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