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