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