1//===-- ClangASTType.cpp ----------------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "lldb/lldb-python.h" 11 12#include "lldb/Symbol/ClangASTType.h" 13 14#include "clang/AST/ASTConsumer.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Attr.h" 17#include "clang/AST/CXXInheritance.h" 18#include "clang/AST/Decl.h" 19#include "clang/AST/DeclCXX.h" 20#include "clang/AST/DeclObjC.h" 21#include "clang/AST/DeclGroup.h" 22#include "clang/AST/DeclTemplate.h" 23#include "clang/AST/RecordLayout.h" 24#include "clang/AST/Type.h" 25 26#include "clang/Basic/Builtins.h" 27#include "clang/Basic/IdentifierTable.h" 28#include "clang/Basic/LangOptions.h" 29#include "clang/Basic/SourceManager.h" 30#include "clang/Basic/TargetInfo.h" 31 32#include "llvm/Support/FormattedStream.h" 33#include "llvm/Support/raw_ostream.h" 34 35#include "lldb/Core/ConstString.h" 36#include "lldb/Core/DataBufferHeap.h" 37#include "lldb/Core/DataExtractor.h" 38#include "lldb/Core/Debugger.h" 39#include "lldb/Core/Scalar.h" 40#include "lldb/Core/Stream.h" 41#include "lldb/Core/StreamFile.h" 42#include "lldb/Core/StreamString.h" 43#include "lldb/Symbol/ClangASTContext.h" 44#include "lldb/Symbol/ClangExternalASTSourceCommon.h" 45#include "lldb/Symbol/VerifyDecl.h" 46#include "lldb/Target/ExecutionContext.h" 47#include "lldb/Target/Process.h" 48 49#include <mutex> 50 51using namespace lldb; 52using namespace lldb_private; 53using namespace clang; 54using namespace llvm; 55 56static bool 57GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion = true) 58{ 59 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 60 switch (type_class) 61 { 62 case clang::Type::ConstantArray: 63 case clang::Type::IncompleteArray: 64 case clang::Type::VariableArray: 65 { 66 const ArrayType *array_type = dyn_cast<ArrayType>(qual_type.getTypePtr()); 67 68 if (array_type) 69 return GetCompleteQualType (ast, array_type->getElementType(), allow_completion); 70 } 71 break; 72 73 case clang::Type::Record: 74 case clang::Type::Enum: 75 { 76 const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr()); 77 if (tag_type) 78 { 79 TagDecl *tag_decl = tag_type->getDecl(); 80 if (tag_decl) 81 { 82 if (tag_decl->isCompleteDefinition()) 83 return true; 84 85 if (!allow_completion) 86 return false; 87 88 if (tag_decl->hasExternalLexicalStorage()) 89 { 90 if (ast) 91 { 92 ExternalASTSource *external_ast_source = ast->getExternalSource(); 93 if (external_ast_source) 94 { 95 external_ast_source->CompleteType(tag_decl); 96 return !tag_type->isIncompleteType(); 97 } 98 } 99 } 100 return false; 101 } 102 } 103 104 } 105 break; 106 107 case clang::Type::ObjCObject: 108 case clang::Type::ObjCInterface: 109 { 110 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type); 111 if (objc_class_type) 112 { 113 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 114 // We currently can't complete objective C types through the newly added ASTContext 115 // because it only supports TagDecl objects right now... 116 if (class_interface_decl) 117 { 118 if (class_interface_decl->getDefinition()) 119 return true; 120 121 if (!allow_completion) 122 return false; 123 124 if (class_interface_decl->hasExternalLexicalStorage()) 125 { 126 if (ast) 127 { 128 ExternalASTSource *external_ast_source = ast->getExternalSource(); 129 if (external_ast_source) 130 { 131 external_ast_source->CompleteType (class_interface_decl); 132 return !objc_class_type->isIncompleteType(); 133 } 134 } 135 } 136 return false; 137 } 138 } 139 } 140 break; 141 142 case clang::Type::Typedef: 143 return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion); 144 145 case clang::Type::Elaborated: 146 return GetCompleteQualType (ast, cast<ElaboratedType>(qual_type)->getNamedType(), allow_completion); 147 148 case clang::Type::Paren: 149 return GetCompleteQualType (ast, cast<ParenType>(qual_type)->desugar(), allow_completion); 150 151 default: 152 break; 153 } 154 155 return true; 156} 157 158static ObjCIvarDecl::AccessControl 159ConvertAccessTypeToObjCIvarAccessControl (AccessType access) 160{ 161 switch (access) 162 { 163 case eAccessNone: return ObjCIvarDecl::None; 164 case eAccessPublic: return ObjCIvarDecl::Public; 165 case eAccessPrivate: return ObjCIvarDecl::Private; 166 case eAccessProtected: return ObjCIvarDecl::Protected; 167 case eAccessPackage: return ObjCIvarDecl::Package; 168 } 169 return ObjCIvarDecl::None; 170} 171 172//---------------------------------------------------------------------- 173// Tests 174//---------------------------------------------------------------------- 175 176ClangASTType::ClangASTType (clang::ASTContext *ast, 177 clang::QualType qual_type) : 178 m_type (qual_type.getAsOpaquePtr()), 179 m_ast (ast) 180{ 181} 182 183ClangASTType::~ClangASTType() 184{ 185} 186 187//---------------------------------------------------------------------- 188// Tests 189//---------------------------------------------------------------------- 190 191bool 192ClangASTType::IsAggregateType () const 193{ 194 if (!IsValid()) 195 return false; 196 197 QualType qual_type (GetCanonicalQualType()); 198 199 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 200 switch (type_class) 201 { 202 case clang::Type::IncompleteArray: 203 case clang::Type::VariableArray: 204 case clang::Type::ConstantArray: 205 case clang::Type::ExtVector: 206 case clang::Type::Vector: 207 case clang::Type::Record: 208 case clang::Type::ObjCObject: 209 case clang::Type::ObjCInterface: 210 return true; 211 case clang::Type::Elaborated: 212 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsAggregateType(); 213 case clang::Type::Typedef: 214 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType(); 215 case clang::Type::Paren: 216 return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).IsAggregateType(); 217 default: 218 break; 219 } 220 // The clang type does have a value 221 return false; 222} 223 224bool 225ClangASTType::IsArrayType (ClangASTType *element_type_ptr, 226 uint64_t *size, 227 bool *is_incomplete) const 228{ 229 if (IsValid()) 230 { 231 QualType qual_type (GetCanonicalQualType()); 232 233 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 234 switch (type_class) 235 { 236 default: 237 break; 238 239 case clang::Type::ConstantArray: 240 if (element_type_ptr) 241 element_type_ptr->SetClangType (m_ast, cast<ConstantArrayType>(qual_type)->getElementType()); 242 if (size) 243 *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX); 244 return true; 245 246 case clang::Type::IncompleteArray: 247 if (element_type_ptr) 248 element_type_ptr->SetClangType (m_ast, cast<IncompleteArrayType>(qual_type)->getElementType()); 249 if (size) 250 *size = 0; 251 if (is_incomplete) 252 *is_incomplete = true; 253 return true; 254 255 case clang::Type::VariableArray: 256 if (element_type_ptr) 257 element_type_ptr->SetClangType (m_ast, cast<VariableArrayType>(qual_type)->getElementType()); 258 if (size) 259 *size = 0; 260 return true; 261 262 case clang::Type::DependentSizedArray: 263 if (element_type_ptr) 264 element_type_ptr->SetClangType (m_ast, cast<DependentSizedArrayType>(qual_type)->getElementType()); 265 if (size) 266 *size = 0; 267 return true; 268 269 case clang::Type::Typedef: 270 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr, 271 size, 272 is_incomplete); 273 case clang::Type::Elaborated: 274 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsArrayType (element_type_ptr, 275 size, 276 is_incomplete); 277 case clang::Type::Paren: 278 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsArrayType (element_type_ptr, 279 size, 280 is_incomplete); 281 } 282 } 283 if (element_type_ptr) 284 element_type_ptr->Clear(); 285 if (size) 286 *size = 0; 287 if (is_incomplete) 288 *is_incomplete = false; 289 return 0; 290} 291 292bool 293ClangASTType::IsRuntimeGeneratedType () const 294{ 295 if (!IsValid()) 296 return false; 297 298 clang::DeclContext* decl_ctx = GetDeclContextForType(); 299 if (!decl_ctx) 300 return false; 301 302 if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx)) 303 return false; 304 305 clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx); 306 307 ClangASTMetadata* ast_metadata = ClangASTContext::GetMetadata(m_ast, result_iface_decl); 308 if (!ast_metadata) 309 return false; 310 return (ast_metadata->GetISAPtr() != 0); 311} 312 313bool 314ClangASTType::IsCharType () const 315{ 316 if (!IsValid()) 317 return false; 318 return GetQualType().getUnqualifiedType()->isCharType(); 319} 320 321 322bool 323ClangASTType::IsCompleteType () const 324{ 325 if (!IsValid()) 326 return false; 327 const bool allow_completion = false; 328 return GetCompleteQualType (m_ast, GetQualType(), allow_completion); 329} 330 331bool 332ClangASTType::IsConst() const 333{ 334 return GetQualType().isConstQualified(); 335} 336 337bool 338ClangASTType::IsCStringType (uint32_t &length) const 339{ 340 ClangASTType pointee_or_element_clang_type; 341 length = 0; 342 Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type)); 343 344 if (!pointee_or_element_clang_type.IsValid()) 345 return false; 346 347 if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer)) 348 { 349 if (pointee_or_element_clang_type.IsCharType()) 350 { 351 if (type_flags.Test (eTypeIsArray)) 352 { 353 // We know the size of the array and it could be a C string 354 // since it is an array of characters 355 length = cast<ConstantArrayType>(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue(); 356 } 357 return true; 358 359 } 360 } 361 return false; 362} 363 364bool 365ClangASTType::IsFunctionType (bool *is_variadic_ptr) const 366{ 367 if (IsValid()) 368 { 369 QualType qual_type (GetCanonicalQualType()); 370 371 if (qual_type->isFunctionType()) 372 { 373 if (is_variadic_ptr) 374 { 375 const clang::FunctionProtoType *function_proto_type = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); 376 if (function_proto_type) 377 *is_variadic_ptr = function_proto_type->isVariadic(); 378 else 379 *is_variadic_ptr = false; 380 } 381 return true; 382 } 383 384 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 385 switch (type_class) 386 { 387 default: 388 break; 389 case clang::Type::Typedef: 390 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType(); 391 case clang::Type::Elaborated: 392 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionType(); 393 case clang::Type::Paren: 394 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionType(); 395 396 case clang::Type::LValueReference: 397 case clang::Type::RValueReference: 398 { 399 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 400 if (reference_type) 401 return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionType(); 402 } 403 break; 404 } 405 } 406 return false; 407} 408 409size_t 410ClangASTType::GetNumberOfFunctionArguments () const 411{ 412 if (IsValid()) 413 { 414 QualType qual_type (GetCanonicalQualType()); 415 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr()); 416 if (func) 417 return func->getNumArgs(); 418 } 419 return 0; 420} 421 422ClangASTType 423ClangASTType::GetFunctionArgumentAtIndex (const size_t index) 424{ 425 if (IsValid()) 426 { 427 QualType qual_type (GetCanonicalQualType()); 428 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr()); 429 if (func) 430 { 431 if (index < func->getNumArgs()) 432 return ClangASTType(m_ast, func->getArgType(index).getAsOpaquePtr()); 433 } 434 } 435 return ClangASTType(); 436} 437 438bool 439ClangASTType::IsFunctionPointerType () const 440{ 441 if (IsValid()) 442 { 443 QualType qual_type (GetCanonicalQualType()); 444 445 if (qual_type->isFunctionPointerType()) 446 return true; 447 448 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 449 switch (type_class) 450 { 451 default: 452 break; 453 case clang::Type::Typedef: 454 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType(); 455 case clang::Type::Elaborated: 456 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionPointerType(); 457 case clang::Type::Paren: 458 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionPointerType(); 459 460 case clang::Type::LValueReference: 461 case clang::Type::RValueReference: 462 { 463 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 464 if (reference_type) 465 return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionPointerType(); 466 } 467 break; 468 } 469 } 470 return false; 471 472} 473 474bool 475ClangASTType::IsIntegerType (bool &is_signed) const 476{ 477 if (!IsValid()) 478 return false; 479 480 QualType qual_type (GetCanonicalQualType()); 481 const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()); 482 483 if (builtin_type) 484 { 485 if (builtin_type->isInteger()) 486 { 487 is_signed = builtin_type->isSignedInteger(); 488 return true; 489 } 490 } 491 492 return false; 493} 494 495bool 496ClangASTType::IsPointerType (ClangASTType *pointee_type) const 497{ 498 if (IsValid()) 499 { 500 QualType qual_type (GetCanonicalQualType()); 501 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 502 switch (type_class) 503 { 504 case clang::Type::Builtin: 505 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 506 { 507 default: 508 break; 509 case clang::BuiltinType::ObjCId: 510 case clang::BuiltinType::ObjCClass: 511 return true; 512 } 513 return false; 514 case clang::Type::ObjCObjectPointer: 515 if (pointee_type) 516 pointee_type->SetClangType (m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType()); 517 return true; 518 case clang::Type::BlockPointer: 519 if (pointee_type) 520 pointee_type->SetClangType (m_ast, cast<BlockPointerType>(qual_type)->getPointeeType()); 521 return true; 522 case clang::Type::Pointer: 523 if (pointee_type) 524 pointee_type->SetClangType (m_ast, cast<PointerType>(qual_type)->getPointeeType()); 525 return true; 526 case clang::Type::MemberPointer: 527 if (pointee_type) 528 pointee_type->SetClangType (m_ast, cast<MemberPointerType>(qual_type)->getPointeeType()); 529 return true; 530 case clang::Type::Typedef: 531 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type); 532 case clang::Type::Elaborated: 533 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerType(pointee_type); 534 case clang::Type::Paren: 535 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerType(pointee_type); 536 default: 537 break; 538 } 539 } 540 if (pointee_type) 541 pointee_type->Clear(); 542 return false; 543} 544 545 546bool 547ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const 548{ 549 if (IsValid()) 550 { 551 QualType qual_type (GetCanonicalQualType()); 552 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 553 switch (type_class) 554 { 555 case clang::Type::Builtin: 556 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 557 { 558 default: 559 break; 560 case clang::BuiltinType::ObjCId: 561 case clang::BuiltinType::ObjCClass: 562 return true; 563 } 564 return false; 565 case clang::Type::ObjCObjectPointer: 566 if (pointee_type) 567 pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType()); 568 return true; 569 case clang::Type::BlockPointer: 570 if (pointee_type) 571 pointee_type->SetClangType(m_ast, cast<BlockPointerType>(qual_type)->getPointeeType()); 572 return true; 573 case clang::Type::Pointer: 574 if (pointee_type) 575 pointee_type->SetClangType(m_ast, cast<PointerType>(qual_type)->getPointeeType()); 576 return true; 577 case clang::Type::MemberPointer: 578 if (pointee_type) 579 pointee_type->SetClangType(m_ast, cast<MemberPointerType>(qual_type)->getPointeeType()); 580 return true; 581 case clang::Type::LValueReference: 582 if (pointee_type) 583 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 584 return true; 585 case clang::Type::RValueReference: 586 if (pointee_type) 587 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 588 return true; 589 case clang::Type::Typedef: 590 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type); 591 case clang::Type::Elaborated: 592 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type); 593 case clang::Type::Paren: 594 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type); 595 default: 596 break; 597 } 598 } 599 if (pointee_type) 600 pointee_type->Clear(); 601 return false; 602} 603 604 605bool 606ClangASTType::IsReferenceType (ClangASTType *pointee_type) const 607{ 608 if (IsValid()) 609 { 610 QualType qual_type (GetCanonicalQualType()); 611 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 612 613 switch (type_class) 614 { 615 case clang::Type::LValueReference: 616 if (pointee_type) 617 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 618 return true; 619 case clang::Type::RValueReference: 620 if (pointee_type) 621 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 622 return true; 623 case clang::Type::Typedef: 624 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type); 625 case clang::Type::Elaborated: 626 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsReferenceType(pointee_type); 627 case clang::Type::Paren: 628 return ClangASTType(m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsReferenceType(pointee_type); 629 630 default: 631 break; 632 } 633 } 634 if (pointee_type) 635 pointee_type->Clear(); 636 return false; 637} 638 639bool 640ClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const 641{ 642 if (IsValid()) 643 { 644 QualType qual_type (GetCanonicalQualType()); 645 646 if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal())) 647 { 648 clang::BuiltinType::Kind kind = BT->getKind(); 649 if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble) 650 { 651 count = 1; 652 is_complex = false; 653 return true; 654 } 655 } 656 else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal())) 657 { 658 if (ClangASTType (m_ast, CT->getElementType()).IsFloatingPointType (count, is_complex)) 659 { 660 count = 2; 661 is_complex = true; 662 return true; 663 } 664 } 665 else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal())) 666 { 667 if (ClangASTType (m_ast, VT->getElementType()).IsFloatingPointType (count, is_complex)) 668 { 669 count = VT->getNumElements(); 670 is_complex = false; 671 return true; 672 } 673 } 674 } 675 count = 0; 676 is_complex = false; 677 return false; 678} 679 680 681bool 682ClangASTType::IsDefined() const 683{ 684 if (!IsValid()) 685 return false; 686 687 QualType qual_type(GetQualType()); 688 const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr()); 689 if (tag_type) 690 { 691 TagDecl *tag_decl = tag_type->getDecl(); 692 if (tag_decl) 693 return tag_decl->isCompleteDefinition(); 694 return false; 695 } 696 else 697 { 698 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type); 699 if (objc_class_type) 700 { 701 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 702 if (class_interface_decl) 703 return class_interface_decl->getDefinition() != NULL; 704 return false; 705 } 706 } 707 return true; 708} 709 710bool 711ClangASTType::IsObjCClassType () const 712{ 713 if (IsValid()) 714 { 715 QualType qual_type (GetCanonicalQualType()); 716 717 const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type); 718 719 if (obj_pointer_type) 720 return obj_pointer_type->isObjCClassType(); 721 } 722 return false; 723} 724 725bool 726ClangASTType::IsObjCObjectOrInterfaceType () const 727{ 728 if (IsValid()) 729 return GetCanonicalQualType()->isObjCObjectOrInterfaceType(); 730 return false; 731} 732 733bool 734ClangASTType::IsPolymorphicClass () const 735{ 736 if (IsValid()) 737 { 738 QualType qual_type(GetCanonicalQualType()); 739 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 740 switch (type_class) 741 { 742 case clang::Type::Record: 743 if (GetCompleteType()) 744 { 745 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 746 const RecordDecl *record_decl = record_type->getDecl(); 747 if (record_decl) 748 { 749 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 750 if (cxx_record_decl) 751 return cxx_record_decl->isPolymorphic(); 752 } 753 } 754 break; 755 756 default: 757 break; 758 } 759 } 760 return false; 761} 762 763bool 764ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type, 765 bool check_cplusplus, 766 bool check_objc) const 767{ 768 QualType pointee_qual_type; 769 if (m_type) 770 { 771 QualType qual_type (GetCanonicalQualType()); 772 bool success = false; 773 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 774 switch (type_class) 775 { 776 case clang::Type::Builtin: 777 if (check_objc && cast<BuiltinType>(qual_type)->getKind() == BuiltinType::ObjCId) 778 { 779 if (dynamic_pointee_type) 780 dynamic_pointee_type->SetClangType(m_ast, m_type); 781 return true; 782 } 783 break; 784 785 case clang::Type::ObjCObjectPointer: 786 if (check_objc) 787 { 788 if (dynamic_pointee_type) 789 dynamic_pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType()); 790 return true; 791 } 792 break; 793 794 case clang::Type::Pointer: 795 pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType(); 796 success = true; 797 break; 798 799 case clang::Type::LValueReference: 800 case clang::Type::RValueReference: 801 pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType(); 802 success = true; 803 break; 804 805 case clang::Type::Typedef: 806 return ClangASTType (m_ast, 807 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type, 808 check_cplusplus, 809 check_objc); 810 811 case clang::Type::Elaborated: 812 return ClangASTType (m_ast, 813 cast<ElaboratedType>(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type, 814 check_cplusplus, 815 check_objc); 816 817 case clang::Type::Paren: 818 return ClangASTType (m_ast, 819 cast<ParenType>(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type, 820 check_cplusplus, 821 check_objc); 822 default: 823 break; 824 } 825 826 if (success) 827 { 828 // Check to make sure what we are pointing too is a possible dynamic C++ type 829 // We currently accept any "void *" (in case we have a class that has been 830 // watered down to an opaque pointer) and virtual C++ classes. 831 const clang::Type::TypeClass pointee_type_class = pointee_qual_type.getCanonicalType()->getTypeClass(); 832 switch (pointee_type_class) 833 { 834 case clang::Type::Builtin: 835 switch (cast<BuiltinType>(pointee_qual_type)->getKind()) 836 { 837 case BuiltinType::UnknownAny: 838 case BuiltinType::Void: 839 if (dynamic_pointee_type) 840 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type); 841 return true; 842 843 case BuiltinType::NullPtr: 844 case BuiltinType::Bool: 845 case BuiltinType::Char_U: 846 case BuiltinType::UChar: 847 case BuiltinType::WChar_U: 848 case BuiltinType::Char16: 849 case BuiltinType::Char32: 850 case BuiltinType::UShort: 851 case BuiltinType::UInt: 852 case BuiltinType::ULong: 853 case BuiltinType::ULongLong: 854 case BuiltinType::UInt128: 855 case BuiltinType::Char_S: 856 case BuiltinType::SChar: 857 case BuiltinType::WChar_S: 858 case BuiltinType::Short: 859 case BuiltinType::Int: 860 case BuiltinType::Long: 861 case BuiltinType::LongLong: 862 case BuiltinType::Int128: 863 case BuiltinType::Float: 864 case BuiltinType::Double: 865 case BuiltinType::LongDouble: 866 case BuiltinType::Dependent: 867 case BuiltinType::Overload: 868 case BuiltinType::ObjCId: 869 case BuiltinType::ObjCClass: 870 case BuiltinType::ObjCSel: 871 case BuiltinType::BoundMember: 872 case BuiltinType::Half: 873 case BuiltinType::ARCUnbridgedCast: 874 case BuiltinType::PseudoObject: 875 case BuiltinType::BuiltinFn: 876 case BuiltinType::OCLEvent: 877 case BuiltinType::OCLImage1d: 878 case BuiltinType::OCLImage1dArray: 879 case BuiltinType::OCLImage1dBuffer: 880 case BuiltinType::OCLImage2d: 881 case BuiltinType::OCLImage2dArray: 882 case BuiltinType::OCLImage3d: 883 case BuiltinType::OCLSampler: 884 break; 885 } 886 break; 887 888 case clang::Type::Record: 889 if (check_cplusplus) 890 { 891 CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl(); 892 if (cxx_record_decl) 893 { 894 bool is_complete = cxx_record_decl->isCompleteDefinition(); 895 896 if (is_complete) 897 success = cxx_record_decl->isDynamicClass(); 898 else 899 { 900 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, cxx_record_decl); 901 if (metadata) 902 success = metadata->GetIsDynamicCXXType(); 903 else 904 { 905 is_complete = ClangASTType(m_ast, pointee_qual_type).GetCompleteType(); 906 if (is_complete) 907 success = cxx_record_decl->isDynamicClass(); 908 else 909 success = false; 910 } 911 } 912 913 if (success) 914 { 915 if (dynamic_pointee_type) 916 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type); 917 return true; 918 } 919 } 920 } 921 break; 922 923 case clang::Type::ObjCObject: 924 case clang::Type::ObjCInterface: 925 if (check_objc) 926 { 927 if (dynamic_pointee_type) 928 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type); 929 return true; 930 } 931 break; 932 933 default: 934 break; 935 } 936 } 937 } 938 if (dynamic_pointee_type) 939 dynamic_pointee_type->Clear(); 940 return false; 941} 942 943 944bool 945ClangASTType::IsScalarType () const 946{ 947 if (!IsValid()) 948 return false; 949 950 return (GetTypeInfo (NULL) & eTypeIsScalar) != 0; 951} 952 953bool 954ClangASTType::IsTypedefType () const 955{ 956 if (!IsValid()) 957 return false; 958 return GetQualType()->getTypeClass() == clang::Type::Typedef; 959} 960 961bool 962ClangASTType::IsVoidType () const 963{ 964 if (!IsValid()) 965 return false; 966 return GetCanonicalQualType()->isVoidType(); 967} 968 969bool 970ClangASTType::IsPointerToScalarType () const 971{ 972 if (!IsValid()) 973 return false; 974 975 return IsPointerType() && GetPointeeType().IsScalarType(); 976} 977 978bool 979ClangASTType::IsArrayOfScalarType () const 980{ 981 ClangASTType element_type; 982 if (IsArrayType(&element_type, NULL, NULL)) 983 return element_type.IsScalarType(); 984 return false; 985} 986 987 988bool 989ClangASTType::GetCXXClassName (std::string &class_name) const 990{ 991 if (IsValid()) 992 { 993 QualType qual_type (GetCanonicalQualType()); 994 995 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 996 if (cxx_record_decl) 997 { 998 class_name.assign (cxx_record_decl->getIdentifier()->getNameStart()); 999 return true; 1000 } 1001 } 1002 class_name.clear(); 1003 return false; 1004} 1005 1006 1007bool 1008ClangASTType::IsCXXClassType () const 1009{ 1010 if (!IsValid()) 1011 return false; 1012 1013 QualType qual_type (GetCanonicalQualType()); 1014 if (qual_type->getAsCXXRecordDecl() != NULL) 1015 return true; 1016 return false; 1017} 1018 1019bool 1020ClangASTType::IsBeingDefined () const 1021{ 1022 if (!IsValid()) 1023 return false; 1024 QualType qual_type (GetCanonicalQualType()); 1025 const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type); 1026 if (tag_type) 1027 return tag_type->isBeingDefined(); 1028 return false; 1029} 1030 1031bool 1032ClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr) 1033{ 1034 if (!IsValid()) 1035 return false; 1036 1037 QualType qual_type (GetCanonicalQualType()); 1038 1039 if (qual_type->isObjCObjectPointerType()) 1040 { 1041 if (class_type_ptr) 1042 { 1043 if (!qual_type->isObjCClassType() && 1044 !qual_type->isObjCIdType()) 1045 { 1046 const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type); 1047 if (obj_pointer_type == NULL) 1048 class_type_ptr->Clear(); 1049 else 1050 class_type_ptr->SetClangType (m_ast, QualType(obj_pointer_type->getInterfaceType(), 0)); 1051 } 1052 } 1053 return true; 1054 } 1055 if (class_type_ptr) 1056 class_type_ptr->Clear(); 1057 return false; 1058} 1059 1060bool 1061ClangASTType::GetObjCClassName (std::string &class_name) 1062{ 1063 if (!IsValid()) 1064 return false; 1065 1066 QualType qual_type (GetCanonicalQualType()); 1067 1068 const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(qual_type); 1069 if (object_type) 1070 { 1071 const ObjCInterfaceDecl *interface = object_type->getInterface(); 1072 if (interface) 1073 { 1074 class_name = interface->getNameAsString(); 1075 return true; 1076 } 1077 } 1078 return false; 1079} 1080 1081 1082//---------------------------------------------------------------------- 1083// Type Completion 1084//---------------------------------------------------------------------- 1085 1086bool 1087ClangASTType::GetCompleteType () const 1088{ 1089 if (!IsValid()) 1090 return false; 1091 const bool allow_completion = true; 1092 return GetCompleteQualType (m_ast, GetQualType(), allow_completion); 1093} 1094 1095//---------------------------------------------------------------------- 1096// AST related queries 1097//---------------------------------------------------------------------- 1098size_t 1099ClangASTType::GetPointerByteSize () const 1100{ 1101 if (m_ast) 1102 return m_ast->getTypeSize(m_ast->VoidPtrTy) / 8; 1103 return 0; 1104} 1105 1106ConstString 1107ClangASTType::GetConstQualifiedTypeName () const 1108{ 1109 return GetConstTypeName (); 1110} 1111 1112ConstString 1113ClangASTType::GetConstTypeName () const 1114{ 1115 if (IsValid()) 1116 { 1117 ConstString type_name (GetTypeName()); 1118 if (type_name) 1119 return type_name; 1120 } 1121 return ConstString("<invalid>"); 1122} 1123 1124ConstString 1125ClangASTType::GetTypeName () const 1126{ 1127 std::string type_name; 1128 if (IsValid()) 1129 { 1130 PrintingPolicy printing_policy (m_ast->getPrintingPolicy()); 1131 QualType qual_type(GetQualType()); 1132 printing_policy.SuppressTagKeyword = true; 1133 printing_policy.LangOpts.WChar = true; 1134 const TypedefType *typedef_type = qual_type->getAs<TypedefType>(); 1135 if (typedef_type) 1136 { 1137 const TypedefNameDecl *typedef_decl = typedef_type->getDecl(); 1138 type_name = typedef_decl->getQualifiedNameAsString(); 1139 } 1140 else 1141 { 1142 type_name = qual_type.getAsString(printing_policy); 1143 } 1144 } 1145 return ConstString(type_name); 1146} 1147 1148 1149uint32_t 1150ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const 1151{ 1152 if (!IsValid()) 1153 return 0; 1154 1155 if (pointee_or_element_clang_type) 1156 pointee_or_element_clang_type->Clear(); 1157 1158 QualType qual_type (GetQualType()); 1159 1160 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 1161 switch (type_class) 1162 { 1163 case clang::Type::Builtin: 1164 { 1165 const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()); 1166 1167 uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue; 1168 switch (builtin_type->getKind()) 1169 { 1170 case clang::BuiltinType::ObjCId: 1171 case clang::BuiltinType::ObjCClass: 1172 if (pointee_or_element_clang_type) 1173 pointee_or_element_clang_type->SetClangType(m_ast, m_ast->ObjCBuiltinClassTy); 1174 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; 1175 break; 1176 1177 case clang::BuiltinType::ObjCSel: 1178 if (pointee_or_element_clang_type) 1179 pointee_or_element_clang_type->SetClangType(m_ast, m_ast->CharTy); 1180 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; 1181 break; 1182 1183 case clang::BuiltinType::Bool: 1184 case clang::BuiltinType::Char_U: 1185 case clang::BuiltinType::UChar: 1186 case clang::BuiltinType::WChar_U: 1187 case clang::BuiltinType::Char16: 1188 case clang::BuiltinType::Char32: 1189 case clang::BuiltinType::UShort: 1190 case clang::BuiltinType::UInt: 1191 case clang::BuiltinType::ULong: 1192 case clang::BuiltinType::ULongLong: 1193 case clang::BuiltinType::UInt128: 1194 case clang::BuiltinType::Char_S: 1195 case clang::BuiltinType::SChar: 1196 case clang::BuiltinType::WChar_S: 1197 case clang::BuiltinType::Short: 1198 case clang::BuiltinType::Int: 1199 case clang::BuiltinType::Long: 1200 case clang::BuiltinType::LongLong: 1201 case clang::BuiltinType::Int128: 1202 case clang::BuiltinType::Float: 1203 case clang::BuiltinType::Double: 1204 case clang::BuiltinType::LongDouble: 1205 builtin_type_flags |= eTypeIsScalar; 1206 if (builtin_type->isInteger()) 1207 { 1208 builtin_type_flags |= eTypeIsInteger; 1209 if (builtin_type->isSignedInteger()) 1210 builtin_type_flags |= eTypeIsSigned; 1211 } 1212 else if (builtin_type->isFloatingPoint()) 1213 builtin_type_flags |= eTypeIsFloat; 1214 break; 1215 default: 1216 break; 1217 } 1218 return builtin_type_flags; 1219 } 1220 1221 case clang::Type::BlockPointer: 1222 if (pointee_or_element_clang_type) 1223 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType()); 1224 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock; 1225 1226 case clang::Type::Complex: 1227 { 1228 uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex; 1229 const ComplexType *complex_type = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()); 1230 if (complex_type) 1231 { 1232 QualType complex_element_type (complex_type->getElementType()); 1233 if (complex_element_type->isIntegerType()) 1234 complex_type_flags |= eTypeIsFloat; 1235 else if (complex_element_type->isFloatingType()) 1236 complex_type_flags |= eTypeIsInteger; 1237 } 1238 return complex_type_flags; 1239 } 1240 break; 1241 1242 case clang::Type::ConstantArray: 1243 case clang::Type::DependentSizedArray: 1244 case clang::Type::IncompleteArray: 1245 case clang::Type::VariableArray: 1246 if (pointee_or_element_clang_type) 1247 pointee_or_element_clang_type->SetClangType(m_ast, cast<ArrayType>(qual_type.getTypePtr())->getElementType()); 1248 return eTypeHasChildren | eTypeIsArray; 1249 1250 case clang::Type::DependentName: return 0; 1251 case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector; 1252 case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate; 1253 case clang::Type::Decltype: return 0; 1254 1255 case clang::Type::Enum: 1256 if (pointee_or_element_clang_type) 1257 pointee_or_element_clang_type->SetClangType(m_ast, cast<EnumType>(qual_type)->getDecl()->getIntegerType()); 1258 return eTypeIsEnumeration | eTypeHasValue; 1259 1260 case clang::Type::Elaborated: 1261 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type); 1262 case clang::Type::Paren: 1263 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type); 1264 1265 case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue; 1266 case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue; 1267 case clang::Type::InjectedClassName: return 0; 1268 1269 case clang::Type::LValueReference: 1270 case clang::Type::RValueReference: 1271 if (pointee_or_element_clang_type) 1272 pointee_or_element_clang_type->SetClangType(m_ast, cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType()); 1273 return eTypeHasChildren | eTypeIsReference | eTypeHasValue; 1274 1275 case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue; 1276 1277 case clang::Type::ObjCObjectPointer: 1278 if (pointee_or_element_clang_type) 1279 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType()); 1280 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue; 1281 1282 case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; 1283 case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; 1284 1285 case clang::Type::Pointer: 1286 if (pointee_or_element_clang_type) 1287 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType()); 1288 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue; 1289 1290 case clang::Type::Record: 1291 if (qual_type->getAsCXXRecordDecl()) 1292 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus; 1293 else 1294 return eTypeHasChildren | eTypeIsStructUnion; 1295 break; 1296 case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate; 1297 case clang::Type::TemplateTypeParm: return eTypeIsTemplate; 1298 case clang::Type::TemplateSpecialization: return eTypeIsTemplate; 1299 1300 case clang::Type::Typedef: 1301 return eTypeIsTypedef | ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type); 1302 case clang::Type::TypeOfExpr: return 0; 1303 case clang::Type::TypeOf: return 0; 1304 case clang::Type::UnresolvedUsing: return 0; 1305 1306 case clang::Type::ExtVector: 1307 case clang::Type::Vector: 1308 { 1309 uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector; 1310 const VectorType *vector_type = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()); 1311 if (vector_type) 1312 { 1313 if (vector_type->isIntegerType()) 1314 vector_type_flags |= eTypeIsFloat; 1315 else if (vector_type->isFloatingType()) 1316 vector_type_flags |= eTypeIsInteger; 1317 } 1318 return vector_type_flags; 1319 } 1320 default: return 0; 1321 } 1322 return 0; 1323} 1324 1325 1326 1327lldb::LanguageType 1328ClangASTType::GetMinimumLanguage () 1329{ 1330 if (!IsValid()) 1331 return lldb::eLanguageTypeC; 1332 1333 // If the type is a reference, then resolve it to what it refers to first: 1334 QualType qual_type (GetCanonicalQualType().getNonReferenceType()); 1335 if (qual_type->isAnyPointerType()) 1336 { 1337 if (qual_type->isObjCObjectPointerType()) 1338 return lldb::eLanguageTypeObjC; 1339 1340 QualType pointee_type (qual_type->getPointeeType()); 1341 if (pointee_type->getPointeeCXXRecordDecl() != NULL) 1342 return lldb::eLanguageTypeC_plus_plus; 1343 if (pointee_type->isObjCObjectOrInterfaceType()) 1344 return lldb::eLanguageTypeObjC; 1345 if (pointee_type->isObjCClassType()) 1346 return lldb::eLanguageTypeObjC; 1347 if (pointee_type.getTypePtr() == m_ast->ObjCBuiltinIdTy.getTypePtr()) 1348 return lldb::eLanguageTypeObjC; 1349 } 1350 else 1351 { 1352 if (qual_type->isObjCObjectOrInterfaceType()) 1353 return lldb::eLanguageTypeObjC; 1354 if (qual_type->getAsCXXRecordDecl()) 1355 return lldb::eLanguageTypeC_plus_plus; 1356 switch (qual_type->getTypeClass()) 1357 { 1358 default: 1359 break; 1360 case clang::Type::Builtin: 1361 switch (cast<BuiltinType>(qual_type)->getKind()) 1362 { 1363 default: 1364 case BuiltinType::Void: 1365 case BuiltinType::Bool: 1366 case BuiltinType::Char_U: 1367 case BuiltinType::UChar: 1368 case BuiltinType::WChar_U: 1369 case BuiltinType::Char16: 1370 case BuiltinType::Char32: 1371 case BuiltinType::UShort: 1372 case BuiltinType::UInt: 1373 case BuiltinType::ULong: 1374 case BuiltinType::ULongLong: 1375 case BuiltinType::UInt128: 1376 case BuiltinType::Char_S: 1377 case BuiltinType::SChar: 1378 case BuiltinType::WChar_S: 1379 case BuiltinType::Short: 1380 case BuiltinType::Int: 1381 case BuiltinType::Long: 1382 case BuiltinType::LongLong: 1383 case BuiltinType::Int128: 1384 case BuiltinType::Float: 1385 case BuiltinType::Double: 1386 case BuiltinType::LongDouble: 1387 break; 1388 1389 case BuiltinType::NullPtr: 1390 return eLanguageTypeC_plus_plus; 1391 1392 case BuiltinType::ObjCId: 1393 case BuiltinType::ObjCClass: 1394 case BuiltinType::ObjCSel: 1395 return eLanguageTypeObjC; 1396 1397 case BuiltinType::Dependent: 1398 case BuiltinType::Overload: 1399 case BuiltinType::BoundMember: 1400 case BuiltinType::UnknownAny: 1401 break; 1402 } 1403 break; 1404 case clang::Type::Typedef: 1405 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage(); 1406 } 1407 } 1408 return lldb::eLanguageTypeC; 1409} 1410 1411lldb::TypeClass 1412ClangASTType::GetTypeClass () const 1413{ 1414 if (!IsValid()) 1415 return lldb::eTypeClassInvalid; 1416 1417 QualType qual_type(GetQualType()); 1418 1419 switch (qual_type->getTypeClass()) 1420 { 1421 case clang::Type::UnaryTransform: break; 1422 case clang::Type::FunctionNoProto: return lldb::eTypeClassFunction; 1423 case clang::Type::FunctionProto: return lldb::eTypeClassFunction; 1424 case clang::Type::IncompleteArray: return lldb::eTypeClassArray; 1425 case clang::Type::VariableArray: return lldb::eTypeClassArray; 1426 case clang::Type::ConstantArray: return lldb::eTypeClassArray; 1427 case clang::Type::DependentSizedArray: return lldb::eTypeClassArray; 1428 case clang::Type::DependentSizedExtVector: return lldb::eTypeClassVector; 1429 case clang::Type::ExtVector: return lldb::eTypeClassVector; 1430 case clang::Type::Vector: return lldb::eTypeClassVector; 1431 case clang::Type::Builtin: return lldb::eTypeClassBuiltin; 1432 case clang::Type::ObjCObjectPointer: return lldb::eTypeClassObjCObjectPointer; 1433 case clang::Type::BlockPointer: return lldb::eTypeClassBlockPointer; 1434 case clang::Type::Pointer: return lldb::eTypeClassPointer; 1435 case clang::Type::LValueReference: return lldb::eTypeClassReference; 1436 case clang::Type::RValueReference: return lldb::eTypeClassReference; 1437 case clang::Type::MemberPointer: return lldb::eTypeClassMemberPointer; 1438 case clang::Type::Complex: 1439 if (qual_type->isComplexType()) 1440 return lldb::eTypeClassComplexFloat; 1441 else 1442 return lldb::eTypeClassComplexInteger; 1443 case clang::Type::ObjCObject: return lldb::eTypeClassObjCObject; 1444 case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface; 1445 case clang::Type::Record: 1446 { 1447 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 1448 const RecordDecl *record_decl = record_type->getDecl(); 1449 if (record_decl->isUnion()) 1450 return lldb::eTypeClassUnion; 1451 else if (record_decl->isStruct()) 1452 return lldb::eTypeClassStruct; 1453 else 1454 return lldb::eTypeClassClass; 1455 } 1456 break; 1457 case clang::Type::Enum: return lldb::eTypeClassEnumeration; 1458 case clang::Type::Typedef: return lldb::eTypeClassTypedef; 1459 case clang::Type::UnresolvedUsing: break; 1460 case clang::Type::Paren: 1461 return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetTypeClass(); 1462 case clang::Type::Elaborated: 1463 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeClass(); 1464 1465 case clang::Type::Attributed: break; 1466 case clang::Type::TemplateTypeParm: break; 1467 case clang::Type::SubstTemplateTypeParm: break; 1468 case clang::Type::SubstTemplateTypeParmPack:break; 1469 case clang::Type::Auto: break; 1470 case clang::Type::InjectedClassName: break; 1471 case clang::Type::DependentName: break; 1472 case clang::Type::DependentTemplateSpecialization: break; 1473 case clang::Type::PackExpansion: break; 1474 1475 case clang::Type::TypeOfExpr: break; 1476 case clang::Type::TypeOf: break; 1477 case clang::Type::Decltype: break; 1478 case clang::Type::TemplateSpecialization: break; 1479 case clang::Type::Atomic: break; 1480 1481 // pointer type decayed from an array or function type. 1482 case clang::Type::Decayed: break; 1483 } 1484 // We don't know hot to display this type... 1485 return lldb::eTypeClassOther; 1486 1487} 1488 1489void 1490ClangASTType::SetClangType (clang::ASTContext *ast, clang::QualType qual_type) 1491{ 1492 m_ast = ast; 1493 m_type = qual_type.getAsOpaquePtr(); 1494} 1495 1496unsigned 1497ClangASTType::GetTypeQualifiers() const 1498{ 1499 if (IsValid()) 1500 return GetQualType().getQualifiers().getCVRQualifiers(); 1501 return 0; 1502} 1503 1504//---------------------------------------------------------------------- 1505// Creating related types 1506//---------------------------------------------------------------------- 1507 1508ClangASTType 1509ClangASTType::AddConstModifier () const 1510{ 1511 if (m_type) 1512 { 1513 QualType result(GetQualType()); 1514 result.addConst(); 1515 return ClangASTType (m_ast, result); 1516 } 1517 return ClangASTType(); 1518} 1519 1520ClangASTType 1521ClangASTType::AddRestrictModifier () const 1522{ 1523 if (m_type) 1524 { 1525 QualType result(GetQualType()); 1526 result.getQualifiers().setRestrict (true); 1527 return ClangASTType (m_ast, result); 1528 } 1529 return ClangASTType(); 1530} 1531 1532ClangASTType 1533ClangASTType::AddVolatileModifier () const 1534{ 1535 if (m_type) 1536 { 1537 QualType result(GetQualType()); 1538 result.getQualifiers().setVolatile (true); 1539 return ClangASTType (m_ast, result); 1540 } 1541 return ClangASTType(); 1542} 1543 1544ClangASTType 1545ClangASTType::GetArrayElementType (uint64_t& stride) const 1546{ 1547 if (IsValid()) 1548 { 1549 QualType qual_type(GetCanonicalQualType()); 1550 1551 ClangASTType element_type (m_ast, qual_type.getTypePtr()->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified()); 1552 1553 // TODO: the real stride will be >= this value.. find the real one! 1554 stride = element_type.GetByteSize(); 1555 1556 return element_type; 1557 1558 } 1559 return ClangASTType(); 1560} 1561 1562ClangASTType 1563ClangASTType::GetCanonicalType () const 1564{ 1565 if (IsValid()) 1566 return ClangASTType (m_ast, GetCanonicalQualType()); 1567 return ClangASTType(); 1568} 1569 1570static QualType 1571GetFullyUnqualifiedType_Impl (ASTContext *ast, QualType qual_type) 1572{ 1573 if (qual_type->isPointerType()) 1574 qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType())); 1575 else 1576 qual_type = qual_type.getUnqualifiedType(); 1577 qual_type.removeLocalConst(); 1578 qual_type.removeLocalRestrict(); 1579 qual_type.removeLocalVolatile(); 1580 return qual_type; 1581} 1582 1583ClangASTType 1584ClangASTType::GetFullyUnqualifiedType () const 1585{ 1586 if (IsValid()) 1587 return ClangASTType(m_ast, GetFullyUnqualifiedType_Impl(m_ast, GetQualType())); 1588 return ClangASTType(); 1589} 1590 1591 1592int 1593ClangASTType::GetFunctionArgumentCount () const 1594{ 1595 if (IsValid()) 1596 { 1597 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType()); 1598 if (func) 1599 return func->getNumArgs(); 1600 } 1601 return -1; 1602} 1603 1604ClangASTType 1605ClangASTType::GetFunctionArgumentTypeAtIndex (size_t idx) 1606{ 1607 if (IsValid()) 1608 { 1609 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType()); 1610 if (func) 1611 { 1612 const uint32_t num_args = func->getNumArgs(); 1613 if (idx < num_args) 1614 return ClangASTType(m_ast, func->getArgType(idx)); 1615 } 1616 } 1617 return ClangASTType(); 1618} 1619 1620ClangASTType 1621ClangASTType::GetFunctionReturnType () const 1622{ 1623 if (IsValid()) 1624 { 1625 QualType qual_type(GetCanonicalQualType()); 1626 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr()); 1627 if (func) 1628 return ClangASTType(m_ast, func->getResultType()); 1629 } 1630 return ClangASTType(); 1631} 1632 1633 1634ClangASTType 1635ClangASTType::GetLValueReferenceType () const 1636{ 1637 if (IsValid()) 1638 { 1639 return ClangASTType(m_ast, m_ast->getLValueReferenceType(GetQualType())); 1640 } 1641 return ClangASTType(); 1642} 1643 1644ClangASTType 1645ClangASTType::GetRValueReferenceType () const 1646{ 1647 if (IsValid()) 1648 { 1649 return ClangASTType(m_ast, m_ast->getRValueReferenceType(GetQualType())); 1650 } 1651 return ClangASTType(); 1652} 1653 1654ClangASTType 1655ClangASTType::GetNonReferenceType () const 1656{ 1657 if (IsValid()) 1658 return ClangASTType(m_ast, GetQualType().getNonReferenceType()); 1659 return ClangASTType(); 1660} 1661 1662ClangASTType 1663ClangASTType::CreateTypedefType (const char *typedef_name, 1664 clang::DeclContext *decl_ctx) const 1665{ 1666 if (IsValid() && typedef_name && typedef_name[0]) 1667 { 1668 QualType qual_type (GetQualType()); 1669 if (decl_ctx == NULL) 1670 decl_ctx = m_ast->getTranslationUnitDecl(); 1671 TypedefDecl *decl = TypedefDecl::Create (*m_ast, 1672 decl_ctx, 1673 SourceLocation(), 1674 SourceLocation(), 1675 &m_ast->Idents.get(typedef_name), 1676 m_ast->getTrivialTypeSourceInfo(qual_type)); 1677 1678 decl->setAccess(AS_public); // TODO respect proper access specifier 1679 1680 // Get a uniqued QualType for the typedef decl type 1681 return ClangASTType (m_ast, m_ast->getTypedefType (decl)); 1682 } 1683 return ClangASTType(); 1684 1685} 1686 1687ClangASTType 1688ClangASTType::GetPointeeType () const 1689{ 1690 if (m_type) 1691 { 1692 QualType qual_type(GetQualType()); 1693 return ClangASTType (m_ast, qual_type.getTypePtr()->getPointeeType()); 1694 } 1695 return ClangASTType(); 1696} 1697 1698ClangASTType 1699ClangASTType::GetPointerType () const 1700{ 1701 if (IsValid()) 1702 { 1703 QualType qual_type (GetQualType()); 1704 1705 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 1706 switch (type_class) 1707 { 1708 case clang::Type::ObjCObject: 1709 case clang::Type::ObjCInterface: 1710 return ClangASTType(m_ast, m_ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr()); 1711 1712 default: 1713 return ClangASTType(m_ast, m_ast->getPointerType(qual_type).getAsOpaquePtr()); 1714 } 1715 } 1716 return ClangASTType(); 1717} 1718 1719ClangASTType 1720ClangASTType::GetTypedefedType () const 1721{ 1722 if (IsValid()) 1723 { 1724 const TypedefType *typedef_type = dyn_cast<TypedefType>(GetQualType()); 1725 if (typedef_type) 1726 return ClangASTType (m_ast, typedef_type->getDecl()->getUnderlyingType()); 1727 } 1728 return ClangASTType(); 1729} 1730 1731ClangASTType 1732ClangASTType::RemoveFastQualifiers () const 1733{ 1734 if (m_type) 1735 { 1736 QualType qual_type(GetQualType()); 1737 qual_type.getQualifiers().removeFastQualifiers(); 1738 return ClangASTType (m_ast, qual_type); 1739 } 1740 return ClangASTType(); 1741} 1742 1743 1744//---------------------------------------------------------------------- 1745// Create related types using the current type's AST 1746//---------------------------------------------------------------------- 1747 1748ClangASTType 1749ClangASTType::GetBasicTypeFromAST (lldb::BasicType basic_type) const 1750{ 1751 if (IsValid()) 1752 return ClangASTContext::GetBasicType(m_ast, basic_type); 1753 return ClangASTType(); 1754} 1755//---------------------------------------------------------------------- 1756// Exploring the type 1757//---------------------------------------------------------------------- 1758 1759uint64_t 1760ClangASTType::GetBitSize () const 1761{ 1762 if (GetCompleteType ()) 1763 { 1764 QualType qual_type(GetCanonicalQualType()); 1765 const uint32_t bit_size = m_ast->getTypeSize (qual_type); 1766 if (bit_size == 0) 1767 { 1768 if (qual_type->isIncompleteArrayType()) 1769 return m_ast->getTypeSize (qual_type->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified()); 1770 } 1771 if (qual_type->isObjCObjectOrInterfaceType()) 1772 return bit_size + m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy); 1773 return bit_size; 1774 } 1775 return 0; 1776} 1777 1778uint64_t 1779ClangASTType::GetByteSize () const 1780{ 1781 return (GetBitSize () + 7) / 8; 1782} 1783 1784size_t 1785ClangASTType::GetTypeBitAlign () const 1786{ 1787 if (GetCompleteType ()) 1788 return m_ast->getTypeAlign(GetQualType()); 1789 return 0; 1790} 1791 1792 1793lldb::Encoding 1794ClangASTType::GetEncoding (uint64_t &count) const 1795{ 1796 if (!IsValid()) 1797 return lldb::eEncodingInvalid; 1798 1799 count = 1; 1800 QualType qual_type(GetCanonicalQualType()); 1801 1802 switch (qual_type->getTypeClass()) 1803 { 1804 case clang::Type::UnaryTransform: 1805 break; 1806 1807 case clang::Type::FunctionNoProto: 1808 case clang::Type::FunctionProto: 1809 break; 1810 1811 case clang::Type::IncompleteArray: 1812 case clang::Type::VariableArray: 1813 break; 1814 1815 case clang::Type::ConstantArray: 1816 break; 1817 1818 case clang::Type::ExtVector: 1819 case clang::Type::Vector: 1820 // TODO: Set this to more than one??? 1821 break; 1822 1823 case clang::Type::Builtin: 1824 switch (cast<BuiltinType>(qual_type)->getKind()) 1825 { 1826 default: assert(0 && "Unknown builtin type!"); 1827 case BuiltinType::Void: 1828 break; 1829 1830 case BuiltinType::Bool: 1831 case BuiltinType::Char_S: 1832 case BuiltinType::SChar: 1833 case BuiltinType::WChar_S: 1834 case BuiltinType::Char16: 1835 case BuiltinType::Char32: 1836 case BuiltinType::Short: 1837 case BuiltinType::Int: 1838 case BuiltinType::Long: 1839 case BuiltinType::LongLong: 1840 case BuiltinType::Int128: return lldb::eEncodingSint; 1841 1842 case BuiltinType::Char_U: 1843 case BuiltinType::UChar: 1844 case BuiltinType::WChar_U: 1845 case BuiltinType::UShort: 1846 case BuiltinType::UInt: 1847 case BuiltinType::ULong: 1848 case BuiltinType::ULongLong: 1849 case BuiltinType::UInt128: return lldb::eEncodingUint; 1850 1851 case BuiltinType::Float: 1852 case BuiltinType::Double: 1853 case BuiltinType::LongDouble: return lldb::eEncodingIEEE754; 1854 1855 case BuiltinType::ObjCClass: 1856 case BuiltinType::ObjCId: 1857 case BuiltinType::ObjCSel: return lldb::eEncodingUint; 1858 1859 case BuiltinType::NullPtr: return lldb::eEncodingUint; 1860 } 1861 break; 1862 // All pointer types are represented as unsigned integer encodings. 1863 // We may nee to add a eEncodingPointer if we ever need to know the 1864 // difference 1865 case clang::Type::ObjCObjectPointer: 1866 case clang::Type::BlockPointer: 1867 case clang::Type::Pointer: 1868 case clang::Type::LValueReference: 1869 case clang::Type::RValueReference: 1870 case clang::Type::MemberPointer: return lldb::eEncodingUint; 1871 case clang::Type::Complex: 1872 { 1873 lldb::Encoding encoding = lldb::eEncodingIEEE754; 1874 if (qual_type->isComplexType()) 1875 encoding = lldb::eEncodingIEEE754; 1876 else 1877 { 1878 const ComplexType *complex_type = qual_type->getAsComplexIntegerType(); 1879 if (complex_type) 1880 encoding = ClangASTType(m_ast, complex_type->getElementType()).GetEncoding(count); 1881 else 1882 encoding = lldb::eEncodingSint; 1883 } 1884 count = 2; 1885 return encoding; 1886 } 1887 1888 case clang::Type::ObjCInterface: break; 1889 case clang::Type::Record: break; 1890 case clang::Type::Enum: return lldb::eEncodingSint; 1891 case clang::Type::Typedef: 1892 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count); 1893 1894 case clang::Type::Elaborated: 1895 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count); 1896 1897 case clang::Type::Paren: 1898 return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetEncoding(count); 1899 1900 case clang::Type::DependentSizedArray: 1901 case clang::Type::DependentSizedExtVector: 1902 case clang::Type::UnresolvedUsing: 1903 case clang::Type::Attributed: 1904 case clang::Type::TemplateTypeParm: 1905 case clang::Type::SubstTemplateTypeParm: 1906 case clang::Type::SubstTemplateTypeParmPack: 1907 case clang::Type::Auto: 1908 case clang::Type::InjectedClassName: 1909 case clang::Type::DependentName: 1910 case clang::Type::DependentTemplateSpecialization: 1911 case clang::Type::PackExpansion: 1912 case clang::Type::ObjCObject: 1913 1914 case clang::Type::TypeOfExpr: 1915 case clang::Type::TypeOf: 1916 case clang::Type::Decltype: 1917 case clang::Type::TemplateSpecialization: 1918 case clang::Type::Atomic: 1919 break; 1920 1921 // pointer type decayed from an array or function type. 1922 case clang::Type::Decayed: 1923 break; 1924 } 1925 count = 0; 1926 return lldb::eEncodingInvalid; 1927} 1928 1929lldb::Format 1930ClangASTType::GetFormat () const 1931{ 1932 if (!IsValid()) 1933 return lldb::eFormatDefault; 1934 1935 QualType qual_type(GetCanonicalQualType()); 1936 1937 switch (qual_type->getTypeClass()) 1938 { 1939 case clang::Type::UnaryTransform: 1940 break; 1941 1942 case clang::Type::FunctionNoProto: 1943 case clang::Type::FunctionProto: 1944 break; 1945 1946 case clang::Type::IncompleteArray: 1947 case clang::Type::VariableArray: 1948 break; 1949 1950 case clang::Type::ConstantArray: 1951 return lldb::eFormatVoid; // no value 1952 1953 case clang::Type::ExtVector: 1954 case clang::Type::Vector: 1955 break; 1956 1957 case clang::Type::Builtin: 1958 switch (cast<BuiltinType>(qual_type)->getKind()) 1959 { 1960 //default: assert(0 && "Unknown builtin type!"); 1961 case BuiltinType::UnknownAny: 1962 case BuiltinType::Void: 1963 case BuiltinType::BoundMember: 1964 break; 1965 1966 case BuiltinType::Bool: return lldb::eFormatBoolean; 1967 case BuiltinType::Char_S: 1968 case BuiltinType::SChar: 1969 case BuiltinType::WChar_S: 1970 case BuiltinType::Char_U: 1971 case BuiltinType::UChar: 1972 case BuiltinType::WChar_U: return lldb::eFormatChar; 1973 case BuiltinType::Char16: return lldb::eFormatUnicode16; 1974 case BuiltinType::Char32: return lldb::eFormatUnicode32; 1975 case BuiltinType::UShort: return lldb::eFormatUnsigned; 1976 case BuiltinType::Short: return lldb::eFormatDecimal; 1977 case BuiltinType::UInt: return lldb::eFormatUnsigned; 1978 case BuiltinType::Int: return lldb::eFormatDecimal; 1979 case BuiltinType::ULong: return lldb::eFormatUnsigned; 1980 case BuiltinType::Long: return lldb::eFormatDecimal; 1981 case BuiltinType::ULongLong: return lldb::eFormatUnsigned; 1982 case BuiltinType::LongLong: return lldb::eFormatDecimal; 1983 case BuiltinType::UInt128: return lldb::eFormatUnsigned; 1984 case BuiltinType::Int128: return lldb::eFormatDecimal; 1985 case BuiltinType::Float: return lldb::eFormatFloat; 1986 case BuiltinType::Double: return lldb::eFormatFloat; 1987 case BuiltinType::LongDouble: return lldb::eFormatFloat; 1988 case BuiltinType::NullPtr: 1989 case BuiltinType::Overload: 1990 case BuiltinType::Dependent: 1991 case BuiltinType::ObjCId: 1992 case BuiltinType::ObjCClass: 1993 case BuiltinType::ObjCSel: 1994 case BuiltinType::Half: 1995 case BuiltinType::ARCUnbridgedCast: 1996 case BuiltinType::PseudoObject: 1997 case BuiltinType::BuiltinFn: 1998 case BuiltinType::OCLEvent: 1999 case BuiltinType::OCLImage1d: 2000 case BuiltinType::OCLImage1dArray: 2001 case BuiltinType::OCLImage1dBuffer: 2002 case BuiltinType::OCLImage2d: 2003 case BuiltinType::OCLImage2dArray: 2004 case BuiltinType::OCLImage3d: 2005 case BuiltinType::OCLSampler: 2006 return lldb::eFormatHex; 2007 } 2008 break; 2009 case clang::Type::ObjCObjectPointer: return lldb::eFormatHex; 2010 case clang::Type::BlockPointer: return lldb::eFormatHex; 2011 case clang::Type::Pointer: return lldb::eFormatHex; 2012 case clang::Type::LValueReference: 2013 case clang::Type::RValueReference: return lldb::eFormatHex; 2014 case clang::Type::MemberPointer: break; 2015 case clang::Type::Complex: 2016 { 2017 if (qual_type->isComplexType()) 2018 return lldb::eFormatComplex; 2019 else 2020 return lldb::eFormatComplexInteger; 2021 } 2022 case clang::Type::ObjCInterface: break; 2023 case clang::Type::Record: break; 2024 case clang::Type::Enum: return lldb::eFormatEnum; 2025 case clang::Type::Typedef: 2026 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat(); 2027 case clang::Type::Auto: 2028 return ClangASTType (m_ast, cast<AutoType>(qual_type)->desugar()).GetFormat(); 2029 case clang::Type::Paren: 2030 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetFormat(); 2031 case clang::Type::Elaborated: 2032 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetFormat(); 2033 case clang::Type::DependentSizedArray: 2034 case clang::Type::DependentSizedExtVector: 2035 case clang::Type::UnresolvedUsing: 2036 case clang::Type::Attributed: 2037 case clang::Type::TemplateTypeParm: 2038 case clang::Type::SubstTemplateTypeParm: 2039 case clang::Type::SubstTemplateTypeParmPack: 2040 case clang::Type::InjectedClassName: 2041 case clang::Type::DependentName: 2042 case clang::Type::DependentTemplateSpecialization: 2043 case clang::Type::PackExpansion: 2044 case clang::Type::ObjCObject: 2045 2046 case clang::Type::TypeOfExpr: 2047 case clang::Type::TypeOf: 2048 case clang::Type::Decltype: 2049 case clang::Type::TemplateSpecialization: 2050 case clang::Type::Atomic: 2051 break; 2052 2053 // pointer type decayed from an array or function type. 2054 case clang::Type::Decayed: 2055 break; 2056 } 2057 // We don't know hot to display this type... 2058 return lldb::eFormatBytes; 2059} 2060 2061static bool 2062ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass) 2063{ 2064 while (class_interface_decl) 2065 { 2066 if (class_interface_decl->ivar_size() > 0) 2067 return true; 2068 2069 if (check_superclass) 2070 class_interface_decl = class_interface_decl->getSuperClass(); 2071 else 2072 break; 2073 } 2074 return false; 2075} 2076 2077uint32_t 2078ClangASTType::GetNumChildren (bool omit_empty_base_classes) const 2079{ 2080 if (!IsValid()) 2081 return 0; 2082 2083 uint32_t num_children = 0; 2084 QualType qual_type(GetQualType()); 2085 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2086 switch (type_class) 2087 { 2088 case clang::Type::Builtin: 2089 switch (cast<BuiltinType>(qual_type)->getKind()) 2090 { 2091 case BuiltinType::ObjCId: // child is Class 2092 case BuiltinType::ObjCClass: // child is Class 2093 num_children = 1; 2094 break; 2095 2096 default: 2097 break; 2098 } 2099 break; 2100 2101 case clang::Type::Complex: return 0; 2102 2103 case clang::Type::Record: 2104 if (GetCompleteQualType (m_ast, qual_type)) 2105 { 2106 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 2107 const RecordDecl *record_decl = record_type->getDecl(); 2108 assert(record_decl); 2109 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 2110 if (cxx_record_decl) 2111 { 2112 if (omit_empty_base_classes) 2113 { 2114 // Check each base classes to see if it or any of its 2115 // base classes contain any fields. This can help 2116 // limit the noise in variable views by not having to 2117 // show base classes that contain no members. 2118 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 2119 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 2120 base_class != base_class_end; 2121 ++base_class) 2122 { 2123 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 2124 2125 // Skip empty base classes 2126 if (ClangASTContext::RecordHasFields(base_class_decl) == false) 2127 continue; 2128 2129 num_children++; 2130 } 2131 } 2132 else 2133 { 2134 // Include all base classes 2135 num_children += cxx_record_decl->getNumBases(); 2136 } 2137 2138 } 2139 RecordDecl::field_iterator field, field_end; 2140 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) 2141 ++num_children; 2142 } 2143 break; 2144 2145 case clang::Type::ObjCObject: 2146 case clang::Type::ObjCInterface: 2147 if (GetCompleteQualType (m_ast, qual_type)) 2148 { 2149 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 2150 assert (objc_class_type); 2151 if (objc_class_type) 2152 { 2153 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2154 2155 if (class_interface_decl) 2156 { 2157 2158 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 2159 if (superclass_interface_decl) 2160 { 2161 if (omit_empty_base_classes) 2162 { 2163 if (ObjCDeclHasIVars (superclass_interface_decl, true)) 2164 ++num_children; 2165 } 2166 else 2167 ++num_children; 2168 } 2169 2170 num_children += class_interface_decl->ivar_size(); 2171 } 2172 } 2173 } 2174 break; 2175 2176 case clang::Type::ObjCObjectPointer: 2177 { 2178 const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr()); 2179 QualType pointee_type = pointer_type->getPointeeType(); 2180 uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes); 2181 // If this type points to a simple type, then it has 1 child 2182 if (num_pointee_children == 0) 2183 num_children = 1; 2184 else 2185 num_children = num_pointee_children; 2186 } 2187 break; 2188 2189 case clang::Type::Vector: 2190 case clang::Type::ExtVector: 2191 num_children = cast<VectorType>(qual_type.getTypePtr())->getNumElements(); 2192 break; 2193 2194 case clang::Type::ConstantArray: 2195 num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue(); 2196 break; 2197 2198 case clang::Type::Pointer: 2199 { 2200 const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); 2201 QualType pointee_type (pointer_type->getPointeeType()); 2202 uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes); 2203 if (num_pointee_children == 0) 2204 { 2205 // We have a pointer to a pointee type that claims it has no children. 2206 // We will want to look at 2207 num_children = ClangASTType (m_ast, pointee_type).GetNumPointeeChildren(); 2208 } 2209 else 2210 num_children = num_pointee_children; 2211 } 2212 break; 2213 2214 case clang::Type::LValueReference: 2215 case clang::Type::RValueReference: 2216 { 2217 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 2218 QualType pointee_type = reference_type->getPointeeType(); 2219 uint32_t num_pointee_children = ClangASTType (m_ast, pointee_type).GetNumChildren (omit_empty_base_classes); 2220 // If this type points to a simple type, then it has 1 child 2221 if (num_pointee_children == 0) 2222 num_children = 1; 2223 else 2224 num_children = num_pointee_children; 2225 } 2226 break; 2227 2228 2229 case clang::Type::Typedef: 2230 num_children = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes); 2231 break; 2232 2233 case clang::Type::Elaborated: 2234 num_children = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes); 2235 break; 2236 2237 case clang::Type::Paren: 2238 num_children = ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes); 2239 break; 2240 default: 2241 break; 2242 } 2243 return num_children; 2244} 2245 2246lldb::BasicType 2247ClangASTType::GetBasicTypeEnumeration () const 2248{ 2249 if (IsValid()) 2250 { 2251 QualType qual_type(GetQualType()); 2252 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2253 if (type_class == clang::Type::Builtin) 2254 { 2255 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 2256 { 2257 case clang::BuiltinType::Void: return eBasicTypeVoid; 2258 case clang::BuiltinType::Bool: return eBasicTypeBool; 2259 case clang::BuiltinType::Char_S: return eBasicTypeSignedChar; 2260 case clang::BuiltinType::Char_U: return eBasicTypeUnsignedChar; 2261 case clang::BuiltinType::Char16: return eBasicTypeChar16; 2262 case clang::BuiltinType::Char32: return eBasicTypeChar32; 2263 case clang::BuiltinType::UChar: return eBasicTypeUnsignedChar; 2264 case clang::BuiltinType::SChar: return eBasicTypeSignedChar; 2265 case clang::BuiltinType::WChar_S: return eBasicTypeSignedWChar; 2266 case clang::BuiltinType::WChar_U: return eBasicTypeUnsignedWChar; 2267 case clang::BuiltinType::Short: return eBasicTypeShort; 2268 case clang::BuiltinType::UShort: return eBasicTypeUnsignedShort; 2269 case clang::BuiltinType::Int: return eBasicTypeInt; 2270 case clang::BuiltinType::UInt: return eBasicTypeUnsignedInt; 2271 case clang::BuiltinType::Long: return eBasicTypeLong; 2272 case clang::BuiltinType::ULong: return eBasicTypeUnsignedLong; 2273 case clang::BuiltinType::LongLong: return eBasicTypeLongLong; 2274 case clang::BuiltinType::ULongLong: return eBasicTypeUnsignedLongLong; 2275 case clang::BuiltinType::Int128: return eBasicTypeInt128; 2276 case clang::BuiltinType::UInt128: return eBasicTypeUnsignedInt128; 2277 2278 case clang::BuiltinType::Half: return eBasicTypeHalf; 2279 case clang::BuiltinType::Float: return eBasicTypeFloat; 2280 case clang::BuiltinType::Double: return eBasicTypeDouble; 2281 case clang::BuiltinType::LongDouble:return eBasicTypeLongDouble; 2282 2283 case clang::BuiltinType::NullPtr: return eBasicTypeNullPtr; 2284 case clang::BuiltinType::ObjCId: return eBasicTypeObjCID; 2285 case clang::BuiltinType::ObjCClass: return eBasicTypeObjCClass; 2286 case clang::BuiltinType::ObjCSel: return eBasicTypeObjCSel; 2287 case clang::BuiltinType::Dependent: 2288 case clang::BuiltinType::Overload: 2289 case clang::BuiltinType::BoundMember: 2290 case clang::BuiltinType::PseudoObject: 2291 case clang::BuiltinType::UnknownAny: 2292 case clang::BuiltinType::BuiltinFn: 2293 case clang::BuiltinType::ARCUnbridgedCast: 2294 case clang::BuiltinType::OCLEvent: 2295 case clang::BuiltinType::OCLImage1d: 2296 case clang::BuiltinType::OCLImage1dArray: 2297 case clang::BuiltinType::OCLImage1dBuffer: 2298 case clang::BuiltinType::OCLImage2d: 2299 case clang::BuiltinType::OCLImage2dArray: 2300 case clang::BuiltinType::OCLImage3d: 2301 case clang::BuiltinType::OCLSampler: 2302 return eBasicTypeOther; 2303 } 2304 } 2305 } 2306 return eBasicTypeInvalid; 2307} 2308 2309 2310#pragma mark Aggregate Types 2311 2312uint32_t 2313ClangASTType::GetNumDirectBaseClasses () const 2314{ 2315 if (!IsValid()) 2316 return 0; 2317 2318 uint32_t count = 0; 2319 QualType qual_type(GetCanonicalQualType()); 2320 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2321 switch (type_class) 2322 { 2323 case clang::Type::Record: 2324 if (GetCompleteType()) 2325 { 2326 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2327 if (cxx_record_decl) 2328 count = cxx_record_decl->getNumBases(); 2329 } 2330 break; 2331 2332 case clang::Type::ObjCObjectPointer: 2333 count = GetPointeeType().GetNumDirectBaseClasses(); 2334 break; 2335 2336 case clang::Type::ObjCObject: 2337 if (GetCompleteType()) 2338 { 2339 const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); 2340 if (objc_class_type) 2341 { 2342 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2343 2344 if (class_interface_decl && class_interface_decl->getSuperClass()) 2345 count = 1; 2346 } 2347 } 2348 break; 2349 case clang::Type::ObjCInterface: 2350 if (GetCompleteType()) 2351 { 2352 const ObjCInterfaceType *objc_interface_type = qual_type->getAs<ObjCInterfaceType>(); 2353 if (objc_interface_type) 2354 { 2355 ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); 2356 2357 if (class_interface_decl && class_interface_decl->getSuperClass()) 2358 count = 1; 2359 } 2360 } 2361 break; 2362 2363 2364 case clang::Type::Typedef: 2365 count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses (); 2366 break; 2367 2368 case clang::Type::Elaborated: 2369 count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumDirectBaseClasses (); 2370 break; 2371 2372 case clang::Type::Paren: 2373 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumDirectBaseClasses (); 2374 2375 default: 2376 break; 2377 } 2378 return count; 2379} 2380 2381uint32_t 2382ClangASTType::GetNumVirtualBaseClasses () const 2383{ 2384 if (!IsValid()) 2385 return 0; 2386 2387 uint32_t count = 0; 2388 QualType qual_type(GetCanonicalQualType()); 2389 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2390 switch (type_class) 2391 { 2392 case clang::Type::Record: 2393 if (GetCompleteType()) 2394 { 2395 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2396 if (cxx_record_decl) 2397 count = cxx_record_decl->getNumVBases(); 2398 } 2399 break; 2400 2401 case clang::Type::Typedef: 2402 count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses(); 2403 break; 2404 2405 case clang::Type::Elaborated: 2406 count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumVirtualBaseClasses(); 2407 break; 2408 2409 case clang::Type::Paren: 2410 count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumVirtualBaseClasses(); 2411 break; 2412 2413 default: 2414 break; 2415 } 2416 return count; 2417} 2418 2419uint32_t 2420ClangASTType::GetNumFields () const 2421{ 2422 if (!IsValid()) 2423 return 0; 2424 2425 uint32_t count = 0; 2426 QualType qual_type(GetCanonicalQualType()); 2427 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2428 switch (type_class) 2429 { 2430 case clang::Type::Record: 2431 if (GetCompleteType()) 2432 { 2433 const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr()); 2434 if (record_type) 2435 { 2436 RecordDecl *record_decl = record_type->getDecl(); 2437 if (record_decl) 2438 { 2439 uint32_t field_idx = 0; 2440 RecordDecl::field_iterator field, field_end; 2441 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) 2442 ++field_idx; 2443 count = field_idx; 2444 } 2445 } 2446 } 2447 break; 2448 2449 case clang::Type::Typedef: 2450 count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields(); 2451 break; 2452 2453 case clang::Type::Elaborated: 2454 count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumFields(); 2455 break; 2456 2457 case clang::Type::Paren: 2458 count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumFields(); 2459 break; 2460 2461 case clang::Type::ObjCObjectPointer: 2462 if (GetCompleteType()) 2463 { 2464 const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); 2465 if (objc_class_type) 2466 { 2467 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); 2468 2469 if (class_interface_decl) 2470 count = class_interface_decl->ivar_size(); 2471 } 2472 } 2473 break; 2474 2475 case clang::Type::ObjCObject: 2476 case clang::Type::ObjCInterface: 2477 if (GetCompleteType()) 2478 { 2479 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 2480 if (objc_class_type) 2481 { 2482 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2483 2484 if (class_interface_decl) 2485 count = class_interface_decl->ivar_size(); 2486 } 2487 } 2488 break; 2489 2490 default: 2491 break; 2492 } 2493 return count; 2494} 2495 2496ClangASTType 2497ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const 2498{ 2499 if (!IsValid()) 2500 return ClangASTType(); 2501 2502 QualType qual_type(GetCanonicalQualType()); 2503 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2504 switch (type_class) 2505 { 2506 case clang::Type::Record: 2507 if (GetCompleteType()) 2508 { 2509 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2510 if (cxx_record_decl) 2511 { 2512 uint32_t curr_idx = 0; 2513 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 2514 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 2515 base_class != base_class_end; 2516 ++base_class, ++curr_idx) 2517 { 2518 if (curr_idx == idx) 2519 { 2520 if (bit_offset_ptr) 2521 { 2522 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); 2523 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 2524 if (base_class->isVirtual()) 2525 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 2526 else 2527 *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 2528 } 2529 return ClangASTType (m_ast, base_class->getType()); 2530 } 2531 } 2532 } 2533 } 2534 break; 2535 2536 case clang::Type::ObjCObjectPointer: 2537 return GetPointeeType().GetDirectBaseClassAtIndex(idx,bit_offset_ptr); 2538 2539 case clang::Type::ObjCObject: 2540 if (idx == 0 && GetCompleteType()) 2541 { 2542 const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); 2543 if (objc_class_type) 2544 { 2545 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2546 2547 if (class_interface_decl) 2548 { 2549 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 2550 if (superclass_interface_decl) 2551 { 2552 if (bit_offset_ptr) 2553 *bit_offset_ptr = 0; 2554 return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 2555 } 2556 } 2557 } 2558 } 2559 break; 2560 case clang::Type::ObjCInterface: 2561 if (idx == 0 && GetCompleteType()) 2562 { 2563 const ObjCObjectType *objc_interface_type = qual_type->getAs<ObjCInterfaceType>(); 2564 if (objc_interface_type) 2565 { 2566 ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); 2567 2568 if (class_interface_decl) 2569 { 2570 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 2571 if (superclass_interface_decl) 2572 { 2573 if (bit_offset_ptr) 2574 *bit_offset_ptr = 0; 2575 return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 2576 } 2577 } 2578 } 2579 } 2580 break; 2581 2582 2583 case clang::Type::Typedef: 2584 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); 2585 2586 case clang::Type::Elaborated: 2587 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); 2588 2589 case clang::Type::Paren: 2590 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); 2591 2592 default: 2593 break; 2594 } 2595 return ClangASTType(); 2596} 2597 2598ClangASTType 2599ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const 2600{ 2601 if (!IsValid()) 2602 return ClangASTType(); 2603 2604 QualType qual_type(GetCanonicalQualType()); 2605 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2606 switch (type_class) 2607 { 2608 case clang::Type::Record: 2609 if (GetCompleteType()) 2610 { 2611 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2612 if (cxx_record_decl) 2613 { 2614 uint32_t curr_idx = 0; 2615 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 2616 for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end(); 2617 base_class != base_class_end; 2618 ++base_class, ++curr_idx) 2619 { 2620 if (curr_idx == idx) 2621 { 2622 if (bit_offset_ptr) 2623 { 2624 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); 2625 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 2626 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 2627 2628 } 2629 return ClangASTType (m_ast, base_class->getType()); 2630 } 2631 } 2632 } 2633 } 2634 break; 2635 2636 case clang::Type::Typedef: 2637 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); 2638 2639 case clang::Type::Elaborated: 2640 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); 2641 2642 case clang::Type::Paren: 2643 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); 2644 2645 default: 2646 break; 2647 } 2648 return ClangASTType(); 2649} 2650 2651static clang_type_t 2652GetObjCFieldAtIndex (clang::ASTContext *ast, 2653 ObjCInterfaceDecl *class_interface_decl, 2654 size_t idx, 2655 std::string& name, 2656 uint64_t *bit_offset_ptr, 2657 uint32_t *bitfield_bit_size_ptr, 2658 bool *is_bitfield_ptr) 2659{ 2660 if (class_interface_decl) 2661 { 2662 if (idx < (class_interface_decl->ivar_size())) 2663 { 2664 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 2665 uint32_t ivar_idx = 0; 2666 2667 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx) 2668 { 2669 if (ivar_idx == idx) 2670 { 2671 const ObjCIvarDecl* ivar_decl = *ivar_pos; 2672 2673 QualType ivar_qual_type(ivar_decl->getType()); 2674 2675 name.assign(ivar_decl->getNameAsString()); 2676 2677 if (bit_offset_ptr) 2678 { 2679 const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); 2680 *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx); 2681 } 2682 2683 const bool is_bitfield = ivar_pos->isBitField(); 2684 2685 if (bitfield_bit_size_ptr) 2686 { 2687 *bitfield_bit_size_ptr = 0; 2688 2689 if (is_bitfield && ast) 2690 { 2691 Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth(); 2692 llvm::APSInt bitfield_apsint; 2693 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast)) 2694 { 2695 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); 2696 } 2697 } 2698 } 2699 if (is_bitfield_ptr) 2700 *is_bitfield_ptr = is_bitfield; 2701 2702 return ivar_qual_type.getAsOpaquePtr(); 2703 } 2704 } 2705 } 2706 } 2707 return NULL; 2708} 2709 2710ClangASTType 2711ClangASTType::GetFieldAtIndex (size_t idx, 2712 std::string& name, 2713 uint64_t *bit_offset_ptr, 2714 uint32_t *bitfield_bit_size_ptr, 2715 bool *is_bitfield_ptr) const 2716{ 2717 if (!IsValid()) 2718 return ClangASTType(); 2719 2720 QualType qual_type(GetCanonicalQualType()); 2721 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2722 switch (type_class) 2723 { 2724 case clang::Type::Record: 2725 if (GetCompleteType()) 2726 { 2727 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 2728 const RecordDecl *record_decl = record_type->getDecl(); 2729 uint32_t field_idx = 0; 2730 RecordDecl::field_iterator field, field_end; 2731 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx) 2732 { 2733 if (idx == field_idx) 2734 { 2735 // Print the member type if requested 2736 // Print the member name and equal sign 2737 name.assign(field->getNameAsString()); 2738 2739 // Figure out the type byte size (field_type_info.first) and 2740 // alignment (field_type_info.second) from the AST context. 2741 if (bit_offset_ptr) 2742 { 2743 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); 2744 *bit_offset_ptr = record_layout.getFieldOffset (field_idx); 2745 } 2746 2747 const bool is_bitfield = field->isBitField(); 2748 2749 if (bitfield_bit_size_ptr) 2750 { 2751 *bitfield_bit_size_ptr = 0; 2752 2753 if (is_bitfield) 2754 { 2755 Expr *bitfield_bit_size_expr = field->getBitWidth(); 2756 llvm::APSInt bitfield_apsint; 2757 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *m_ast)) 2758 { 2759 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); 2760 } 2761 } 2762 } 2763 if (is_bitfield_ptr) 2764 *is_bitfield_ptr = is_bitfield; 2765 2766 return ClangASTType (m_ast, field->getType()); 2767 } 2768 } 2769 } 2770 break; 2771 2772 case clang::Type::ObjCObjectPointer: 2773 if (GetCompleteType()) 2774 { 2775 const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); 2776 if (objc_class_type) 2777 { 2778 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); 2779 return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); 2780 } 2781 } 2782 break; 2783 2784 case clang::Type::ObjCObject: 2785 case clang::Type::ObjCInterface: 2786 if (GetCompleteType()) 2787 { 2788 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 2789 assert (objc_class_type); 2790 if (objc_class_type) 2791 { 2792 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2793 return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); 2794 } 2795 } 2796 break; 2797 2798 2799 case clang::Type::Typedef: 2800 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()). 2801 GetFieldAtIndex (idx, 2802 name, 2803 bit_offset_ptr, 2804 bitfield_bit_size_ptr, 2805 is_bitfield_ptr); 2806 2807 case clang::Type::Elaborated: 2808 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()). 2809 GetFieldAtIndex (idx, 2810 name, 2811 bit_offset_ptr, 2812 bitfield_bit_size_ptr, 2813 is_bitfield_ptr); 2814 2815 case clang::Type::Paren: 2816 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()). 2817 GetFieldAtIndex (idx, 2818 name, 2819 bit_offset_ptr, 2820 bitfield_bit_size_ptr, 2821 is_bitfield_ptr); 2822 2823 default: 2824 break; 2825 } 2826 return ClangASTType(); 2827} 2828 2829uint32_t 2830ClangASTType::GetIndexOfFieldWithName (const char* name, 2831 ClangASTType* field_clang_type_ptr, 2832 uint64_t *bit_offset_ptr, 2833 uint32_t *bitfield_bit_size_ptr, 2834 bool *is_bitfield_ptr) const 2835{ 2836 unsigned count = GetNumFields(); 2837 std::string field_name; 2838 for (unsigned index = 0; index < count; index++) 2839 { 2840 ClangASTType field_clang_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); 2841 if (strcmp(field_name.c_str(), name) == 0) 2842 { 2843 if (field_clang_type_ptr) 2844 *field_clang_type_ptr = field_clang_type; 2845 return index; 2846 } 2847 } 2848 return UINT32_MAX; 2849} 2850 2851// If a pointer to a pointee type (the clang_type arg) says that it has no 2852// children, then we either need to trust it, or override it and return a 2853// different result. For example, an "int *" has one child that is an integer, 2854// but a function pointer doesn't have any children. Likewise if a Record type 2855// claims it has no children, then there really is nothing to show. 2856uint32_t 2857ClangASTType::GetNumPointeeChildren () const 2858{ 2859 if (!IsValid()) 2860 return 0; 2861 2862 QualType qual_type(GetCanonicalQualType()); 2863 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2864 switch (type_class) 2865 { 2866 case clang::Type::Builtin: 2867 switch (cast<clang::BuiltinType>(qual_type)->getKind()) 2868 { 2869 case clang::BuiltinType::UnknownAny: 2870 case clang::BuiltinType::Void: 2871 case clang::BuiltinType::NullPtr: 2872 case clang::BuiltinType::OCLEvent: 2873 case clang::BuiltinType::OCLImage1d: 2874 case clang::BuiltinType::OCLImage1dArray: 2875 case clang::BuiltinType::OCLImage1dBuffer: 2876 case clang::BuiltinType::OCLImage2d: 2877 case clang::BuiltinType::OCLImage2dArray: 2878 case clang::BuiltinType::OCLImage3d: 2879 case clang::BuiltinType::OCLSampler: 2880 return 0; 2881 case clang::BuiltinType::Bool: 2882 case clang::BuiltinType::Char_U: 2883 case clang::BuiltinType::UChar: 2884 case clang::BuiltinType::WChar_U: 2885 case clang::BuiltinType::Char16: 2886 case clang::BuiltinType::Char32: 2887 case clang::BuiltinType::UShort: 2888 case clang::BuiltinType::UInt: 2889 case clang::BuiltinType::ULong: 2890 case clang::BuiltinType::ULongLong: 2891 case clang::BuiltinType::UInt128: 2892 case clang::BuiltinType::Char_S: 2893 case clang::BuiltinType::SChar: 2894 case clang::BuiltinType::WChar_S: 2895 case clang::BuiltinType::Short: 2896 case clang::BuiltinType::Int: 2897 case clang::BuiltinType::Long: 2898 case clang::BuiltinType::LongLong: 2899 case clang::BuiltinType::Int128: 2900 case clang::BuiltinType::Float: 2901 case clang::BuiltinType::Double: 2902 case clang::BuiltinType::LongDouble: 2903 case clang::BuiltinType::Dependent: 2904 case clang::BuiltinType::Overload: 2905 case clang::BuiltinType::ObjCId: 2906 case clang::BuiltinType::ObjCClass: 2907 case clang::BuiltinType::ObjCSel: 2908 case clang::BuiltinType::BoundMember: 2909 case clang::BuiltinType::Half: 2910 case clang::BuiltinType::ARCUnbridgedCast: 2911 case clang::BuiltinType::PseudoObject: 2912 case clang::BuiltinType::BuiltinFn: 2913 return 1; 2914 } 2915 break; 2916 2917 case clang::Type::Complex: return 1; 2918 case clang::Type::Pointer: return 1; 2919 case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them 2920 case clang::Type::LValueReference: return 1; 2921 case clang::Type::RValueReference: return 1; 2922 case clang::Type::MemberPointer: return 0; 2923 case clang::Type::ConstantArray: return 0; 2924 case clang::Type::IncompleteArray: return 0; 2925 case clang::Type::VariableArray: return 0; 2926 case clang::Type::DependentSizedArray: return 0; 2927 case clang::Type::DependentSizedExtVector: return 0; 2928 case clang::Type::Vector: return 0; 2929 case clang::Type::ExtVector: return 0; 2930 case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children... 2931 case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children... 2932 case clang::Type::UnresolvedUsing: return 0; 2933 case clang::Type::Paren: return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumPointeeChildren (); 2934 case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren (); 2935 case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumPointeeChildren (); 2936 case clang::Type::TypeOfExpr: return 0; 2937 case clang::Type::TypeOf: return 0; 2938 case clang::Type::Decltype: return 0; 2939 case clang::Type::Record: return 0; 2940 case clang::Type::Enum: return 1; 2941 case clang::Type::TemplateTypeParm: return 1; 2942 case clang::Type::SubstTemplateTypeParm: return 1; 2943 case clang::Type::TemplateSpecialization: return 1; 2944 case clang::Type::InjectedClassName: return 0; 2945 case clang::Type::DependentName: return 1; 2946 case clang::Type::DependentTemplateSpecialization: return 1; 2947 case clang::Type::ObjCObject: return 0; 2948 case clang::Type::ObjCInterface: return 0; 2949 case clang::Type::ObjCObjectPointer: return 1; 2950 default: 2951 break; 2952 } 2953 return 0; 2954} 2955 2956 2957ClangASTType 2958ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, 2959 const char *parent_name, 2960 size_t idx, 2961 bool transparent_pointers, 2962 bool omit_empty_base_classes, 2963 bool ignore_array_bounds, 2964 std::string& child_name, 2965 uint32_t &child_byte_size, 2966 int32_t &child_byte_offset, 2967 uint32_t &child_bitfield_bit_size, 2968 uint32_t &child_bitfield_bit_offset, 2969 bool &child_is_base_class, 2970 bool &child_is_deref_of_parent) const 2971{ 2972 if (!IsValid()) 2973 return ClangASTType(); 2974 2975 QualType parent_qual_type(GetCanonicalQualType()); 2976 const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass(); 2977 child_bitfield_bit_size = 0; 2978 child_bitfield_bit_offset = 0; 2979 child_is_base_class = false; 2980 2981 const bool idx_is_valid = idx < GetNumChildren (omit_empty_base_classes); 2982 uint32_t bit_offset; 2983 switch (parent_type_class) 2984 { 2985 case clang::Type::Builtin: 2986 if (idx_is_valid) 2987 { 2988 switch (cast<clang::BuiltinType>(parent_qual_type)->getKind()) 2989 { 2990 case clang::BuiltinType::ObjCId: 2991 case clang::BuiltinType::ObjCClass: 2992 child_name = "isa"; 2993 child_byte_size = m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy) / CHAR_BIT; 2994 return ClangASTType (m_ast, m_ast->ObjCBuiltinClassTy); 2995 2996 default: 2997 break; 2998 } 2999 } 3000 break; 3001 3002 case clang::Type::Record: 3003 if (idx_is_valid && GetCompleteType()) 3004 { 3005 const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr()); 3006 const RecordDecl *record_decl = record_type->getDecl(); 3007 assert(record_decl); 3008 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); 3009 uint32_t child_idx = 0; 3010 3011 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3012 if (cxx_record_decl) 3013 { 3014 // We might have base classes to print out first 3015 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3016 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3017 base_class != base_class_end; 3018 ++base_class) 3019 { 3020 const CXXRecordDecl *base_class_decl = NULL; 3021 3022 // Skip empty base classes 3023 if (omit_empty_base_classes) 3024 { 3025 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3026 if (ClangASTContext::RecordHasFields(base_class_decl) == false) 3027 continue; 3028 } 3029 3030 if (idx == child_idx) 3031 { 3032 if (base_class_decl == NULL) 3033 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3034 3035 3036 if (base_class->isVirtual()) 3037 bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 3038 else 3039 bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 3040 3041 // Base classes should be a multiple of 8 bits in size 3042 child_byte_offset = bit_offset/8; 3043 ClangASTType base_class_clang_type(m_ast, base_class->getType()); 3044 child_name = base_class_clang_type.GetTypeName().AsCString(""); 3045 uint64_t base_class_clang_type_bit_size = base_class_clang_type.GetBitSize(); 3046 3047 // Base classes bit sizes should be a multiple of 8 bits in size 3048 assert (base_class_clang_type_bit_size % 8 == 0); 3049 child_byte_size = base_class_clang_type_bit_size / 8; 3050 child_is_base_class = true; 3051 return base_class_clang_type; 3052 } 3053 // We don't increment the child index in the for loop since we might 3054 // be skipping empty base classes 3055 ++child_idx; 3056 } 3057 } 3058 // Make sure index is in range... 3059 uint32_t field_idx = 0; 3060 RecordDecl::field_iterator field, field_end; 3061 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) 3062 { 3063 if (idx == child_idx) 3064 { 3065 // Print the member type if requested 3066 // Print the member name and equal sign 3067 child_name.assign(field->getNameAsString().c_str()); 3068 3069 // Figure out the type byte size (field_type_info.first) and 3070 // alignment (field_type_info.second) from the AST context. 3071 ClangASTType field_clang_type (m_ast, field->getType()); 3072 assert(field_idx < record_layout.getFieldCount()); 3073 child_byte_size = field_clang_type.GetByteSize(); 3074 3075 // Figure out the field offset within the current struct/union/class type 3076 bit_offset = record_layout.getFieldOffset (field_idx); 3077 child_byte_offset = bit_offset / 8; 3078 if (ClangASTContext::FieldIsBitfield (m_ast, *field, child_bitfield_bit_size)) 3079 child_bitfield_bit_offset = bit_offset % 8; 3080 3081 return field_clang_type; 3082 } 3083 } 3084 } 3085 break; 3086 3087 case clang::Type::ObjCObject: 3088 case clang::Type::ObjCInterface: 3089 if (idx_is_valid && GetCompleteType()) 3090 { 3091 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr()); 3092 assert (objc_class_type); 3093 if (objc_class_type) 3094 { 3095 uint32_t child_idx = 0; 3096 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3097 3098 if (class_interface_decl) 3099 { 3100 3101 const ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl); 3102 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3103 if (superclass_interface_decl) 3104 { 3105 if (omit_empty_base_classes) 3106 { 3107 ClangASTType base_class_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 3108 if (base_class_clang_type.GetNumChildren(omit_empty_base_classes) > 0) 3109 { 3110 if (idx == 0) 3111 { 3112 QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl)); 3113 3114 3115 child_name.assign(superclass_interface_decl->getNameAsString().c_str()); 3116 3117 std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr()); 3118 3119 child_byte_size = ivar_type_info.first / 8; 3120 child_byte_offset = 0; 3121 child_is_base_class = true; 3122 3123 return ClangASTType (m_ast, ivar_qual_type); 3124 } 3125 3126 ++child_idx; 3127 } 3128 } 3129 else 3130 ++child_idx; 3131 } 3132 3133 const uint32_t superclass_idx = child_idx; 3134 3135 if (idx < (child_idx + class_interface_decl->ivar_size())) 3136 { 3137 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 3138 3139 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos) 3140 { 3141 if (child_idx == idx) 3142 { 3143 ObjCIvarDecl* ivar_decl = *ivar_pos; 3144 3145 QualType ivar_qual_type(ivar_decl->getType()); 3146 3147 child_name.assign(ivar_decl->getNameAsString().c_str()); 3148 3149 std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr()); 3150 3151 child_byte_size = ivar_type_info.first / 8; 3152 3153 // Figure out the field offset within the current struct/union/class type 3154 // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since 3155 // that doesn't account for the space taken up by unbacked properties, or from 3156 // the changing size of base classes that are newer than this class. 3157 // So if we have a process around that we can ask about this object, do so. 3158 child_byte_offset = LLDB_INVALID_IVAR_OFFSET; 3159 Process *process = NULL; 3160 if (exe_ctx) 3161 process = exe_ctx->GetProcessPtr(); 3162 if (process) 3163 { 3164 ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime(); 3165 if (objc_runtime != NULL) 3166 { 3167 ClangASTType parent_ast_type (m_ast, parent_qual_type); 3168 child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str()); 3169 } 3170 } 3171 3172 // Setting this to UINT32_MAX to make sure we don't compute it twice... 3173 bit_offset = UINT32_MAX; 3174 3175 if (child_byte_offset == LLDB_INVALID_IVAR_OFFSET) 3176 { 3177 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); 3178 child_byte_offset = bit_offset / 8; 3179 } 3180 3181 // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset 3182 // of a bitfield within its containing object. So regardless of where we get the byte 3183 // offset from, we still need to get the bit offset for bitfields from the layout. 3184 3185 if (ClangASTContext::FieldIsBitfield (m_ast, ivar_decl, child_bitfield_bit_size)) 3186 { 3187 if (bit_offset == UINT32_MAX) 3188 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); 3189 3190 child_bitfield_bit_offset = bit_offset % 8; 3191 } 3192 return ClangASTType (m_ast, ivar_qual_type); 3193 } 3194 ++child_idx; 3195 } 3196 } 3197 } 3198 } 3199 } 3200 break; 3201 3202 case clang::Type::ObjCObjectPointer: 3203 if (idx_is_valid) 3204 { 3205 ClangASTType pointee_clang_type (GetPointeeType()); 3206 3207 if (transparent_pointers && pointee_clang_type.IsAggregateType()) 3208 { 3209 child_is_deref_of_parent = false; 3210 bool tmp_child_is_deref_of_parent = false; 3211 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3212 parent_name, 3213 idx, 3214 transparent_pointers, 3215 omit_empty_base_classes, 3216 ignore_array_bounds, 3217 child_name, 3218 child_byte_size, 3219 child_byte_offset, 3220 child_bitfield_bit_size, 3221 child_bitfield_bit_offset, 3222 child_is_base_class, 3223 tmp_child_is_deref_of_parent); 3224 } 3225 else 3226 { 3227 child_is_deref_of_parent = true; 3228 if (parent_name) 3229 { 3230 child_name.assign(1, '*'); 3231 child_name += parent_name; 3232 } 3233 3234 // We have a pointer to an simple type 3235 if (idx == 0 && pointee_clang_type.GetCompleteType()) 3236 { 3237 child_byte_size = pointee_clang_type.GetByteSize(); 3238 child_byte_offset = 0; 3239 return pointee_clang_type; 3240 } 3241 } 3242 } 3243 break; 3244 3245 case clang::Type::Vector: 3246 case clang::Type::ExtVector: 3247 if (idx_is_valid) 3248 { 3249 const VectorType *array = cast<VectorType>(parent_qual_type.getTypePtr()); 3250 if (array) 3251 { 3252 ClangASTType element_type (m_ast, array->getElementType()); 3253 if (element_type.GetCompleteType()) 3254 { 3255 char element_name[64]; 3256 ::snprintf (element_name, sizeof (element_name), "[%zu]", idx); 3257 child_name.assign(element_name); 3258 child_byte_size = element_type.GetByteSize(); 3259 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; 3260 return element_type; 3261 } 3262 } 3263 } 3264 break; 3265 3266 case clang::Type::ConstantArray: 3267 case clang::Type::IncompleteArray: 3268 if (ignore_array_bounds || idx_is_valid) 3269 { 3270 const ArrayType *array = cast<ArrayType>(parent_qual_type.getTypePtr()); 3271 if (array) 3272 { 3273 ClangASTType element_type (m_ast, array->getElementType()); 3274 if (element_type.GetCompleteType()) 3275 { 3276 char element_name[64]; 3277 ::snprintf (element_name, sizeof (element_name), "[%zu]", idx); 3278 child_name.assign(element_name); 3279 child_byte_size = element_type.GetByteSize(); 3280 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; 3281 return element_type; 3282 } 3283 } 3284 } 3285 break; 3286 3287 3288 case clang::Type::Pointer: 3289 if (idx_is_valid) 3290 { 3291 ClangASTType pointee_clang_type (GetPointeeType()); 3292 3293 // Don't dereference "void *" pointers 3294 if (pointee_clang_type.IsVoidType()) 3295 return ClangASTType(); 3296 3297 if (transparent_pointers && pointee_clang_type.IsAggregateType ()) 3298 { 3299 child_is_deref_of_parent = false; 3300 bool tmp_child_is_deref_of_parent = false; 3301 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3302 parent_name, 3303 idx, 3304 transparent_pointers, 3305 omit_empty_base_classes, 3306 ignore_array_bounds, 3307 child_name, 3308 child_byte_size, 3309 child_byte_offset, 3310 child_bitfield_bit_size, 3311 child_bitfield_bit_offset, 3312 child_is_base_class, 3313 tmp_child_is_deref_of_parent); 3314 } 3315 else 3316 { 3317 child_is_deref_of_parent = true; 3318 3319 if (parent_name) 3320 { 3321 child_name.assign(1, '*'); 3322 child_name += parent_name; 3323 } 3324 3325 // We have a pointer to an simple type 3326 if (idx == 0) 3327 { 3328 child_byte_size = pointee_clang_type.GetByteSize(); 3329 child_byte_offset = 0; 3330 return pointee_clang_type; 3331 } 3332 } 3333 } 3334 break; 3335 3336 case clang::Type::LValueReference: 3337 case clang::Type::RValueReference: 3338 if (idx_is_valid) 3339 { 3340 const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr()); 3341 ClangASTType pointee_clang_type (m_ast, reference_type->getPointeeType()); 3342 if (transparent_pointers && pointee_clang_type.IsAggregateType ()) 3343 { 3344 child_is_deref_of_parent = false; 3345 bool tmp_child_is_deref_of_parent = false; 3346 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3347 parent_name, 3348 idx, 3349 transparent_pointers, 3350 omit_empty_base_classes, 3351 ignore_array_bounds, 3352 child_name, 3353 child_byte_size, 3354 child_byte_offset, 3355 child_bitfield_bit_size, 3356 child_bitfield_bit_offset, 3357 child_is_base_class, 3358 tmp_child_is_deref_of_parent); 3359 } 3360 else 3361 { 3362 if (parent_name) 3363 { 3364 child_name.assign(1, '&'); 3365 child_name += parent_name; 3366 } 3367 3368 // We have a pointer to an simple type 3369 if (idx == 0) 3370 { 3371 child_byte_size = pointee_clang_type.GetByteSize(); 3372 child_byte_offset = 0; 3373 return pointee_clang_type; 3374 } 3375 } 3376 } 3377 break; 3378 3379 case clang::Type::Typedef: 3380 { 3381 ClangASTType typedefed_clang_type (m_ast, cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType()); 3382 return typedefed_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3383 parent_name, 3384 idx, 3385 transparent_pointers, 3386 omit_empty_base_classes, 3387 ignore_array_bounds, 3388 child_name, 3389 child_byte_size, 3390 child_byte_offset, 3391 child_bitfield_bit_size, 3392 child_bitfield_bit_offset, 3393 child_is_base_class, 3394 child_is_deref_of_parent); 3395 } 3396 break; 3397 3398 case clang::Type::Elaborated: 3399 { 3400 ClangASTType elaborated_clang_type (m_ast, cast<ElaboratedType>(parent_qual_type)->getNamedType()); 3401 return elaborated_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3402 parent_name, 3403 idx, 3404 transparent_pointers, 3405 omit_empty_base_classes, 3406 ignore_array_bounds, 3407 child_name, 3408 child_byte_size, 3409 child_byte_offset, 3410 child_bitfield_bit_size, 3411 child_bitfield_bit_offset, 3412 child_is_base_class, 3413 child_is_deref_of_parent); 3414 } 3415 3416 case clang::Type::Paren: 3417 { 3418 ClangASTType paren_clang_type (m_ast, llvm::cast<clang::ParenType>(parent_qual_type)->desugar()); 3419 return paren_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3420 parent_name, 3421 idx, 3422 transparent_pointers, 3423 omit_empty_base_classes, 3424 ignore_array_bounds, 3425 child_name, 3426 child_byte_size, 3427 child_byte_offset, 3428 child_bitfield_bit_size, 3429 child_bitfield_bit_offset, 3430 child_is_base_class, 3431 child_is_deref_of_parent); 3432 } 3433 3434 3435 default: 3436 break; 3437 } 3438 return ClangASTType(); 3439} 3440 3441static inline bool 3442BaseSpecifierIsEmpty (const CXXBaseSpecifier *b) 3443{ 3444 return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false; 3445} 3446 3447static uint32_t 3448GetIndexForRecordBase 3449( 3450 const RecordDecl *record_decl, 3451 const CXXBaseSpecifier *base_spec, 3452 bool omit_empty_base_classes 3453 ) 3454{ 3455 uint32_t child_idx = 0; 3456 3457 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3458 3459 // const char *super_name = record_decl->getNameAsCString(); 3460 // const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString(); 3461 // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name); 3462 // 3463 if (cxx_record_decl) 3464 { 3465 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3466 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3467 base_class != base_class_end; 3468 ++base_class) 3469 { 3470 if (omit_empty_base_classes) 3471 { 3472 if (BaseSpecifierIsEmpty (base_class)) 3473 continue; 3474 } 3475 3476 // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name, 3477 // child_idx, 3478 // base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString()); 3479 // 3480 // 3481 if (base_class == base_spec) 3482 return child_idx; 3483 ++child_idx; 3484 } 3485 } 3486 3487 return UINT32_MAX; 3488} 3489 3490 3491static uint32_t 3492GetIndexForRecordChild (const RecordDecl *record_decl, 3493 NamedDecl *canonical_decl, 3494 bool omit_empty_base_classes) 3495{ 3496 uint32_t child_idx = ClangASTContext::GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl), 3497 omit_empty_base_classes); 3498 3499 RecordDecl::field_iterator field, field_end; 3500 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 3501 field != field_end; 3502 ++field, ++child_idx) 3503 { 3504 if (field->getCanonicalDecl() == canonical_decl) 3505 return child_idx; 3506 } 3507 3508 return UINT32_MAX; 3509} 3510 3511// Look for a child member (doesn't include base classes, but it does include 3512// their members) in the type hierarchy. Returns an index path into "clang_type" 3513// on how to reach the appropriate member. 3514// 3515// class A 3516// { 3517// public: 3518// int m_a; 3519// int m_b; 3520// }; 3521// 3522// class B 3523// { 3524// }; 3525// 3526// class C : 3527// public B, 3528// public A 3529// { 3530// }; 3531// 3532// If we have a clang type that describes "class C", and we wanted to looked 3533// "m_b" in it: 3534// 3535// With omit_empty_base_classes == false we would get an integer array back with: 3536// { 1, 1 } 3537// The first index 1 is the child index for "class A" within class C 3538// The second index 1 is the child index for "m_b" within class A 3539// 3540// With omit_empty_base_classes == true we would get an integer array back with: 3541// { 0, 1 } 3542// 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) 3543// The second index 1 is the child index for "m_b" within class A 3544 3545size_t 3546ClangASTType::GetIndexOfChildMemberWithName (const char *name, 3547 bool omit_empty_base_classes, 3548 std::vector<uint32_t>& child_indexes) const 3549{ 3550 if (IsValid() && name && name[0]) 3551 { 3552 QualType qual_type(GetCanonicalQualType()); 3553 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3554 switch (type_class) 3555 { 3556 case clang::Type::Record: 3557 if (GetCompleteType ()) 3558 { 3559 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 3560 const RecordDecl *record_decl = record_type->getDecl(); 3561 3562 assert(record_decl); 3563 uint32_t child_idx = 0; 3564 3565 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3566 3567 // Try and find a field that matches NAME 3568 RecordDecl::field_iterator field, field_end; 3569 StringRef name_sref(name); 3570 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 3571 field != field_end; 3572 ++field, ++child_idx) 3573 { 3574 llvm::StringRef field_name = field->getName(); 3575 if (field_name.empty()) 3576 { 3577 ClangASTType field_type(m_ast,field->getType()); 3578 child_indexes.push_back(child_idx); 3579 if (field_type.GetIndexOfChildMemberWithName(name, omit_empty_base_classes, child_indexes)) 3580 return child_indexes.size(); 3581 child_indexes.pop_back(); 3582 3583 } 3584 else if (field_name.equals (name_sref)) 3585 { 3586 // We have to add on the number of base classes to this index! 3587 child_indexes.push_back (child_idx + ClangASTContext::GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes)); 3588 return child_indexes.size(); 3589 } 3590 } 3591 3592 if (cxx_record_decl) 3593 { 3594 const RecordDecl *parent_record_decl = cxx_record_decl; 3595 3596 //printf ("parent = %s\n", parent_record_decl->getNameAsCString()); 3597 3598 //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl(); 3599 // Didn't find things easily, lets let clang do its thang... 3600 IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref); 3601 DeclarationName decl_name(&ident_ref); 3602 3603 CXXBasePaths paths; 3604 if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember, 3605 decl_name.getAsOpaquePtr(), 3606 paths)) 3607 { 3608 CXXBasePaths::const_paths_iterator path, path_end = paths.end(); 3609 for (path = paths.begin(); path != path_end; ++path) 3610 { 3611 const size_t num_path_elements = path->size(); 3612 for (size_t e=0; e<num_path_elements; ++e) 3613 { 3614 CXXBasePathElement elem = (*path)[e]; 3615 3616 child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes); 3617 if (child_idx == UINT32_MAX) 3618 { 3619 child_indexes.clear(); 3620 return 0; 3621 } 3622 else 3623 { 3624 child_indexes.push_back (child_idx); 3625 parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl()); 3626 } 3627 } 3628 for (NamedDecl *path_decl : path->Decls) 3629 { 3630 child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes); 3631 if (child_idx == UINT32_MAX) 3632 { 3633 child_indexes.clear(); 3634 return 0; 3635 } 3636 else 3637 { 3638 child_indexes.push_back (child_idx); 3639 } 3640 } 3641 } 3642 return child_indexes.size(); 3643 } 3644 } 3645 3646 } 3647 break; 3648 3649 case clang::Type::ObjCObject: 3650 case clang::Type::ObjCInterface: 3651 if (GetCompleteType ()) 3652 { 3653 StringRef name_sref(name); 3654 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 3655 assert (objc_class_type); 3656 if (objc_class_type) 3657 { 3658 uint32_t child_idx = 0; 3659 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3660 3661 if (class_interface_decl) 3662 { 3663 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 3664 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3665 3666 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) 3667 { 3668 const ObjCIvarDecl* ivar_decl = *ivar_pos; 3669 3670 if (ivar_decl->getName().equals (name_sref)) 3671 { 3672 if ((!omit_empty_base_classes && superclass_interface_decl) || 3673 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) 3674 ++child_idx; 3675 3676 child_indexes.push_back (child_idx); 3677 return child_indexes.size(); 3678 } 3679 } 3680 3681 if (superclass_interface_decl) 3682 { 3683 // The super class index is always zero for ObjC classes, 3684 // so we push it onto the child indexes in case we find 3685 // an ivar in our superclass... 3686 child_indexes.push_back (0); 3687 3688 ClangASTType superclass_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 3689 if (superclass_clang_type.GetIndexOfChildMemberWithName (name, 3690 omit_empty_base_classes, 3691 child_indexes)) 3692 { 3693 // We did find an ivar in a superclass so just 3694 // return the results! 3695 return child_indexes.size(); 3696 } 3697 3698 // We didn't find an ivar matching "name" in our 3699 // superclass, pop the superclass zero index that 3700 // we pushed on above. 3701 child_indexes.pop_back(); 3702 } 3703 } 3704 } 3705 } 3706 break; 3707 3708 case clang::Type::ObjCObjectPointer: 3709 { 3710 ClangASTType objc_object_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()); 3711 return objc_object_clang_type.GetIndexOfChildMemberWithName (name, 3712 omit_empty_base_classes, 3713 child_indexes); 3714 } 3715 break; 3716 3717 3718 case clang::Type::ConstantArray: 3719 { 3720 // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); 3721 // const uint64_t element_count = array->getSize().getLimitedValue(); 3722 // 3723 // if (idx < element_count) 3724 // { 3725 // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); 3726 // 3727 // char element_name[32]; 3728 // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); 3729 // 3730 // child_name.assign(element_name); 3731 // assert(field_type_info.first % 8 == 0); 3732 // child_byte_size = field_type_info.first / 8; 3733 // child_byte_offset = idx * child_byte_size; 3734 // return array->getElementType().getAsOpaquePtr(); 3735 // } 3736 } 3737 break; 3738 3739 // case clang::Type::MemberPointerType: 3740 // { 3741 // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); 3742 // QualType pointee_type = mem_ptr_type->getPointeeType(); 3743 // 3744 // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 3745 // { 3746 // return GetIndexOfChildWithName (ast, 3747 // mem_ptr_type->getPointeeType().getAsOpaquePtr(), 3748 // name); 3749 // } 3750 // } 3751 // break; 3752 // 3753 case clang::Type::LValueReference: 3754 case clang::Type::RValueReference: 3755 { 3756 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 3757 QualType pointee_type(reference_type->getPointeeType()); 3758 ClangASTType pointee_clang_type (m_ast, pointee_type); 3759 3760 if (pointee_clang_type.IsAggregateType ()) 3761 { 3762 return pointee_clang_type.GetIndexOfChildMemberWithName (name, 3763 omit_empty_base_classes, 3764 child_indexes); 3765 } 3766 } 3767 break; 3768 3769 case clang::Type::Pointer: 3770 { 3771 ClangASTType pointee_clang_type (GetPointeeType()); 3772 3773 if (pointee_clang_type.IsAggregateType ()) 3774 { 3775 return pointee_clang_type.GetIndexOfChildMemberWithName (name, 3776 omit_empty_base_classes, 3777 child_indexes); 3778 } 3779 } 3780 break; 3781 3782 case clang::Type::Typedef: 3783 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name, 3784 omit_empty_base_classes, 3785 child_indexes); 3786 3787 case clang::Type::Elaborated: 3788 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name, 3789 omit_empty_base_classes, 3790 child_indexes); 3791 3792 case clang::Type::Paren: 3793 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name, 3794 omit_empty_base_classes, 3795 child_indexes); 3796 3797 default: 3798 break; 3799 } 3800 } 3801 return 0; 3802} 3803 3804 3805// Get the index of the child of "clang_type" whose name matches. This function 3806// doesn't descend into the children, but only looks one level deep and name 3807// matches can include base class names. 3808 3809uint32_t 3810ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_classes) const 3811{ 3812 if (IsValid() && name && name[0]) 3813 { 3814 QualType qual_type(GetCanonicalQualType()); 3815 3816 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3817 3818 switch (type_class) 3819 { 3820 case clang::Type::Record: 3821 if (GetCompleteType ()) 3822 { 3823 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 3824 const RecordDecl *record_decl = record_type->getDecl(); 3825 3826 assert(record_decl); 3827 uint32_t child_idx = 0; 3828 3829 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3830 3831 if (cxx_record_decl) 3832 { 3833 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3834 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3835 base_class != base_class_end; 3836 ++base_class) 3837 { 3838 // Skip empty base classes 3839 CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3840 if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false) 3841 continue; 3842 3843 ClangASTType base_class_clang_type (m_ast, base_class->getType()); 3844 std::string base_class_type_name (base_class_clang_type.GetTypeName().AsCString("")); 3845 if (base_class_type_name.compare (name) == 0) 3846 return child_idx; 3847 ++child_idx; 3848 } 3849 } 3850 3851 // Try and find a field that matches NAME 3852 RecordDecl::field_iterator field, field_end; 3853 StringRef name_sref(name); 3854 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 3855 field != field_end; 3856 ++field, ++child_idx) 3857 { 3858 if (field->getName().equals (name_sref)) 3859 return child_idx; 3860 } 3861 3862 } 3863 break; 3864 3865 case clang::Type::ObjCObject: 3866 case clang::Type::ObjCInterface: 3867 if (GetCompleteType()) 3868 { 3869 StringRef name_sref(name); 3870 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 3871 assert (objc_class_type); 3872 if (objc_class_type) 3873 { 3874 uint32_t child_idx = 0; 3875 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3876 3877 if (class_interface_decl) 3878 { 3879 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 3880 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3881 3882 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) 3883 { 3884 const ObjCIvarDecl* ivar_decl = *ivar_pos; 3885 3886 if (ivar_decl->getName().equals (name_sref)) 3887 { 3888 if ((!omit_empty_base_classes && superclass_interface_decl) || 3889 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) 3890 ++child_idx; 3891 3892 return child_idx; 3893 } 3894 } 3895 3896 if (superclass_interface_decl) 3897 { 3898 if (superclass_interface_decl->getName().equals (name_sref)) 3899 return 0; 3900 } 3901 } 3902 } 3903 } 3904 break; 3905 3906 case clang::Type::ObjCObjectPointer: 3907 { 3908 ClangASTType pointee_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()); 3909 return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes); 3910 } 3911 break; 3912 3913 case clang::Type::ConstantArray: 3914 { 3915 // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); 3916 // const uint64_t element_count = array->getSize().getLimitedValue(); 3917 // 3918 // if (idx < element_count) 3919 // { 3920 // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); 3921 // 3922 // char element_name[32]; 3923 // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); 3924 // 3925 // child_name.assign(element_name); 3926 // assert(field_type_info.first % 8 == 0); 3927 // child_byte_size = field_type_info.first / 8; 3928 // child_byte_offset = idx * child_byte_size; 3929 // return array->getElementType().getAsOpaquePtr(); 3930 // } 3931 } 3932 break; 3933 3934 // case clang::Type::MemberPointerType: 3935 // { 3936 // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); 3937 // QualType pointee_type = mem_ptr_type->getPointeeType(); 3938 // 3939 // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 3940 // { 3941 // return GetIndexOfChildWithName (ast, 3942 // mem_ptr_type->getPointeeType().getAsOpaquePtr(), 3943 // name); 3944 // } 3945 // } 3946 // break; 3947 // 3948 case clang::Type::LValueReference: 3949 case clang::Type::RValueReference: 3950 { 3951 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 3952 ClangASTType pointee_type (m_ast, reference_type->getPointeeType()); 3953 3954 if (pointee_type.IsAggregateType ()) 3955 { 3956 return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes); 3957 } 3958 } 3959 break; 3960 3961 case clang::Type::Pointer: 3962 { 3963 const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); 3964 ClangASTType pointee_type (m_ast, pointer_type->getPointeeType()); 3965 3966 if (pointee_type.IsAggregateType ()) 3967 { 3968 return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes); 3969 } 3970 else 3971 { 3972 // if (parent_name) 3973 // { 3974 // child_name.assign(1, '*'); 3975 // child_name += parent_name; 3976 // } 3977 // 3978 // // We have a pointer to an simple type 3979 // if (idx == 0) 3980 // { 3981 // std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); 3982 // assert(clang_type_info.first % 8 == 0); 3983 // child_byte_size = clang_type_info.first / 8; 3984 // child_byte_offset = 0; 3985 // return pointee_type.getAsOpaquePtr(); 3986 // } 3987 } 3988 } 3989 break; 3990 3991 case clang::Type::Elaborated: 3992 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes); 3993 3994 case clang::Type::Paren: 3995 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes); 3996 3997 case clang::Type::Typedef: 3998 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes); 3999 4000 default: 4001 break; 4002 } 4003 } 4004 return UINT32_MAX; 4005} 4006 4007 4008size_t 4009ClangASTType::GetNumTemplateArguments () const 4010{ 4011 if (IsValid()) 4012 { 4013 QualType qual_type (GetCanonicalQualType()); 4014 4015 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 4016 switch (type_class) 4017 { 4018 case clang::Type::Record: 4019 if (GetCompleteType ()) 4020 { 4021 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 4022 if (cxx_record_decl) 4023 { 4024 const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl); 4025 if (template_decl) 4026 return template_decl->getTemplateArgs().size(); 4027 } 4028 } 4029 break; 4030 4031 case clang::Type::Typedef: 4032 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments(); 4033 4034 case clang::Type::Elaborated: 4035 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumTemplateArguments(); 4036 4037 case clang::Type::Paren: 4038 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumTemplateArguments(); 4039 4040 default: 4041 break; 4042 } 4043 } 4044 return 0; 4045} 4046 4047ClangASTType 4048ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &kind) const 4049{ 4050 if (IsValid()) 4051 { 4052 QualType qual_type (GetCanonicalQualType()); 4053 4054 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 4055 switch (type_class) 4056 { 4057 case clang::Type::Record: 4058 if (GetCompleteType ()) 4059 { 4060 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 4061 if (cxx_record_decl) 4062 { 4063 const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl); 4064 if (template_decl && arg_idx < template_decl->getTemplateArgs().size()) 4065 { 4066 const TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx]; 4067 switch (template_arg.getKind()) 4068 { 4069 case clang::TemplateArgument::Null: 4070 kind = eTemplateArgumentKindNull; 4071 return ClangASTType(); 4072 4073 case clang::TemplateArgument::Type: 4074 kind = eTemplateArgumentKindType; 4075 return ClangASTType(m_ast, template_arg.getAsType()); 4076 4077 case clang::TemplateArgument::Declaration: 4078 kind = eTemplateArgumentKindDeclaration; 4079 return ClangASTType(); 4080 4081 case clang::TemplateArgument::Integral: 4082 kind = eTemplateArgumentKindIntegral; 4083 return ClangASTType(m_ast, template_arg.getIntegralType()); 4084 4085 case clang::TemplateArgument::Template: 4086 kind = eTemplateArgumentKindTemplate; 4087 return ClangASTType(); 4088 4089 case clang::TemplateArgument::TemplateExpansion: 4090 kind = eTemplateArgumentKindTemplateExpansion; 4091 return ClangASTType(); 4092 4093 case clang::TemplateArgument::Expression: 4094 kind = eTemplateArgumentKindExpression; 4095 return ClangASTType(); 4096 4097 case clang::TemplateArgument::Pack: 4098 kind = eTemplateArgumentKindPack; 4099 return ClangASTType(); 4100 4101 default: 4102 assert (!"Unhandled TemplateArgument::ArgKind"); 4103 break; 4104 } 4105 } 4106 } 4107 } 4108 break; 4109 4110 case clang::Type::Typedef: 4111 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind); 4112 4113 case clang::Type::Elaborated: 4114 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind); 4115 4116 case clang::Type::Paren: 4117 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind); 4118 4119 default: 4120 break; 4121 } 4122 } 4123 kind = eTemplateArgumentKindNull; 4124 return ClangASTType (); 4125} 4126 4127static bool 4128IsOperator (const char *name, OverloadedOperatorKind &op_kind) 4129{ 4130 if (name == NULL || name[0] == '\0') 4131 return false; 4132 4133#define OPERATOR_PREFIX "operator" 4134#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1) 4135 4136 const char *post_op_name = NULL; 4137 4138 bool no_space = true; 4139 4140 if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH)) 4141 return false; 4142 4143 post_op_name = name + OPERATOR_PREFIX_LENGTH; 4144 4145 if (post_op_name[0] == ' ') 4146 { 4147 post_op_name++; 4148 no_space = false; 4149 } 4150 4151#undef OPERATOR_PREFIX 4152#undef OPERATOR_PREFIX_LENGTH 4153 4154 // This is an operator, set the overloaded operator kind to invalid 4155 // in case this is a conversion operator... 4156 op_kind = NUM_OVERLOADED_OPERATORS; 4157 4158 switch (post_op_name[0]) 4159 { 4160 default: 4161 if (no_space) 4162 return false; 4163 break; 4164 case 'n': 4165 if (no_space) 4166 return false; 4167 if (strcmp (post_op_name, "new") == 0) 4168 op_kind = OO_New; 4169 else if (strcmp (post_op_name, "new[]") == 0) 4170 op_kind = OO_Array_New; 4171 break; 4172 4173 case 'd': 4174 if (no_space) 4175 return false; 4176 if (strcmp (post_op_name, "delete") == 0) 4177 op_kind = OO_Delete; 4178 else if (strcmp (post_op_name, "delete[]") == 0) 4179 op_kind = OO_Array_Delete; 4180 break; 4181 4182 case '+': 4183 if (post_op_name[1] == '\0') 4184 op_kind = OO_Plus; 4185 else if (post_op_name[2] == '\0') 4186 { 4187 if (post_op_name[1] == '=') 4188 op_kind = OO_PlusEqual; 4189 else if (post_op_name[1] == '+') 4190 op_kind = OO_PlusPlus; 4191 } 4192 break; 4193 4194 case '-': 4195 if (post_op_name[1] == '\0') 4196 op_kind = OO_Minus; 4197 else if (post_op_name[2] == '\0') 4198 { 4199 switch (post_op_name[1]) 4200 { 4201 case '=': op_kind = OO_MinusEqual; break; 4202 case '-': op_kind = OO_MinusMinus; break; 4203 case '>': op_kind = OO_Arrow; break; 4204 } 4205 } 4206 else if (post_op_name[3] == '\0') 4207 { 4208 if (post_op_name[2] == '*') 4209 op_kind = OO_ArrowStar; break; 4210 } 4211 break; 4212 4213 case '*': 4214 if (post_op_name[1] == '\0') 4215 op_kind = OO_Star; 4216 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4217 op_kind = OO_StarEqual; 4218 break; 4219 4220 case '/': 4221 if (post_op_name[1] == '\0') 4222 op_kind = OO_Slash; 4223 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4224 op_kind = OO_SlashEqual; 4225 break; 4226 4227 case '%': 4228 if (post_op_name[1] == '\0') 4229 op_kind = OO_Percent; 4230 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4231 op_kind = OO_PercentEqual; 4232 break; 4233 4234 4235 case '^': 4236 if (post_op_name[1] == '\0') 4237 op_kind = OO_Caret; 4238 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4239 op_kind = OO_CaretEqual; 4240 break; 4241 4242 case '&': 4243 if (post_op_name[1] == '\0') 4244 op_kind = OO_Amp; 4245 else if (post_op_name[2] == '\0') 4246 { 4247 switch (post_op_name[1]) 4248 { 4249 case '=': op_kind = OO_AmpEqual; break; 4250 case '&': op_kind = OO_AmpAmp; break; 4251 } 4252 } 4253 break; 4254 4255 case '|': 4256 if (post_op_name[1] == '\0') 4257 op_kind = OO_Pipe; 4258 else if (post_op_name[2] == '\0') 4259 { 4260 switch (post_op_name[1]) 4261 { 4262 case '=': op_kind = OO_PipeEqual; break; 4263 case '|': op_kind = OO_PipePipe; break; 4264 } 4265 } 4266 break; 4267 4268 case '~': 4269 if (post_op_name[1] == '\0') 4270 op_kind = OO_Tilde; 4271 break; 4272 4273 case '!': 4274 if (post_op_name[1] == '\0') 4275 op_kind = OO_Exclaim; 4276 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4277 op_kind = OO_ExclaimEqual; 4278 break; 4279 4280 case '=': 4281 if (post_op_name[1] == '\0') 4282 op_kind = OO_Equal; 4283 else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4284 op_kind = OO_EqualEqual; 4285 break; 4286 4287 case '<': 4288 if (post_op_name[1] == '\0') 4289 op_kind = OO_Less; 4290 else if (post_op_name[2] == '\0') 4291 { 4292 switch (post_op_name[1]) 4293 { 4294 case '<': op_kind = OO_LessLess; break; 4295 case '=': op_kind = OO_LessEqual; break; 4296 } 4297 } 4298 else if (post_op_name[3] == '\0') 4299 { 4300 if (post_op_name[2] == '=') 4301 op_kind = OO_LessLessEqual; 4302 } 4303 break; 4304 4305 case '>': 4306 if (post_op_name[1] == '\0') 4307 op_kind = OO_Greater; 4308 else if (post_op_name[2] == '\0') 4309 { 4310 switch (post_op_name[1]) 4311 { 4312 case '>': op_kind = OO_GreaterGreater; break; 4313 case '=': op_kind = OO_GreaterEqual; break; 4314 } 4315 } 4316 else if (post_op_name[1] == '>' && 4317 post_op_name[2] == '=' && 4318 post_op_name[3] == '\0') 4319 { 4320 op_kind = OO_GreaterGreaterEqual; 4321 } 4322 break; 4323 4324 case ',': 4325 if (post_op_name[1] == '\0') 4326 op_kind = OO_Comma; 4327 break; 4328 4329 case '(': 4330 if (post_op_name[1] == ')' && post_op_name[2] == '\0') 4331 op_kind = OO_Call; 4332 break; 4333 4334 case '[': 4335 if (post_op_name[1] == ']' && post_op_name[2] == '\0') 4336 op_kind = OO_Subscript; 4337 break; 4338 } 4339 4340 return true; 4341} 4342 4343static inline bool 4344check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params) 4345{ 4346 // Special-case call since it can take any number of operands 4347 if(op_kind == OO_Call) 4348 return true; 4349 4350 // The parameter count doens't include "this" 4351 if (num_params == 0) 4352 return unary; 4353 if (num_params == 1) 4354 return binary; 4355 else 4356 return false; 4357} 4358 4359clang::RecordDecl * 4360ClangASTType::GetAsRecordDecl () const 4361{ 4362 const RecordType *record_type = dyn_cast<RecordType>(GetCanonicalQualType()); 4363 if (record_type) 4364 return record_type->getDecl(); 4365 return NULL; 4366} 4367 4368clang::CXXRecordDecl * 4369ClangASTType::GetAsCXXRecordDecl () const 4370{ 4371 return GetCanonicalQualType()->getAsCXXRecordDecl(); 4372} 4373 4374ObjCInterfaceDecl * 4375ClangASTType::GetAsObjCInterfaceDecl () const 4376{ 4377 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(GetCanonicalQualType()); 4378 if (objc_class_type) 4379 return objc_class_type->getInterface(); 4380 return NULL; 4381} 4382 4383clang::FieldDecl * 4384ClangASTType::AddFieldToRecordType (const char *name, 4385 const ClangASTType &field_clang_type, 4386 AccessType access, 4387 uint32_t bitfield_bit_size) 4388{ 4389 if (!IsValid() || !field_clang_type.IsValid()) 4390 return NULL; 4391 4392 FieldDecl *field = NULL; 4393 4394 clang::Expr *bit_width = NULL; 4395 if (bitfield_bit_size != 0) 4396 { 4397 APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size); 4398 bit_width = new (*m_ast)IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, SourceLocation()); 4399 } 4400 4401 RecordDecl *record_decl = GetAsRecordDecl (); 4402 if (record_decl) 4403 { 4404 field = FieldDecl::Create (*m_ast, 4405 record_decl, 4406 SourceLocation(), 4407 SourceLocation(), 4408 name ? &m_ast->Idents.get(name) : NULL, // Identifier 4409 field_clang_type.GetQualType(), // Field type 4410 NULL, // TInfo * 4411 bit_width, // BitWidth 4412 false, // Mutable 4413 ICIS_NoInit); // HasInit 4414 4415 if (!name) 4416 { 4417 // Determine whether this field corresponds to an anonymous 4418 // struct or union. 4419 if (const TagType *TagT = field->getType()->getAs<TagType>()) { 4420 if (RecordDecl *Rec = dyn_cast<RecordDecl>(TagT->getDecl())) 4421 if (!Rec->getDeclName()) { 4422 Rec->setAnonymousStructOrUnion(true); 4423 field->setImplicit(); 4424 4425 } 4426 } 4427 } 4428 4429 if (field) 4430 { 4431 field->setAccess (ClangASTContext::ConvertAccessTypeToAccessSpecifier (access)); 4432 4433 record_decl->addDecl(field); 4434 4435#ifdef LLDB_CONFIGURATION_DEBUG 4436 VerifyDecl(field); 4437#endif 4438 } 4439 } 4440 else 4441 { 4442 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 4443 4444 if (class_interface_decl) 4445 { 4446 const bool is_synthesized = false; 4447 4448 field_clang_type.GetCompleteType(); 4449 4450 field = ObjCIvarDecl::Create (*m_ast, 4451 class_interface_decl, 4452 SourceLocation(), 4453 SourceLocation(), 4454 name ? &m_ast->Idents.get(name) : NULL, // Identifier 4455 field_clang_type.GetQualType(), // Field type 4456 NULL, // TypeSourceInfo * 4457 ConvertAccessTypeToObjCIvarAccessControl (access), 4458 bit_width, 4459 is_synthesized); 4460 4461 if (field) 4462 { 4463 class_interface_decl->addDecl(field); 4464 4465#ifdef LLDB_CONFIGURATION_DEBUG 4466 VerifyDecl(field); 4467#endif 4468 } 4469 } 4470 } 4471 return field; 4472} 4473 4474void 4475ClangASTType::BuildIndirectFields () 4476{ 4477 RecordDecl *record_decl = GetAsRecordDecl(); 4478 4479 if (!record_decl) 4480 return; 4481 4482 typedef llvm::SmallVector <IndirectFieldDecl *, 1> IndirectFieldVector; 4483 4484 IndirectFieldVector indirect_fields; 4485 RecordDecl::field_iterator field_pos; 4486 RecordDecl::field_iterator field_end_pos = record_decl->field_end(); 4487 RecordDecl::field_iterator last_field_pos = field_end_pos; 4488 for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++) 4489 { 4490 if (field_pos->isAnonymousStructOrUnion()) 4491 { 4492 QualType field_qual_type = field_pos->getType(); 4493 4494 const RecordType *field_record_type = field_qual_type->getAs<RecordType>(); 4495 4496 if (!field_record_type) 4497 continue; 4498 4499 RecordDecl *field_record_decl = field_record_type->getDecl(); 4500 4501 if (!field_record_decl) 4502 continue; 4503 4504 for (RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end(); 4505 di != de; 4506 ++di) 4507 { 4508 if (FieldDecl *nested_field_decl = dyn_cast<FieldDecl>(*di)) 4509 { 4510 NamedDecl **chain = new (*m_ast) NamedDecl*[2]; 4511 chain[0] = *field_pos; 4512 chain[1] = nested_field_decl; 4513 IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast, 4514 record_decl, 4515 SourceLocation(), 4516 nested_field_decl->getIdentifier(), 4517 nested_field_decl->getType(), 4518 chain, 4519 2); 4520 4521 indirect_field->setImplicit(); 4522 4523 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(), 4524 nested_field_decl->getAccess())); 4525 4526 indirect_fields.push_back(indirect_field); 4527 } 4528 else if (IndirectFieldDecl *nested_indirect_field_decl = dyn_cast<IndirectFieldDecl>(*di)) 4529 { 4530 int nested_chain_size = nested_indirect_field_decl->getChainingSize(); 4531 NamedDecl **chain = new (*m_ast) NamedDecl*[nested_chain_size + 1]; 4532 chain[0] = *field_pos; 4533 4534 int chain_index = 1; 4535 for (IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(), 4536 nce = nested_indirect_field_decl->chain_end(); 4537 nci < nce; 4538 ++nci) 4539 { 4540 chain[chain_index] = *nci; 4541 chain_index++; 4542 } 4543 4544 IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast, 4545 record_decl, 4546 SourceLocation(), 4547 nested_indirect_field_decl->getIdentifier(), 4548 nested_indirect_field_decl->getType(), 4549 chain, 4550 nested_chain_size + 1); 4551 4552 indirect_field->setImplicit(); 4553 4554 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(), 4555 nested_indirect_field_decl->getAccess())); 4556 4557 indirect_fields.push_back(indirect_field); 4558 } 4559 } 4560 } 4561 } 4562 4563 // Check the last field to see if it has an incomplete array type as its 4564 // last member and if it does, the tell the record decl about it 4565 if (last_field_pos != field_end_pos) 4566 { 4567 if (last_field_pos->getType()->isIncompleteArrayType()) 4568 record_decl->hasFlexibleArrayMember(); 4569 } 4570 4571 for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end(); 4572 ifi < ife; 4573 ++ifi) 4574 { 4575 record_decl->addDecl(*ifi); 4576 } 4577} 4578 4579clang::VarDecl * 4580ClangASTType::AddVariableToRecordType (const char *name, 4581 const ClangASTType &var_type, 4582 AccessType access) 4583{ 4584 clang::VarDecl *var_decl = NULL; 4585 4586 if (!IsValid() || !var_type.IsValid()) 4587 return NULL; 4588 4589 RecordDecl *record_decl = GetAsRecordDecl (); 4590 if (record_decl) 4591 { 4592 var_decl = VarDecl::Create (*m_ast, // ASTContext & 4593 record_decl, // DeclContext * 4594 SourceLocation(), // SourceLocation StartLoc 4595 SourceLocation(), // SourceLocation IdLoc 4596 name ? &m_ast->Idents.get(name) : NULL, // IdentifierInfo * 4597 var_type.GetQualType(), // Variable QualType 4598 NULL, // TypeSourceInfo * 4599 SC_Static); // StorageClass 4600 if (var_decl) 4601 { 4602 var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access)); 4603 record_decl->addDecl(var_decl); 4604 4605#ifdef LLDB_CONFIGURATION_DEBUG 4606 VerifyDecl(var_decl); 4607#endif 4608 } 4609 } 4610 return var_decl; 4611} 4612 4613 4614CXXMethodDecl * 4615ClangASTType::AddMethodToCXXRecordType (const char *name, 4616 const ClangASTType &method_clang_type, 4617 lldb::AccessType access, 4618 bool is_virtual, 4619 bool is_static, 4620 bool is_inline, 4621 bool is_explicit, 4622 bool is_attr_used, 4623 bool is_artificial) 4624{ 4625 if (!IsValid() || !method_clang_type.IsValid() || name == NULL || name[0] == '\0') 4626 return NULL; 4627 4628 QualType record_qual_type(GetCanonicalQualType()); 4629 4630 CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl(); 4631 4632 if (cxx_record_decl == NULL) 4633 return NULL; 4634 4635 QualType method_qual_type (method_clang_type.GetQualType()); 4636 4637 CXXMethodDecl *cxx_method_decl = NULL; 4638 4639 DeclarationName decl_name (&m_ast->Idents.get(name)); 4640 4641 const clang::FunctionType *function_type = dyn_cast<FunctionType>(method_qual_type.getTypePtr()); 4642 4643 if (function_type == NULL) 4644 return NULL; 4645 4646 const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_type)); 4647 4648 if (!method_function_prototype) 4649 return NULL; 4650 4651 unsigned int num_params = method_function_prototype->getNumArgs(); 4652 4653 CXXDestructorDecl *cxx_dtor_decl(NULL); 4654 CXXConstructorDecl *cxx_ctor_decl(NULL); 4655 4656 if (is_artificial) 4657 return NULL; // skip everything artificial 4658 4659 if (name[0] == '~') 4660 { 4661 cxx_dtor_decl = CXXDestructorDecl::Create (*m_ast, 4662 cxx_record_decl, 4663 SourceLocation(), 4664 DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()), 4665 method_qual_type, 4666 NULL, 4667 is_inline, 4668 is_artificial); 4669 cxx_method_decl = cxx_dtor_decl; 4670 } 4671 else if (decl_name == cxx_record_decl->getDeclName()) 4672 { 4673 cxx_ctor_decl = CXXConstructorDecl::Create (*m_ast, 4674 cxx_record_decl, 4675 SourceLocation(), 4676 DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()), 4677 method_qual_type, 4678 NULL, // TypeSourceInfo * 4679 is_explicit, 4680 is_inline, 4681 is_artificial, 4682 false /*is_constexpr*/); 4683 cxx_method_decl = cxx_ctor_decl; 4684 } 4685 else 4686 { 4687 clang::StorageClass SC = is_static ? SC_Static : SC_None; 4688 OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS; 4689 4690 if (IsOperator (name, op_kind)) 4691 { 4692 if (op_kind != NUM_OVERLOADED_OPERATORS) 4693 { 4694 // Check the number of operator parameters. Sometimes we have 4695 // seen bad DWARF that doesn't correctly describe operators and 4696 // if we try to create a methed and add it to the class, clang 4697 // will assert and crash, so we need to make sure things are 4698 // acceptable. 4699 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params)) 4700 return NULL; 4701 cxx_method_decl = CXXMethodDecl::Create (*m_ast, 4702 cxx_record_decl, 4703 SourceLocation(), 4704 DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()), 4705 method_qual_type, 4706 NULL, // TypeSourceInfo * 4707 SC, 4708 is_inline, 4709 false /*is_constexpr*/, 4710 SourceLocation()); 4711 } 4712 else if (num_params == 0) 4713 { 4714 // Conversion operators don't take params... 4715 cxx_method_decl = CXXConversionDecl::Create (*m_ast, 4716 cxx_record_decl, 4717 SourceLocation(), 4718 DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getResultType())), SourceLocation()), 4719 method_qual_type, 4720 NULL, // TypeSourceInfo * 4721 is_inline, 4722 is_explicit, 4723 false /*is_constexpr*/, 4724 SourceLocation()); 4725 } 4726 } 4727 4728 if (cxx_method_decl == NULL) 4729 { 4730 cxx_method_decl = CXXMethodDecl::Create (*m_ast, 4731 cxx_record_decl, 4732 SourceLocation(), 4733 DeclarationNameInfo (decl_name, SourceLocation()), 4734 method_qual_type, 4735 NULL, // TypeSourceInfo * 4736 SC, 4737 is_inline, 4738 false /*is_constexpr*/, 4739 SourceLocation()); 4740 } 4741 } 4742 4743 AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access); 4744 4745 cxx_method_decl->setAccess (access_specifier); 4746 cxx_method_decl->setVirtualAsWritten (is_virtual); 4747 4748 if (is_attr_used) 4749 cxx_method_decl->addAttr(::new (*m_ast) UsedAttr(SourceRange(), *m_ast)); 4750 4751 // Populate the method decl with parameter decls 4752 4753 llvm::SmallVector<ParmVarDecl *, 12> params; 4754 4755 for (unsigned param_index = 0; 4756 param_index < num_params; 4757 ++param_index) 4758 { 4759 params.push_back (ParmVarDecl::Create (*m_ast, 4760 cxx_method_decl, 4761 SourceLocation(), 4762 SourceLocation(), 4763 NULL, // anonymous 4764 method_function_prototype->getArgType(param_index), 4765 NULL, 4766 SC_None, 4767 NULL)); 4768 } 4769 4770 cxx_method_decl->setParams (ArrayRef<ParmVarDecl*>(params)); 4771 4772 cxx_record_decl->addDecl (cxx_method_decl); 4773 4774 // Sometimes the debug info will mention a constructor (default/copy/move), 4775 // destructor, or assignment operator (copy/move) but there won't be any 4776 // version of this in the code. So we check if the function was artificially 4777 // generated and if it is trivial and this lets the compiler/backend know 4778 // that it can inline the IR for these when it needs to and we can avoid a 4779 // "missing function" error when running expressions. 4780 4781 if (is_artificial) 4782 { 4783 if (cxx_ctor_decl && 4784 ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) || 4785 (cxx_ctor_decl->isCopyConstructor() && cxx_record_decl->hasTrivialCopyConstructor ()) || 4786 (cxx_ctor_decl->isMoveConstructor() && cxx_record_decl->hasTrivialMoveConstructor ()) )) 4787 { 4788 cxx_ctor_decl->setDefaulted(); 4789 cxx_ctor_decl->setTrivial(true); 4790 } 4791 else if (cxx_dtor_decl) 4792 { 4793 if (cxx_record_decl->hasTrivialDestructor()) 4794 { 4795 cxx_dtor_decl->setDefaulted(); 4796 cxx_dtor_decl->setTrivial(true); 4797 } 4798 } 4799 else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) || 4800 (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment())) 4801 { 4802 cxx_method_decl->setDefaulted(); 4803 cxx_method_decl->setTrivial(true); 4804 } 4805 } 4806 4807#ifdef LLDB_CONFIGURATION_DEBUG 4808 VerifyDecl(cxx_method_decl); 4809#endif 4810 4811 // printf ("decl->isPolymorphic() = %i\n", cxx_record_decl->isPolymorphic()); 4812 // printf ("decl->isAggregate() = %i\n", cxx_record_decl->isAggregate()); 4813 // printf ("decl->isPOD() = %i\n", cxx_record_decl->isPOD()); 4814 // printf ("decl->isEmpty() = %i\n", cxx_record_decl->isEmpty()); 4815 // printf ("decl->isAbstract() = %i\n", cxx_record_decl->isAbstract()); 4816 // printf ("decl->hasTrivialConstructor() = %i\n", cxx_record_decl->hasTrivialConstructor()); 4817 // printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor()); 4818 // printf ("decl->hasTrivialCopyAssignment() = %i\n", cxx_record_decl->hasTrivialCopyAssignment()); 4819 // printf ("decl->hasTrivialDestructor() = %i\n", cxx_record_decl->hasTrivialDestructor()); 4820 return cxx_method_decl; 4821} 4822 4823 4824#pragma mark C++ Base Classes 4825 4826CXXBaseSpecifier * 4827ClangASTType::CreateBaseClassSpecifier (AccessType access, bool is_virtual, bool base_of_class) 4828{ 4829 if (IsValid()) 4830 return new CXXBaseSpecifier (SourceRange(), 4831 is_virtual, 4832 base_of_class, 4833 ClangASTContext::ConvertAccessTypeToAccessSpecifier (access), 4834 m_ast->getTrivialTypeSourceInfo (GetQualType()), 4835 SourceLocation()); 4836 return NULL; 4837} 4838 4839void 4840ClangASTType::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes) 4841{ 4842 for (unsigned i=0; i<num_base_classes; ++i) 4843 { 4844 delete base_classes[i]; 4845 base_classes[i] = NULL; 4846 } 4847} 4848 4849bool 4850ClangASTType::SetBaseClassesForClassType (CXXBaseSpecifier const * const *base_classes, 4851 unsigned num_base_classes) 4852{ 4853 if (IsValid()) 4854 { 4855 CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(); 4856 if (cxx_record_decl) 4857 { 4858 cxx_record_decl->setBases(base_classes, num_base_classes); 4859 return true; 4860 } 4861 } 4862 return false; 4863} 4864 4865bool 4866ClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type) 4867{ 4868 if (IsValid() && superclass_clang_type.IsValid()) 4869 { 4870 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 4871 ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl (); 4872 if (class_interface_decl && super_interface_decl) 4873 { 4874 class_interface_decl->setSuperClass(super_interface_decl); 4875 return true; 4876 } 4877 } 4878 return false; 4879} 4880 4881bool 4882ClangASTType::AddObjCClassProperty (const char *property_name, 4883 const ClangASTType &property_clang_type, 4884 ObjCIvarDecl *ivar_decl, 4885 const char *property_setter_name, 4886 const char *property_getter_name, 4887 uint32_t property_attributes, 4888 ClangASTMetadata *metadata) 4889{ 4890 if (!IsValid() || !property_clang_type.IsValid() || property_name == NULL || property_name[0] == '\0') 4891 return false; 4892 4893 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 4894 4895 if (class_interface_decl) 4896 { 4897 ClangASTType property_clang_type_to_access; 4898 4899 if (property_clang_type.IsValid()) 4900 property_clang_type_to_access = property_clang_type; 4901 else if (ivar_decl) 4902 property_clang_type_to_access = ClangASTType (m_ast, ivar_decl->getType()); 4903 4904 if (class_interface_decl && property_clang_type_to_access.IsValid()) 4905 { 4906 clang::TypeSourceInfo *prop_type_source; 4907 if (ivar_decl) 4908 prop_type_source = m_ast->getTrivialTypeSourceInfo (ivar_decl->getType()); 4909 else 4910 prop_type_source = m_ast->getTrivialTypeSourceInfo (property_clang_type.GetQualType()); 4911 4912 ObjCPropertyDecl *property_decl = ObjCPropertyDecl::Create (*m_ast, 4913 class_interface_decl, 4914 SourceLocation(), // Source Location 4915 &m_ast->Idents.get(property_name), 4916 SourceLocation(), //Source Location for AT 4917 SourceLocation(), //Source location for ( 4918 prop_type_source); 4919 4920 if (property_decl) 4921 { 4922 if (metadata) 4923 ClangASTContext::SetMetadata(m_ast, property_decl, *metadata); 4924 4925 class_interface_decl->addDecl (property_decl); 4926 4927 Selector setter_sel, getter_sel; 4928 4929 if (property_setter_name != NULL) 4930 { 4931 std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1); 4932 clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(property_setter_no_colon.c_str()); 4933 setter_sel = m_ast->Selectors.getSelector(1, &setter_ident); 4934 } 4935 else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) 4936 { 4937 std::string setter_sel_string("set"); 4938 setter_sel_string.push_back(::toupper(property_name[0])); 4939 setter_sel_string.append(&property_name[1]); 4940 clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(setter_sel_string.c_str()); 4941 setter_sel = m_ast->Selectors.getSelector(1, &setter_ident); 4942 } 4943 property_decl->setSetterName(setter_sel); 4944 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter); 4945 4946 if (property_getter_name != NULL) 4947 { 4948 clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_getter_name); 4949 getter_sel = m_ast->Selectors.getSelector(0, &getter_ident); 4950 } 4951 else 4952 { 4953 clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_name); 4954 getter_sel = m_ast->Selectors.getSelector(0, &getter_ident); 4955 } 4956 property_decl->setGetterName(getter_sel); 4957 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter); 4958 4959 if (ivar_decl) 4960 property_decl->setPropertyIvarDecl (ivar_decl); 4961 4962 if (property_attributes & DW_APPLE_PROPERTY_readonly) 4963 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly); 4964 if (property_attributes & DW_APPLE_PROPERTY_readwrite) 4965 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite); 4966 if (property_attributes & DW_APPLE_PROPERTY_assign) 4967 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign); 4968 if (property_attributes & DW_APPLE_PROPERTY_retain) 4969 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain); 4970 if (property_attributes & DW_APPLE_PROPERTY_copy) 4971 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy); 4972 if (property_attributes & DW_APPLE_PROPERTY_nonatomic) 4973 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic); 4974 4975 if (!getter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(getter_sel)) 4976 { 4977 const bool isInstance = true; 4978 const bool isVariadic = false; 4979 const bool isSynthesized = false; 4980 const bool isImplicitlyDeclared = true; 4981 const bool isDefined = false; 4982 const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; 4983 const bool HasRelatedResultType = false; 4984 4985 ObjCMethodDecl *getter = ObjCMethodDecl::Create (*m_ast, 4986 SourceLocation(), 4987 SourceLocation(), 4988 getter_sel, 4989 property_clang_type_to_access.GetQualType(), 4990 NULL, 4991 class_interface_decl, 4992 isInstance, 4993 isVariadic, 4994 isSynthesized, 4995 isImplicitlyDeclared, 4996 isDefined, 4997 impControl, 4998 HasRelatedResultType); 4999 5000 if (getter && metadata) 5001 ClangASTContext::SetMetadata(m_ast, getter, *metadata); 5002 5003 getter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(), ArrayRef<SourceLocation>()); 5004 5005 class_interface_decl->addDecl(getter); 5006 } 5007 5008 if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel)) 5009 { 5010 QualType result_type = m_ast->VoidTy; 5011 5012 const bool isInstance = true; 5013 const bool isVariadic = false; 5014 const bool isSynthesized = false; 5015 const bool isImplicitlyDeclared = true; 5016 const bool isDefined = false; 5017 const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; 5018 const bool HasRelatedResultType = false; 5019 5020 ObjCMethodDecl *setter = ObjCMethodDecl::Create (*m_ast, 5021 SourceLocation(), 5022 SourceLocation(), 5023 setter_sel, 5024 result_type, 5025 NULL, 5026 class_interface_decl, 5027 isInstance, 5028 isVariadic, 5029 isSynthesized, 5030 isImplicitlyDeclared, 5031 isDefined, 5032 impControl, 5033 HasRelatedResultType); 5034 5035 if (setter && metadata) 5036 ClangASTContext::SetMetadata(m_ast, setter, *metadata); 5037 5038 llvm::SmallVector<ParmVarDecl *, 1> params; 5039 5040 params.push_back (ParmVarDecl::Create (*m_ast, 5041 setter, 5042 SourceLocation(), 5043 SourceLocation(), 5044 NULL, // anonymous 5045 property_clang_type_to_access.GetQualType(), 5046 NULL, 5047 SC_Auto, 5048 NULL)); 5049 5050 setter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>()); 5051 5052 class_interface_decl->addDecl(setter); 5053 } 5054 5055 return true; 5056 } 5057 } 5058 } 5059 return false; 5060} 5061 5062bool 5063ClangASTType::IsObjCClassTypeAndHasIVars (bool check_superclass) const 5064{ 5065 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 5066 if (class_interface_decl) 5067 return ObjCDeclHasIVars (class_interface_decl, check_superclass); 5068 return false; 5069} 5070 5071 5072ObjCMethodDecl * 5073ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]") 5074 const ClangASTType &method_clang_type, 5075 lldb::AccessType access, 5076 bool is_artificial) 5077{ 5078 if (!IsValid() || !method_clang_type.IsValid()) 5079 return NULL; 5080 5081 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(); 5082 5083 if (class_interface_decl == NULL) 5084 return NULL; 5085 5086 const char *selector_start = ::strchr (name, ' '); 5087 if (selector_start == NULL) 5088 return NULL; 5089 5090 selector_start++; 5091 llvm::SmallVector<IdentifierInfo *, 12> selector_idents; 5092 5093 size_t len = 0; 5094 const char *start; 5095 //printf ("name = '%s'\n", name); 5096 5097 unsigned num_selectors_with_args = 0; 5098 for (start = selector_start; 5099 start && *start != '\0' && *start != ']'; 5100 start += len) 5101 { 5102 len = ::strcspn(start, ":]"); 5103 bool has_arg = (start[len] == ':'); 5104 if (has_arg) 5105 ++num_selectors_with_args; 5106 selector_idents.push_back (&m_ast->Idents.get (StringRef (start, len))); 5107 if (has_arg) 5108 len += 1; 5109 } 5110 5111 5112 if (selector_idents.size() == 0) 5113 return 0; 5114 5115 clang::Selector method_selector = m_ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0, 5116 selector_idents.data()); 5117 5118 QualType method_qual_type (method_clang_type.GetQualType()); 5119 5120 // Populate the method decl with parameter decls 5121 const clang::Type *method_type(method_qual_type.getTypePtr()); 5122 5123 if (method_type == NULL) 5124 return NULL; 5125 5126 const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type)); 5127 5128 if (!method_function_prototype) 5129 return NULL; 5130 5131 5132 bool is_variadic = false; 5133 bool is_synthesized = false; 5134 bool is_defined = false; 5135 ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None; 5136 5137 const unsigned num_args = method_function_prototype->getNumArgs(); 5138 5139 if (num_args != num_selectors_with_args) 5140 return NULL; // some debug information is corrupt. We are not going to deal with it. 5141 5142 ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*m_ast, 5143 SourceLocation(), // beginLoc, 5144 SourceLocation(), // endLoc, 5145 method_selector, 5146 method_function_prototype->getResultType(), 5147 NULL, // TypeSourceInfo *ResultTInfo, 5148 GetDeclContextForType (), 5149 name[0] == '-', 5150 is_variadic, 5151 is_synthesized, 5152 true, // is_implicitly_declared; we force this to true because we don't have source locations 5153 is_defined, 5154 imp_control, 5155 false /*has_related_result_type*/); 5156 5157 5158 if (objc_method_decl == NULL) 5159 return NULL; 5160 5161 if (num_args > 0) 5162 { 5163 llvm::SmallVector<ParmVarDecl *, 12> params; 5164 5165 for (unsigned param_index = 0; param_index < num_args; ++param_index) 5166 { 5167 params.push_back (ParmVarDecl::Create (*m_ast, 5168 objc_method_decl, 5169 SourceLocation(), 5170 SourceLocation(), 5171 NULL, // anonymous 5172 method_function_prototype->getArgType(param_index), 5173 NULL, 5174 SC_Auto, 5175 NULL)); 5176 } 5177 5178 objc_method_decl->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>()); 5179 } 5180 5181 class_interface_decl->addDecl (objc_method_decl); 5182 5183#ifdef LLDB_CONFIGURATION_DEBUG 5184 VerifyDecl(objc_method_decl); 5185#endif 5186 5187 return objc_method_decl; 5188} 5189 5190 5191clang::DeclContext * 5192ClangASTType::GetDeclContextForType () const 5193{ 5194 if (!IsValid()) 5195 return NULL; 5196 5197 QualType qual_type(GetCanonicalQualType()); 5198 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5199 switch (type_class) 5200 { 5201 case clang::Type::UnaryTransform: break; 5202 case clang::Type::FunctionNoProto: break; 5203 case clang::Type::FunctionProto: break; 5204 case clang::Type::IncompleteArray: break; 5205 case clang::Type::VariableArray: break; 5206 case clang::Type::ConstantArray: break; 5207 case clang::Type::DependentSizedArray: break; 5208 case clang::Type::ExtVector: break; 5209 case clang::Type::DependentSizedExtVector: break; 5210 case clang::Type::Vector: break; 5211 case clang::Type::Builtin: break; 5212 case clang::Type::BlockPointer: break; 5213 case clang::Type::Pointer: break; 5214 case clang::Type::LValueReference: break; 5215 case clang::Type::RValueReference: break; 5216 case clang::Type::MemberPointer: break; 5217 case clang::Type::Complex: break; 5218 case clang::Type::ObjCObject: break; 5219 case clang::Type::ObjCInterface: return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface(); 5220 case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType(); 5221 case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl(); 5222 case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl(); 5223 case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType(); 5224 case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDeclContextForType(); 5225 case clang::Type::Paren: return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetDeclContextForType(); 5226 case clang::Type::TypeOfExpr: break; 5227 case clang::Type::TypeOf: break; 5228 case clang::Type::Decltype: break; 5229 //case clang::Type::QualifiedName: break; 5230 case clang::Type::TemplateSpecialization: break; 5231 case clang::Type::DependentTemplateSpecialization: break; 5232 case clang::Type::TemplateTypeParm: break; 5233 case clang::Type::SubstTemplateTypeParm: break; 5234 case clang::Type::SubstTemplateTypeParmPack:break; 5235 case clang::Type::PackExpansion: break; 5236 case clang::Type::UnresolvedUsing: break; 5237 case clang::Type::Attributed: break; 5238 case clang::Type::Auto: break; 5239 case clang::Type::InjectedClassName: break; 5240 case clang::Type::DependentName: break; 5241 case clang::Type::Atomic: break; 5242 5243 // pointer type decayed from an array or function type. 5244 case clang::Type::Decayed: break; 5245 } 5246 // No DeclContext in this type... 5247 return NULL; 5248} 5249 5250bool 5251ClangASTType::SetDefaultAccessForRecordFields (int default_accessibility, 5252 int *assigned_accessibilities, 5253 size_t num_assigned_accessibilities) 5254{ 5255 if (IsValid()) 5256 { 5257 RecordDecl *record_decl = GetAsRecordDecl(); 5258 if (record_decl) 5259 { 5260 uint32_t field_idx; 5261 RecordDecl::field_iterator field, field_end; 5262 for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0; 5263 field != field_end; 5264 ++field, ++field_idx) 5265 { 5266 // If no accessibility was assigned, assign the correct one 5267 if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none) 5268 field->setAccess ((AccessSpecifier)default_accessibility); 5269 } 5270 return true; 5271 } 5272 } 5273 return false; 5274} 5275 5276 5277bool 5278ClangASTType::SetHasExternalStorage (bool has_extern) 5279{ 5280 if (!IsValid()) 5281 return false; 5282 5283 QualType qual_type (GetCanonicalQualType()); 5284 5285 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5286 switch (type_class) 5287 { 5288 case clang::Type::Record: 5289 { 5290 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 5291 if (cxx_record_decl) 5292 { 5293 cxx_record_decl->setHasExternalLexicalStorage (has_extern); 5294 cxx_record_decl->setHasExternalVisibleStorage (has_extern); 5295 return true; 5296 } 5297 } 5298 break; 5299 5300 case clang::Type::Enum: 5301 { 5302 EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl(); 5303 if (enum_decl) 5304 { 5305 enum_decl->setHasExternalLexicalStorage (has_extern); 5306 enum_decl->setHasExternalVisibleStorage (has_extern); 5307 return true; 5308 } 5309 } 5310 break; 5311 5312 case clang::Type::ObjCObject: 5313 case clang::Type::ObjCInterface: 5314 { 5315 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 5316 assert (objc_class_type); 5317 if (objc_class_type) 5318 { 5319 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 5320 5321 if (class_interface_decl) 5322 { 5323 class_interface_decl->setHasExternalLexicalStorage (has_extern); 5324 class_interface_decl->setHasExternalVisibleStorage (has_extern); 5325 return true; 5326 } 5327 } 5328 } 5329 break; 5330 5331 case clang::Type::Typedef: 5332 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern); 5333 5334 case clang::Type::Elaborated: 5335 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).SetHasExternalStorage (has_extern); 5336 5337 case clang::Type::Paren: 5338 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).SetHasExternalStorage (has_extern); 5339 5340 default: 5341 break; 5342 } 5343 return false; 5344} 5345 5346bool 5347ClangASTType::SetTagTypeKind (int kind) const 5348{ 5349 if (IsValid()) 5350 { 5351 QualType tag_qual_type(GetQualType()); 5352 const clang::Type *clang_type = tag_qual_type.getTypePtr(); 5353 if (clang_type) 5354 { 5355 const TagType *tag_type = dyn_cast<TagType>(clang_type); 5356 if (tag_type) 5357 { 5358 TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl()); 5359 if (tag_decl) 5360 { 5361 tag_decl->setTagKind ((TagDecl::TagKind)kind); 5362 return true; 5363 } 5364 } 5365 } 5366 } 5367 return false; 5368} 5369 5370 5371#pragma mark TagDecl 5372 5373bool 5374ClangASTType::StartTagDeclarationDefinition () 5375{ 5376 if (IsValid()) 5377 { 5378 QualType qual_type (GetQualType()); 5379 const clang::Type *t = qual_type.getTypePtr(); 5380 if (t) 5381 { 5382 const TagType *tag_type = dyn_cast<TagType>(t); 5383 if (tag_type) 5384 { 5385 TagDecl *tag_decl = tag_type->getDecl(); 5386 if (tag_decl) 5387 { 5388 tag_decl->startDefinition(); 5389 return true; 5390 } 5391 } 5392 5393 const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(t); 5394 if (object_type) 5395 { 5396 ObjCInterfaceDecl *interface_decl = object_type->getInterface(); 5397 if (interface_decl) 5398 { 5399 interface_decl->startDefinition(); 5400 return true; 5401 } 5402 } 5403 } 5404 } 5405 return false; 5406} 5407 5408bool 5409ClangASTType::CompleteTagDeclarationDefinition () 5410{ 5411 if (IsValid()) 5412 { 5413 QualType qual_type (GetQualType()); 5414 5415 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 5416 5417 if (cxx_record_decl) 5418 { 5419 cxx_record_decl->completeDefinition(); 5420 5421 return true; 5422 } 5423 5424 const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr()); 5425 5426 if (enum_type) 5427 { 5428 EnumDecl *enum_decl = enum_type->getDecl(); 5429 5430 if (enum_decl) 5431 { 5432 /// TODO This really needs to be fixed. 5433 5434 unsigned NumPositiveBits = 1; 5435 unsigned NumNegativeBits = 0; 5436 5437 QualType promotion_qual_type; 5438 // If the enum integer type is less than an integer in bit width, 5439 // then we must promote it to an integer size. 5440 if (m_ast->getTypeSize(enum_decl->getIntegerType()) < m_ast->getTypeSize(m_ast->IntTy)) 5441 { 5442 if (enum_decl->getIntegerType()->isSignedIntegerType()) 5443 promotion_qual_type = m_ast->IntTy; 5444 else 5445 promotion_qual_type = m_ast->UnsignedIntTy; 5446 } 5447 else 5448 promotion_qual_type = enum_decl->getIntegerType(); 5449 5450 enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits); 5451 return true; 5452 } 5453 } 5454 } 5455 return false; 5456} 5457 5458 5459 5460 5461 5462 5463 5464bool 5465ClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerator_clang_type, 5466 const Declaration &decl, 5467 const char *name, 5468 int64_t enum_value, 5469 uint32_t enum_value_bit_size) 5470{ 5471 if (IsValid() && enumerator_clang_type.IsValid() && name && name[0]) 5472 { 5473 QualType enum_qual_type (GetCanonicalQualType()); 5474 5475 bool is_signed = false; 5476 enumerator_clang_type.IsIntegerType (is_signed); 5477 const clang::Type *clang_type = enum_qual_type.getTypePtr(); 5478 if (clang_type) 5479 { 5480 const EnumType *enum_type = dyn_cast<EnumType>(clang_type); 5481 5482 if (enum_type) 5483 { 5484 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed); 5485 enum_llvm_apsint = enum_value; 5486 EnumConstantDecl *enumerator_decl = 5487 EnumConstantDecl::Create (*m_ast, 5488 enum_type->getDecl(), 5489 SourceLocation(), 5490 name ? &m_ast->Idents.get(name) : NULL, // Identifier 5491 enumerator_clang_type.GetQualType(), 5492 NULL, 5493 enum_llvm_apsint); 5494 5495 if (enumerator_decl) 5496 { 5497 enum_type->getDecl()->addDecl(enumerator_decl); 5498 5499#ifdef LLDB_CONFIGURATION_DEBUG 5500 VerifyDecl(enumerator_decl); 5501#endif 5502 5503 return true; 5504 } 5505 } 5506 } 5507 } 5508 return false; 5509} 5510 5511 5512ClangASTType 5513ClangASTType::GetEnumerationIntegerType () const 5514{ 5515 QualType enum_qual_type (GetCanonicalQualType()); 5516 const clang::Type *clang_type = enum_qual_type.getTypePtr(); 5517 if (clang_type) 5518 { 5519 const EnumType *enum_type = dyn_cast<EnumType>(clang_type); 5520 if (enum_type) 5521 { 5522 EnumDecl *enum_decl = enum_type->getDecl(); 5523 if (enum_decl) 5524 return ClangASTType (m_ast, enum_decl->getIntegerType()); 5525 } 5526 } 5527 return ClangASTType(); 5528} 5529 5530ClangASTType 5531ClangASTType::CreateMemberPointerType (const ClangASTType &pointee_type) const 5532{ 5533 if (IsValid() && pointee_type.IsValid()) 5534 { 5535 return ClangASTType (m_ast, m_ast->getMemberPointerType (pointee_type.GetQualType(), 5536 GetQualType().getTypePtr())); 5537 } 5538 return ClangASTType(); 5539} 5540 5541 5542size_t 5543ClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst_size) const 5544{ 5545 if (IsValid()) 5546 { 5547 QualType qual_type (GetCanonicalQualType()); 5548 uint32_t count = 0; 5549 bool is_complex = false; 5550 if (IsFloatingPointType (count, is_complex)) 5551 { 5552 // TODO: handle complex and vector types 5553 if (count != 1) 5554 return false; 5555 5556 StringRef s_sref(s); 5557 APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref); 5558 5559 const uint64_t bit_size = m_ast->getTypeSize (qual_type); 5560 const uint64_t byte_size = bit_size / 8; 5561 if (dst_size >= byte_size) 5562 { 5563 if (bit_size == sizeof(float)*8) 5564 { 5565 float float32 = ap_float.convertToFloat(); 5566 ::memcpy (dst, &float32, byte_size); 5567 return byte_size; 5568 } 5569 else if (bit_size >= 64) 5570 { 5571 llvm::APInt ap_int(ap_float.bitcastToAPInt()); 5572 ::memcpy (dst, ap_int.getRawData(), byte_size); 5573 return byte_size; 5574 } 5575 } 5576 } 5577 } 5578 return 0; 5579} 5580 5581 5582 5583//---------------------------------------------------------------------- 5584// Dumping types 5585//---------------------------------------------------------------------- 5586#define DEPTH_INCREMENT 2 5587 5588void 5589ClangASTType::DumpValue (ExecutionContext *exe_ctx, 5590 Stream *s, 5591 lldb::Format format, 5592 const lldb_private::DataExtractor &data, 5593 lldb::offset_t data_byte_offset, 5594 size_t data_byte_size, 5595 uint32_t bitfield_bit_size, 5596 uint32_t bitfield_bit_offset, 5597 bool show_types, 5598 bool show_summary, 5599 bool verbose, 5600 uint32_t depth) 5601{ 5602 if (!IsValid()) 5603 return; 5604 5605 QualType qual_type(GetQualType()); 5606 switch (qual_type->getTypeClass()) 5607 { 5608 case clang::Type::Record: 5609 if (GetCompleteType ()) 5610 { 5611 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 5612 const RecordDecl *record_decl = record_type->getDecl(); 5613 assert(record_decl); 5614 uint32_t field_bit_offset = 0; 5615 uint32_t field_byte_offset = 0; 5616 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); 5617 uint32_t child_idx = 0; 5618 5619 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 5620 if (cxx_record_decl) 5621 { 5622 // We might have base classes to print out first 5623 CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 5624 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 5625 base_class != base_class_end; 5626 ++base_class) 5627 { 5628 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 5629 5630 // Skip empty base classes 5631 if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false) 5632 continue; 5633 5634 if (base_class->isVirtual()) 5635 field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 5636 else 5637 field_bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 5638 field_byte_offset = field_bit_offset / 8; 5639 assert (field_bit_offset % 8 == 0); 5640 if (child_idx == 0) 5641 s->PutChar('{'); 5642 else 5643 s->PutChar(','); 5644 5645 QualType base_class_qual_type = base_class->getType(); 5646 std::string base_class_type_name(base_class_qual_type.getAsString()); 5647 5648 // Indent and print the base class type name 5649 s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str()); 5650 5651 std::pair<uint64_t, unsigned> base_class_type_info = m_ast->getTypeInfo(base_class_qual_type); 5652 5653 // Dump the value of the member 5654 ClangASTType base_clang_type(m_ast, base_class_qual_type); 5655 base_clang_type.DumpValue (exe_ctx, 5656 s, // Stream to dump to 5657 base_clang_type.GetFormat(), // The format with which to display the member 5658 data, // Data buffer containing all bytes for this type 5659 data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from 5660 base_class_type_info.first / 8, // Size of this type in bytes 5661 0, // Bitfield bit size 5662 0, // Bitfield bit offset 5663 show_types, // Boolean indicating if we should show the variable types 5664 show_summary, // Boolean indicating if we should show a summary for the current type 5665 verbose, // Verbose output? 5666 depth + DEPTH_INCREMENT); // Scope depth for any types that have children 5667 5668 ++child_idx; 5669 } 5670 } 5671 uint32_t field_idx = 0; 5672 RecordDecl::field_iterator field, field_end; 5673 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) 5674 { 5675 // Print the starting squiggly bracket (if this is the 5676 // first member) or comman (for member 2 and beyong) for 5677 // the struct/union/class member. 5678 if (child_idx == 0) 5679 s->PutChar('{'); 5680 else 5681 s->PutChar(','); 5682 5683 // Indent 5684 s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); 5685 5686 QualType field_type = field->getType(); 5687 // Print the member type if requested 5688 // Figure out the type byte size (field_type_info.first) and 5689 // alignment (field_type_info.second) from the AST context. 5690 std::pair<uint64_t, unsigned> field_type_info = m_ast->getTypeInfo(field_type); 5691 assert(field_idx < record_layout.getFieldCount()); 5692 // Figure out the field offset within the current struct/union/class type 5693 field_bit_offset = record_layout.getFieldOffset (field_idx); 5694 field_byte_offset = field_bit_offset / 8; 5695 uint32_t field_bitfield_bit_size = 0; 5696 uint32_t field_bitfield_bit_offset = 0; 5697 if (ClangASTContext::FieldIsBitfield (m_ast, *field, field_bitfield_bit_size)) 5698 field_bitfield_bit_offset = field_bit_offset % 8; 5699 5700 if (show_types) 5701 { 5702 std::string field_type_name(field_type.getAsString()); 5703 if (field_bitfield_bit_size > 0) 5704 s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size); 5705 else 5706 s->Printf("(%s) ", field_type_name.c_str()); 5707 } 5708 // Print the member name and equal sign 5709 s->Printf("%s = ", field->getNameAsString().c_str()); 5710 5711 5712 // Dump the value of the member 5713 ClangASTType field_clang_type (m_ast, field_type); 5714 field_clang_type.DumpValue (exe_ctx, 5715 s, // Stream to dump to 5716 field_clang_type.GetFormat(), // The format with which to display the member 5717 data, // Data buffer containing all bytes for this type 5718 data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from 5719 field_type_info.first / 8, // Size of this type in bytes 5720 field_bitfield_bit_size, // Bitfield bit size 5721 field_bitfield_bit_offset, // Bitfield bit offset 5722 show_types, // Boolean indicating if we should show the variable types 5723 show_summary, // Boolean indicating if we should show a summary for the current type 5724 verbose, // Verbose output? 5725 depth + DEPTH_INCREMENT); // Scope depth for any types that have children 5726 } 5727 5728 // Indent the trailing squiggly bracket 5729 if (child_idx > 0) 5730 s->Printf("\n%*s}", depth, ""); 5731 } 5732 return; 5733 5734 case clang::Type::Enum: 5735 if (GetCompleteType ()) 5736 { 5737 const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr()); 5738 const EnumDecl *enum_decl = enum_type->getDecl(); 5739 assert(enum_decl); 5740 EnumDecl::enumerator_iterator enum_pos, enum_end_pos; 5741 lldb::offset_t offset = data_byte_offset; 5742 const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); 5743 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) 5744 { 5745 if (enum_pos->getInitVal() == enum_value) 5746 { 5747 s->Printf("%s", enum_pos->getNameAsString().c_str()); 5748 return; 5749 } 5750 } 5751 // If we have gotten here we didn't get find the enumerator in the 5752 // enum decl, so just print the integer. 5753 s->Printf("%" PRIi64, enum_value); 5754 } 5755 return; 5756 5757 case clang::Type::ConstantArray: 5758 { 5759 const ConstantArrayType *array = cast<ConstantArrayType>(qual_type.getTypePtr()); 5760 bool is_array_of_characters = false; 5761 QualType element_qual_type = array->getElementType(); 5762 5763 const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); 5764 if (canonical_type) 5765 is_array_of_characters = canonical_type->isCharType(); 5766 5767 const uint64_t element_count = array->getSize().getLimitedValue(); 5768 5769 std::pair<uint64_t, unsigned> field_type_info = m_ast->getTypeInfo(element_qual_type); 5770 5771 uint32_t element_idx = 0; 5772 uint32_t element_offset = 0; 5773 uint64_t element_byte_size = field_type_info.first / 8; 5774 uint32_t element_stride = element_byte_size; 5775 5776 if (is_array_of_characters) 5777 { 5778 s->PutChar('"'); 5779 data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); 5780 s->PutChar('"'); 5781 return; 5782 } 5783 else 5784 { 5785 ClangASTType element_clang_type(m_ast, element_qual_type); 5786 lldb::Format element_format = element_clang_type.GetFormat(); 5787 5788 for (element_idx = 0; element_idx < element_count; ++element_idx) 5789 { 5790 // Print the starting squiggly bracket (if this is the 5791 // first member) or comman (for member 2 and beyong) for 5792 // the struct/union/class member. 5793 if (element_idx == 0) 5794 s->PutChar('{'); 5795 else 5796 s->PutChar(','); 5797 5798 // Indent and print the index 5799 s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx); 5800 5801 // Figure out the field offset within the current struct/union/class type 5802 element_offset = element_idx * element_stride; 5803 5804 // Dump the value of the member 5805 element_clang_type.DumpValue (exe_ctx, 5806 s, // Stream to dump to 5807 element_format, // The format with which to display the element 5808 data, // Data buffer containing all bytes for this type 5809 data_byte_offset + element_offset,// Offset into "data" where to grab value from 5810 element_byte_size, // Size of this type in bytes 5811 0, // Bitfield bit size 5812 0, // Bitfield bit offset 5813 show_types, // Boolean indicating if we should show the variable types 5814 show_summary, // Boolean indicating if we should show a summary for the current type 5815 verbose, // Verbose output? 5816 depth + DEPTH_INCREMENT); // Scope depth for any types that have children 5817 } 5818 5819 // Indent the trailing squiggly bracket 5820 if (element_idx > 0) 5821 s->Printf("\n%*s}", depth, ""); 5822 } 5823 } 5824 return; 5825 5826 case clang::Type::Typedef: 5827 { 5828 QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(); 5829 5830 ClangASTType typedef_clang_type (m_ast, typedef_qual_type); 5831 lldb::Format typedef_format = typedef_clang_type.GetFormat(); 5832 std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type); 5833 uint64_t typedef_byte_size = typedef_type_info.first / 8; 5834 5835 return typedef_clang_type.DumpValue (exe_ctx, 5836 s, // Stream to dump to 5837 typedef_format, // The format with which to display the element 5838 data, // Data buffer containing all bytes for this type 5839 data_byte_offset, // Offset into "data" where to grab value from 5840 typedef_byte_size, // Size of this type in bytes 5841 bitfield_bit_size, // Bitfield bit size 5842 bitfield_bit_offset,// Bitfield bit offset 5843 show_types, // Boolean indicating if we should show the variable types 5844 show_summary, // Boolean indicating if we should show a summary for the current type 5845 verbose, // Verbose output? 5846 depth); // Scope depth for any types that have children 5847 } 5848 break; 5849 5850 case clang::Type::Elaborated: 5851 { 5852 QualType elaborated_qual_type = cast<ElaboratedType>(qual_type)->getNamedType(); 5853 ClangASTType elaborated_clang_type (m_ast, elaborated_qual_type); 5854 lldb::Format elaborated_format = elaborated_clang_type.GetFormat(); 5855 std::pair<uint64_t, unsigned> elaborated_type_info = m_ast->getTypeInfo(elaborated_qual_type); 5856 uint64_t elaborated_byte_size = elaborated_type_info.first / 8; 5857 5858 return elaborated_clang_type.DumpValue (exe_ctx, 5859 s, // Stream to dump to 5860 elaborated_format, // The format with which to display the element 5861 data, // Data buffer containing all bytes for this type 5862 data_byte_offset, // Offset into "data" where to grab value from 5863 elaborated_byte_size, // Size of this type in bytes 5864 bitfield_bit_size, // Bitfield bit size 5865 bitfield_bit_offset,// Bitfield bit offset 5866 show_types, // Boolean indicating if we should show the variable types 5867 show_summary, // Boolean indicating if we should show a summary for the current type 5868 verbose, // Verbose output? 5869 depth); // Scope depth for any types that have children 5870 } 5871 break; 5872 5873 case clang::Type::Paren: 5874 { 5875 QualType desugar_qual_type = cast<ParenType>(qual_type)->desugar(); 5876 ClangASTType desugar_clang_type (m_ast, desugar_qual_type); 5877 5878 lldb::Format desugar_format = desugar_clang_type.GetFormat(); 5879 std::pair<uint64_t, unsigned> desugar_type_info = m_ast->getTypeInfo(desugar_qual_type); 5880 uint64_t desugar_byte_size = desugar_type_info.first / 8; 5881 5882 return desugar_clang_type.DumpValue (exe_ctx, 5883 s, // Stream to dump to 5884 desugar_format, // The format with which to display the element 5885 data, // Data buffer containing all bytes for this type 5886 data_byte_offset, // Offset into "data" where to grab value from 5887 desugar_byte_size, // Size of this type in bytes 5888 bitfield_bit_size, // Bitfield bit size 5889 bitfield_bit_offset,// Bitfield bit offset 5890 show_types, // Boolean indicating if we should show the variable types 5891 show_summary, // Boolean indicating if we should show a summary for the current type 5892 verbose, // Verbose output? 5893 depth); // Scope depth for any types that have children 5894 } 5895 break; 5896 5897 default: 5898 // We are down the a scalar type that we just need to display. 5899 data.Dump(s, 5900 data_byte_offset, 5901 format, 5902 data_byte_size, 5903 1, 5904 UINT32_MAX, 5905 LLDB_INVALID_ADDRESS, 5906 bitfield_bit_size, 5907 bitfield_bit_offset); 5908 5909 if (show_summary) 5910 DumpSummary (exe_ctx, s, data, data_byte_offset, data_byte_size); 5911 break; 5912 } 5913} 5914 5915 5916 5917 5918bool 5919ClangASTType::DumpTypeValue (Stream *s, 5920 lldb::Format format, 5921 const lldb_private::DataExtractor &data, 5922 lldb::offset_t byte_offset, 5923 size_t byte_size, 5924 uint32_t bitfield_bit_size, 5925 uint32_t bitfield_bit_offset, 5926 ExecutionContextScope *exe_scope) 5927{ 5928 if (!IsValid()) 5929 return false; 5930 if (IsAggregateType()) 5931 { 5932 return false; 5933 } 5934 else 5935 { 5936 QualType qual_type(GetQualType()); 5937 5938 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5939 switch (type_class) 5940 { 5941 case clang::Type::Typedef: 5942 { 5943 QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(); 5944 ClangASTType typedef_clang_type (m_ast, typedef_qual_type); 5945 if (format == eFormatDefault) 5946 format = typedef_clang_type.GetFormat(); 5947 std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type); 5948 uint64_t typedef_byte_size = typedef_type_info.first / 8; 5949 5950 return typedef_clang_type.DumpTypeValue (s, 5951 format, // The format with which to display the element 5952 data, // Data buffer containing all bytes for this type 5953 byte_offset, // Offset into "data" where to grab value from 5954 typedef_byte_size, // Size of this type in bytes 5955 bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield 5956 bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0 5957 exe_scope); 5958 } 5959 break; 5960 5961 case clang::Type::Enum: 5962 // If our format is enum or default, show the enumeration value as 5963 // its enumeration string value, else just display it as requested. 5964 if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType ()) 5965 { 5966 const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr()); 5967 const EnumDecl *enum_decl = enum_type->getDecl(); 5968 assert(enum_decl); 5969 EnumDecl::enumerator_iterator enum_pos, enum_end_pos; 5970 const bool is_signed = qual_type->isSignedIntegerOrEnumerationType(); 5971 lldb::offset_t offset = byte_offset; 5972 if (is_signed) 5973 { 5974 const int64_t enum_svalue = data.GetMaxS64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); 5975 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) 5976 { 5977 if (enum_pos->getInitVal().getSExtValue() == enum_svalue) 5978 { 5979 s->PutCString (enum_pos->getNameAsString().c_str()); 5980 return true; 5981 } 5982 } 5983 // If we have gotten here we didn't get find the enumerator in the 5984 // enum decl, so just print the integer. 5985 s->Printf("%" PRIi64, enum_svalue); 5986 } 5987 else 5988 { 5989 const uint64_t enum_uvalue = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); 5990 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) 5991 { 5992 if (enum_pos->getInitVal().getZExtValue() == enum_uvalue) 5993 { 5994 s->PutCString (enum_pos->getNameAsString().c_str()); 5995 return true; 5996 } 5997 } 5998 // If we have gotten here we didn't get find the enumerator in the 5999 // enum decl, so just print the integer. 6000 s->Printf("%" PRIu64, enum_uvalue); 6001 } 6002 return true; 6003 } 6004 // format was not enum, just fall through and dump the value as requested.... 6005 6006 default: 6007 // We are down the a scalar type that we just need to display. 6008 { 6009 uint32_t item_count = 1; 6010 // A few formats, we might need to modify our size and count for depending 6011 // on how we are trying to display the value... 6012 switch (format) 6013 { 6014 default: 6015 case eFormatBoolean: 6016 case eFormatBinary: 6017 case eFormatComplex: 6018 case eFormatCString: // NULL terminated C strings 6019 case eFormatDecimal: 6020 case eFormatEnum: 6021 case eFormatHex: 6022 case eFormatHexUppercase: 6023 case eFormatFloat: 6024 case eFormatOctal: 6025 case eFormatOSType: 6026 case eFormatUnsigned: 6027 case eFormatPointer: 6028 case eFormatVectorOfChar: 6029 case eFormatVectorOfSInt8: 6030 case eFormatVectorOfUInt8: 6031 case eFormatVectorOfSInt16: 6032 case eFormatVectorOfUInt16: 6033 case eFormatVectorOfSInt32: 6034 case eFormatVectorOfUInt32: 6035 case eFormatVectorOfSInt64: 6036 case eFormatVectorOfUInt64: 6037 case eFormatVectorOfFloat32: 6038 case eFormatVectorOfFloat64: 6039 case eFormatVectorOfUInt128: 6040 break; 6041 6042 case eFormatChar: 6043 case eFormatCharPrintable: 6044 case eFormatCharArray: 6045 case eFormatBytes: 6046 case eFormatBytesWithASCII: 6047 item_count = byte_size; 6048 byte_size = 1; 6049 break; 6050 6051 case eFormatUnicode16: 6052 item_count = byte_size / 2; 6053 byte_size = 2; 6054 break; 6055 6056 case eFormatUnicode32: 6057 item_count = byte_size / 4; 6058 byte_size = 4; 6059 break; 6060 } 6061 return data.Dump (s, 6062 byte_offset, 6063 format, 6064 byte_size, 6065 item_count, 6066 UINT32_MAX, 6067 LLDB_INVALID_ADDRESS, 6068 bitfield_bit_size, 6069 bitfield_bit_offset, 6070 exe_scope); 6071 } 6072 break; 6073 } 6074 } 6075 return 0; 6076} 6077 6078 6079 6080void 6081ClangASTType::DumpSummary (ExecutionContext *exe_ctx, 6082 Stream *s, 6083 const lldb_private::DataExtractor &data, 6084 lldb::offset_t data_byte_offset, 6085 size_t data_byte_size) 6086{ 6087 uint32_t length = 0; 6088 if (IsCStringType (length)) 6089 { 6090 if (exe_ctx) 6091 { 6092 Process *process = exe_ctx->GetProcessPtr(); 6093 if (process) 6094 { 6095 lldb::offset_t offset = data_byte_offset; 6096 lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size); 6097 std::vector<uint8_t> buf; 6098 if (length > 0) 6099 buf.resize (length); 6100 else 6101 buf.resize (256); 6102 6103 lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), process->GetByteOrder(), 4); 6104 buf.back() = '\0'; 6105 size_t bytes_read; 6106 size_t total_cstr_len = 0; 6107 Error error; 6108 while ((bytes_read = process->ReadMemory (pointer_addresss, &buf.front(), buf.size(), error)) > 0) 6109 { 6110 const size_t len = strlen((const char *)&buf.front()); 6111 if (len == 0) 6112 break; 6113 if (total_cstr_len == 0) 6114 s->PutCString (" \""); 6115 cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); 6116 total_cstr_len += len; 6117 if (len < buf.size()) 6118 break; 6119 pointer_addresss += total_cstr_len; 6120 } 6121 if (total_cstr_len > 0) 6122 s->PutChar ('"'); 6123 } 6124 } 6125 } 6126} 6127 6128void 6129ClangASTType::DumpTypeDescription () const 6130{ 6131 StreamFile s (stdout, false); 6132 DumpTypeDescription (&s); 6133 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, m_type); 6134 if (metadata) 6135 { 6136 metadata->Dump (&s); 6137 } 6138} 6139 6140void 6141ClangASTType::DumpTypeDescription (Stream *s) const 6142{ 6143 if (IsValid()) 6144 { 6145 QualType qual_type(GetQualType()); 6146 6147 SmallVector<char, 1024> buf; 6148 raw_svector_ostream llvm_ostrm (buf); 6149 6150 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 6151 switch (type_class) 6152 { 6153 case clang::Type::ObjCObject: 6154 case clang::Type::ObjCInterface: 6155 { 6156 GetCompleteType (); 6157 6158 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 6159 assert (objc_class_type); 6160 if (objc_class_type) 6161 { 6162 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 6163 if (class_interface_decl) 6164 { 6165 PrintingPolicy policy = m_ast->getPrintingPolicy(); 6166 class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel()); 6167 } 6168 } 6169 } 6170 break; 6171 6172 case clang::Type::Typedef: 6173 { 6174 const TypedefType *typedef_type = qual_type->getAs<TypedefType>(); 6175 if (typedef_type) 6176 { 6177 const TypedefNameDecl *typedef_decl = typedef_type->getDecl(); 6178 std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); 6179 if (!clang_typedef_name.empty()) 6180 { 6181 s->PutCString ("typedef "); 6182 s->PutCString (clang_typedef_name.c_str()); 6183 } 6184 } 6185 } 6186 break; 6187 6188 case clang::Type::Elaborated: 6189 ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s); 6190 return; 6191 6192 case clang::Type::Paren: 6193 ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).DumpTypeDescription(s); 6194 return; 6195 6196 case clang::Type::Record: 6197 { 6198 GetCompleteType (); 6199 6200 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 6201 const RecordDecl *record_decl = record_type->getDecl(); 6202 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 6203 6204 if (cxx_record_decl) 6205 cxx_record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel()); 6206 else 6207 record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel()); 6208 } 6209 break; 6210 6211 default: 6212 { 6213 const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr()); 6214 if (tag_type) 6215 { 6216 TagDecl *tag_decl = tag_type->getDecl(); 6217 if (tag_decl) 6218 tag_decl->print(llvm_ostrm, 0); 6219 } 6220 else 6221 { 6222 std::string clang_type_name(qual_type.getAsString()); 6223 if (!clang_type_name.empty()) 6224 s->PutCString (clang_type_name.c_str()); 6225 } 6226 } 6227 } 6228 6229 llvm_ostrm.flush(); 6230 if (buf.size() > 0) 6231 { 6232 s->Write (buf.data(), buf.size()); 6233 } 6234 } 6235} 6236 6237bool 6238ClangASTType::GetValueAsScalar (const lldb_private::DataExtractor &data, 6239 lldb::offset_t data_byte_offset, 6240 size_t data_byte_size, 6241 Scalar &value) const 6242{ 6243 if (!IsValid()) 6244 return false; 6245 6246 if (IsAggregateType ()) 6247 { 6248 return false; // Aggregate types don't have scalar values 6249 } 6250 else 6251 { 6252 uint64_t count = 0; 6253 lldb::Encoding encoding = GetEncoding (count); 6254 6255 if (encoding == lldb::eEncodingInvalid || count != 1) 6256 return false; 6257 6258 const uint64_t byte_size = GetByteSize(); 6259 lldb::offset_t offset = data_byte_offset; 6260 switch (encoding) 6261 { 6262 case lldb::eEncodingInvalid: 6263 break; 6264 case lldb::eEncodingVector: 6265 break; 6266 case lldb::eEncodingUint: 6267 if (byte_size <= sizeof(unsigned long long)) 6268 { 6269 uint64_t uval64 = data.GetMaxU64 (&offset, byte_size); 6270 if (byte_size <= sizeof(unsigned int)) 6271 { 6272 value = (unsigned int)uval64; 6273 return true; 6274 } 6275 else if (byte_size <= sizeof(unsigned long)) 6276 { 6277 value = (unsigned long)uval64; 6278 return true; 6279 } 6280 else if (byte_size <= sizeof(unsigned long long)) 6281 { 6282 value = (unsigned long long )uval64; 6283 return true; 6284 } 6285 else 6286 value.Clear(); 6287 } 6288 break; 6289 6290 case lldb::eEncodingSint: 6291 if (byte_size <= sizeof(long long)) 6292 { 6293 int64_t sval64 = data.GetMaxS64 (&offset, byte_size); 6294 if (byte_size <= sizeof(int)) 6295 { 6296 value = (int)sval64; 6297 return true; 6298 } 6299 else if (byte_size <= sizeof(long)) 6300 { 6301 value = (long)sval64; 6302 return true; 6303 } 6304 else if (byte_size <= sizeof(long long)) 6305 { 6306 value = (long long )sval64; 6307 return true; 6308 } 6309 else 6310 value.Clear(); 6311 } 6312 break; 6313 6314 case lldb::eEncodingIEEE754: 6315 if (byte_size <= sizeof(long double)) 6316 { 6317 uint32_t u32; 6318 uint64_t u64; 6319 if (byte_size == sizeof(float)) 6320 { 6321 if (sizeof(float) == sizeof(uint32_t)) 6322 { 6323 u32 = data.GetU32(&offset); 6324 value = *((float *)&u32); 6325 return true; 6326 } 6327 else if (sizeof(float) == sizeof(uint64_t)) 6328 { 6329 u64 = data.GetU64(&offset); 6330 value = *((float *)&u64); 6331 return true; 6332 } 6333 } 6334 else 6335 if (byte_size == sizeof(double)) 6336 { 6337 if (sizeof(double) == sizeof(uint32_t)) 6338 { 6339 u32 = data.GetU32(&offset); 6340 value = *((double *)&u32); 6341 return true; 6342 } 6343 else if (sizeof(double) == sizeof(uint64_t)) 6344 { 6345 u64 = data.GetU64(&offset); 6346 value = *((double *)&u64); 6347 return true; 6348 } 6349 } 6350 else 6351 if (byte_size == sizeof(long double)) 6352 { 6353 if (sizeof(long double) == sizeof(uint32_t)) 6354 { 6355 u32 = data.GetU32(&offset); 6356 value = *((long double *)&u32); 6357 return true; 6358 } 6359 else if (sizeof(long double) == sizeof(uint64_t)) 6360 { 6361 u64 = data.GetU64(&offset); 6362 value = *((long double *)&u64); 6363 return true; 6364 } 6365 } 6366 } 6367 break; 6368 } 6369 } 6370 return false; 6371} 6372 6373bool 6374ClangASTType::SetValueFromScalar (const Scalar &value, Stream &strm) 6375{ 6376 // Aggregate types don't have scalar values 6377 if (!IsAggregateType ()) 6378 { 6379 strm.GetFlags().Set(Stream::eBinary); 6380 uint64_t count = 0; 6381 lldb::Encoding encoding = GetEncoding (count); 6382 6383 if (encoding == lldb::eEncodingInvalid || count != 1) 6384 return false; 6385 6386 const uint64_t bit_width = GetBitSize(); 6387 // This function doesn't currently handle non-byte aligned assignments 6388 if ((bit_width % 8) != 0) 6389 return false; 6390 6391 const uint64_t byte_size = (bit_width + 7 ) / 8; 6392 switch (encoding) 6393 { 6394 case lldb::eEncodingInvalid: 6395 break; 6396 case lldb::eEncodingVector: 6397 break; 6398 case lldb::eEncodingUint: 6399 switch (byte_size) 6400 { 6401 case 1: strm.PutHex8(value.UInt()); return true; 6402 case 2: strm.PutHex16(value.UInt()); return true; 6403 case 4: strm.PutHex32(value.UInt()); return true; 6404 case 8: strm.PutHex64(value.ULongLong()); return true; 6405 default: 6406 break; 6407 } 6408 break; 6409 6410 case lldb::eEncodingSint: 6411 switch (byte_size) 6412 { 6413 case 1: strm.PutHex8(value.SInt()); return true; 6414 case 2: strm.PutHex16(value.SInt()); return true; 6415 case 4: strm.PutHex32(value.SInt()); return true; 6416 case 8: strm.PutHex64(value.SLongLong()); return true; 6417 default: 6418 break; 6419 } 6420 break; 6421 6422 case lldb::eEncodingIEEE754: 6423 if (byte_size <= sizeof(long double)) 6424 { 6425 if (byte_size == sizeof(float)) 6426 { 6427 strm.PutFloat(value.Float()); 6428 return true; 6429 } 6430 else 6431 if (byte_size == sizeof(double)) 6432 { 6433 strm.PutDouble(value.Double()); 6434 return true; 6435 } 6436 else 6437 if (byte_size == sizeof(long double)) 6438 { 6439 strm.PutDouble(value.LongDouble()); 6440 return true; 6441 } 6442 } 6443 break; 6444 } 6445 } 6446 return false; 6447} 6448 6449bool 6450ClangASTType::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx, 6451 lldb::addr_t addr, 6452 AddressType address_type, 6453 lldb_private::DataExtractor &data) 6454{ 6455 if (!IsValid()) 6456 return false; 6457 6458 // Can't convert a file address to anything valid without more 6459 // context (which Module it came from) 6460 if (address_type == eAddressTypeFile) 6461 return false; 6462 6463 if (!GetCompleteType()) 6464 return false; 6465 6466 const uint64_t byte_size = GetByteSize(); 6467 if (data.GetByteSize() < byte_size) 6468 { 6469 lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0')); 6470 data.SetData(data_sp); 6471 } 6472 6473 uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size); 6474 if (dst != NULL) 6475 { 6476 if (address_type == eAddressTypeHost) 6477 { 6478 if (addr == 0) 6479 return false; 6480 // The address is an address in this process, so just copy it 6481 memcpy (dst, (uint8_t*)NULL + addr, byte_size); 6482 return true; 6483 } 6484 else 6485 { 6486 Process *process = NULL; 6487 if (exe_ctx) 6488 process = exe_ctx->GetProcessPtr(); 6489 if (process) 6490 { 6491 Error error; 6492 return process->ReadMemory(addr, dst, byte_size, error) == byte_size; 6493 } 6494 } 6495 } 6496 return false; 6497} 6498 6499bool 6500ClangASTType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx, 6501 lldb::addr_t addr, 6502 AddressType address_type, 6503 StreamString &new_value) 6504{ 6505 if (!IsValid()) 6506 return false; 6507 6508 // Can't convert a file address to anything valid without more 6509 // context (which Module it came from) 6510 if (address_type == eAddressTypeFile) 6511 return false; 6512 6513 if (!GetCompleteType()) 6514 return false; 6515 6516 const uint64_t byte_size = GetByteSize(); 6517 6518 if (byte_size > 0) 6519 { 6520 if (address_type == eAddressTypeHost) 6521 { 6522 // The address is an address in this process, so just copy it 6523 memcpy ((void *)addr, new_value.GetData(), byte_size); 6524 return true; 6525 } 6526 else 6527 { 6528 Process *process = NULL; 6529 if (exe_ctx) 6530 process = exe_ctx->GetProcessPtr(); 6531 if (process) 6532 { 6533 Error error; 6534 return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size; 6535 } 6536 } 6537 } 6538 return false; 6539} 6540 6541 6542//CXXRecordDecl * 6543//ClangASTType::GetAsCXXRecordDecl (lldb::clang_type_t opaque_clang_qual_type) 6544//{ 6545// if (opaque_clang_qual_type) 6546// return QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl(); 6547// return NULL; 6548//} 6549 6550bool 6551lldb_private::operator == (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs) 6552{ 6553 return lhs.GetASTContext() == rhs.GetASTContext() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType(); 6554} 6555 6556 6557bool 6558lldb_private::operator != (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs) 6559{ 6560 return lhs.GetASTContext() != rhs.GetASTContext() || lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType(); 6561} 6562 6563 6564