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