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