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