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