contrib/llvm/tools/lldb/source/Expression/ClangASTSource.cpp

   1 //===-- ClangASTSource.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
  11 #include "clang/AST/ASTContext.h"
  12 #include "clang/AST/RecordLayout.h"
  13 #include "lldb/Core/Log.h"
  14 #include "lldb/Core/Module.h"
  15 #include "lldb/Core/ModuleList.h"
  16 #include "lldb/Expression/ASTDumper.h"
  17 #include "lldb/Expression/ClangASTSource.h"
  18 #include "lldb/Expression/ClangExpression.h"
  19 #include "lldb/Symbol/ClangNamespaceDecl.h"
  20 #include "lldb/Symbol/Function.h"
  21 #include "lldb/Symbol/SymbolVendor.h"
  22 #include "lldb/Target/ObjCLanguageRuntime.h"
  23 #include "lldb/Target/Target.h"
  24
  25 using namespace clang;
  26 using namespace lldb_private;
  27
  28 ClangASTSource::~ClangASTSource()
  29 {
  30     m_ast_importer->ForgetDestination(m_ast_context);
  31
  32     // We are in the process of destruction, don't create clang ast context on demand
  33     // by passing false to Target::GetScratchClangASTContext(create_on_demand).
  34     ClangASTContext *scratch_clang_ast_context = m_target->GetScratchClangASTContext(false);
  35
  36     if (!scratch_clang_ast_context)
  37         return;
  38
  39     clang::ASTContext *scratch_ast_context = scratch_clang_ast_context->getASTContext();
  40
  41     if (!scratch_ast_context)
  42         return;
  43
  44     if (m_ast_context != scratch_ast_context)
  45         m_ast_importer->ForgetSource(scratch_ast_context, m_ast_context);
  46 }
  47
  48 void
  49 ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer)
  50 {
  51     if (!m_ast_context)
  52         return;
  53
  54     m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage();
  55     m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage();
  56 }
  57
  58 // The core lookup interface.
  59 bool
  60 ClangASTSource::FindExternalVisibleDeclsByName
  61 (
  62     const DeclContext *decl_ctx,
  63     DeclarationName clang_decl_name
  64 )
  65 {
  66     if (!m_ast_context)
  67     {
  68         SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
  69         return false;
  70     }
  71
  72     if (GetImportInProgress())
  73     {
  74         SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
  75         return false;
  76     }
  77
  78     std::string decl_name (clang_decl_name.getAsString());
  79
  80 //    if (m_decl_map.DoingASTImport ())
  81 //      return DeclContext::lookup_result();
  82 //
  83     switch (clang_decl_name.getNameKind()) {
  84     // Normal identifiers.
  85     case DeclarationName::Identifier:
  86         {
  87             clang::IdentifierInfo *identifier_info = clang_decl_name.getAsIdentifierInfo();
  88
  89             if (!identifier_info ||
  90                 identifier_info->getBuiltinID() != 0)
  91             {
  92                 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
  93                 return false;
  94             }
  95         }
  96         break;
  97
  98     // Operator names.  Not important for now.
  99     case DeclarationName::CXXOperatorName:
 100     case DeclarationName::CXXLiteralOperatorName:
 101       SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
 102       return false;
 103
 104     // Using directives found in this context.
 105     // Tell Sema we didn't find any or we'll end up getting asked a *lot*.
 106     case DeclarationName::CXXUsingDirective:
 107       SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
 108       return false;
 109
 110     case DeclarationName::ObjCZeroArgSelector:
 111     case DeclarationName::ObjCOneArgSelector:
 112     case DeclarationName::ObjCMultiArgSelector:
 113     {
 114       llvm::SmallVector<NamedDecl*, 1> method_decls;
 115
 116       NameSearchContext method_search_context (*this, method_decls, clang_decl_name, decl_ctx);
 117
 118       FindObjCMethodDecls(method_search_context);
 119
 120       SetExternalVisibleDeclsForName (decl_ctx, clang_decl_name, method_decls);
 121       return (method_decls.size() > 0);
 122     }
 123     // These aren't possible in the global context.
 124     case DeclarationName::CXXConstructorName:
 125     case DeclarationName::CXXDestructorName:
 126     case DeclarationName::CXXConversionFunctionName:
 127       SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
 128       return false;
 129     }
 130
 131
 132     if (!GetLookupsEnabled())
 133     {
 134         // Wait until we see a '$' at the start of a name before we start doing
 135         // any lookups so we can avoid lookup up all of the builtin types.
 136         if (!decl_name.empty() && decl_name[0] == '$')
 137         {
 138             SetLookupsEnabled (true);
 139         }
 140         else
 141         {
 142             SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
 143             return false;
 144         }
 145     }
 146
 147     ConstString const_decl_name(decl_name.c_str());
 148
 149     const char *uniqued_const_decl_name = const_decl_name.GetCString();
 150     if (m_active_lookups.find (uniqued_const_decl_name) != m_active_lookups.end())
 151     {
 152         // We are currently looking up this name...
 153         SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
 154         return false;
 155     }
 156     m_active_lookups.insert(uniqued_const_decl_name);
 157 //  static uint32_t g_depth = 0;
 158 //  ++g_depth;
 159 //  printf("[%5u] FindExternalVisibleDeclsByName() \"%s\"\n", g_depth, uniqued_const_decl_name);
 160     llvm::SmallVector<NamedDecl*, 4> name_decls;
 161     NameSearchContext name_search_context(*this, name_decls, clang_decl_name, decl_ctx);
 162     FindExternalVisibleDecls(name_search_context);
 163     SetExternalVisibleDeclsForName (decl_ctx, clang_decl_name, name_decls);
 164 //  --g_depth;
 165     m_active_lookups.erase (uniqued_const_decl_name);
 166     return (name_decls.size() != 0);
 167 }
 168
 169 void
 170 ClangASTSource::CompleteType (TagDecl *tag_decl)
 171 {
 172     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 173
 174     static unsigned int invocation_id = 0;
 175     unsigned int current_id = invocation_id++;
 176
 177     if (log)
 178     {
 179         log->Printf("    CompleteTagDecl[%u] on (ASTContext*)%p Completing (TagDecl*)%p named %s",
 180                     current_id,
 181                     m_ast_context,
 182                     tag_decl,
 183                     tag_decl->getName().str().c_str());
 184
 185         log->Printf("      CTD[%u] Before:", current_id);
 186         ASTDumper dumper((Decl*)tag_decl);
 187         dumper.ToLog(log, "      [CTD] ");
 188     }
 189
 190     if (!m_ast_importer->CompleteTagDecl (tag_decl))
 191     {
 192         // We couldn't complete the type.  Maybe there's a definition
 193         // somewhere else that can be completed.
 194
 195         if (log)
 196             log->Printf("      CTD[%u] Type could not be completed in the module in which it was first found.", current_id);
 197
 198         bool found = false;
 199
 200         DeclContext *decl_ctx = tag_decl->getDeclContext();
 201
 202         if (const NamespaceDecl *namespace_context = dyn_cast<NamespaceDecl>(decl_ctx))
 203         {
 204             ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer->GetNamespaceMap(namespace_context);
 205
 206             if (log && log->GetVerbose())
 207                 log->Printf("      CTD[%u] Inspecting namespace map %p (%d entries)",
 208                             current_id,
 209                             namespace_map.get(),
 210                             (int)namespace_map->size());
 211
 212             if (!namespace_map)
 213                 return;
 214
 215             for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), e = namespace_map->end();
 216                  i != e && !found;
 217                  ++i)
 218             {
 219                 if (log)
 220                     log->Printf("      CTD[%u] Searching namespace %s in module %s",
 221                                 current_id,
 222                                 i->second.GetNamespaceDecl()->getNameAsString().c_str(),
 223                                 i->first->GetFileSpec().GetFilename().GetCString());
 224
 225                 TypeList types;
 226
 227                 SymbolContext null_sc;
 228                 ConstString name(tag_decl->getName().str().c_str());
 229
 230                 i->first->FindTypesInNamespace(null_sc, name, &i->second, UINT32_MAX, types);
 231
 232                 for (uint32_t ti = 0, te = types.GetSize();
 233                      ti != te && !found;
 234                      ++ti)
 235                 {
 236                     lldb::TypeSP type = types.GetTypeAtIndex(ti);
 237
 238                     if (!type)
 239                         continue;
 240
 241                     ClangASTType clang_type (type->GetClangFullType());
 242
 243                     if (!clang_type)
 244                         continue;
 245
 246                     const TagType *tag_type = clang_type.GetQualType()->getAs<TagType>();
 247
 248                     if (!tag_type)
 249                         continue;
 250
 251                     TagDecl *candidate_tag_decl = const_cast<TagDecl*>(tag_type->getDecl());
 252
 253                     if (m_ast_importer->CompleteTagDeclWithOrigin (tag_decl, candidate_tag_decl))
 254                         found = true;
 255                 }
 256             }
 257         }
 258         else
 259         {
 260             TypeList types;
 261
 262             SymbolContext null_sc;
 263             ConstString name(tag_decl->getName().str().c_str());
 264             ClangNamespaceDecl namespace_decl;
 265
 266             const ModuleList &module_list = m_target->GetImages();
 267
 268             bool exact_match = false;
 269             module_list.FindTypes (null_sc, name, exact_match, UINT32_MAX, types);
 270
 271             for (uint32_t ti = 0, te = types.GetSize();
 272                  ti != te && !found;
 273                  ++ti)
 274             {
 275                 lldb::TypeSP type = types.GetTypeAtIndex(ti);
 276
 277                 if (!type)
 278                     continue;
 279
 280                 ClangASTType clang_type (type->GetClangFullType());
 281
 282                 if (!clang_type)
 283                     continue;
 284
 285                 const TagType *tag_type = clang_type.GetQualType()->getAs<TagType>();
 286
 287                 if (!tag_type)
 288                     continue;
 289
 290                 TagDecl *candidate_tag_decl = const_cast<TagDecl*>(tag_type->getDecl());
 291
 292                 if (m_ast_importer->CompleteTagDeclWithOrigin (tag_decl, candidate_tag_decl))
 293                     found = true;
 294             }
 295         }
 296     }
 297
 298     if (log)
 299     {
 300         log->Printf("      [CTD] After:");
 301         ASTDumper dumper((Decl*)tag_decl);
 302         dumper.ToLog(log, "      [CTD] ");
 303     }
 304 }
 305
 306 void
 307 ClangASTSource::CompleteType (clang::ObjCInterfaceDecl *interface_decl)
 308 {
 309     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 310
 311     if (log)
 312     {
 313         log->Printf("    [CompleteObjCInterfaceDecl] on (ASTContext*)%p Completing an ObjCInterfaceDecl named %s", m_ast_context, interface_decl->getName().str().c_str());
 314         log->Printf("      [COID] Before:");
 315         ASTDumper dumper((Decl*)interface_decl);
 316         dumper.ToLog(log, "      [COID] ");
 317     }
 318
 319     m_ast_importer->CompleteObjCInterfaceDecl (interface_decl);
 320
 321     if (log)
 322     {
 323         log->Printf("      [COID] After:");
 324         ASTDumper dumper((Decl*)interface_decl);
 325         dumper.ToLog(log, "      [COID] ");
 326     }
 327 }
 328
 329 clang::ObjCInterfaceDecl *
 330 ClangASTSource::GetCompleteObjCInterface (clang::ObjCInterfaceDecl *interface_decl)
 331 {
 332     lldb::ProcessSP process(m_target->GetProcessSP());
 333
 334     if (!process)
 335         return NULL;
 336
 337     ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
 338
 339     if (!language_runtime)
 340         return NULL;
 341
 342     ConstString class_name(interface_decl->getNameAsString().c_str());
 343
 344     lldb::TypeSP complete_type_sp(language_runtime->LookupInCompleteClassCache(class_name));
 345
 346     if (!complete_type_sp)
 347         return NULL;
 348
 349     TypeFromUser complete_type = TypeFromUser(complete_type_sp->GetClangFullType());
 350     lldb::clang_type_t complete_opaque_type = complete_type.GetOpaqueQualType();
 351
 352     if (!complete_opaque_type)
 353         return NULL;
 354
 355     const clang::Type *complete_clang_type = QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr();
 356     const ObjCInterfaceType *complete_interface_type = dyn_cast<ObjCInterfaceType>(complete_clang_type);
 357
 358     if (!complete_interface_type)
 359         return NULL;
 360
 361     ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl());
 362
 363     return complete_iface_decl;
 364 }
 365
 366 clang::ExternalLoadResult
 367 ClangASTSource::FindExternalLexicalDecls (const DeclContext *decl_context,
 368                                           bool (*predicate)(Decl::Kind),
 369                                           llvm::SmallVectorImpl<Decl*> &decls)
 370 {
 371     ClangASTMetrics::RegisterLexicalQuery();
 372
 373     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 374
 375     const Decl *context_decl = dyn_cast<Decl>(decl_context);
 376
 377     if (!context_decl)
 378         return ELR_Failure;
 379
 380     static unsigned int invocation_id = 0;
 381     unsigned int current_id = invocation_id++;
 382
 383     if (log)
 384     {
 385         if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl))
 386             log->Printf("FindExternalLexicalDecls[%u] on (ASTContext*)%p in '%s' (%sDecl*)%p with %s predicate",
 387                         current_id,
 388                         m_ast_context,
 389                         context_named_decl->getNameAsString().c_str(),
 390                         context_decl->getDeclKindName(),
 391                         context_decl,
 392                         (predicate ? "non-null" : "null"));
 393         else if(context_decl)
 394             log->Printf("FindExternalLexicalDecls[%u] on (ASTContext*)%p in (%sDecl*)%p with %s predicate",
 395                         current_id,
 396                         m_ast_context,
 397                         context_decl->getDeclKindName(),
 398                         context_decl,
 399                         (predicate ? "non-null" : "null"));
 400         else
 401             log->Printf("FindExternalLexicalDecls[%u] on (ASTContext*)%p in a NULL context with %s predicate",
 402                         current_id,
 403                         m_ast_context,
 404                         (predicate ? "non-null" : "null"));
 405     }
 406
 407     Decl *original_decl = NULL;
 408     ASTContext *original_ctx = NULL;
 409
 410     if (!m_ast_importer->ResolveDeclOrigin(context_decl, &original_decl, &original_ctx))
 411         return ELR_Failure;
 412
 413     if (log)
 414     {
 415         log->Printf("  FELD[%u] Original decl (ASTContext*)%p (Decl*)%p:", current_id, original_ctx, original_decl);
 416         ASTDumper(original_decl).ToLog(log, "    ");
 417     }
 418
 419     if (ObjCInterfaceDecl *original_iface_decl = dyn_cast<ObjCInterfaceDecl>(original_decl))
 420     {
 421         ObjCInterfaceDecl *complete_iface_decl = GetCompleteObjCInterface(original_iface_decl);
 422
 423         if (complete_iface_decl && (complete_iface_decl != original_iface_decl))
 424         {
 425             original_decl = complete_iface_decl;
 426             original_ctx = &complete_iface_decl->getASTContext();
 427
 428             m_ast_importer->SetDeclOrigin(context_decl, original_iface_decl);
 429         }
 430     }
 431
 432     if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl))
 433     {
 434         ExternalASTSource *external_source = original_ctx->getExternalSource();
 435
 436         if (external_source)
 437             external_source->CompleteType (original_tag_decl);
 438     }
 439
 440     const DeclContext *original_decl_context = dyn_cast<DeclContext>(original_decl);
 441
 442     if (!original_decl_context)
 443         return ELR_Failure;
 444
 445     for (TagDecl::decl_iterator iter = original_decl_context->decls_begin();
 446          iter != original_decl_context->decls_end();
 447          ++iter)
 448     {
 449         Decl *decl = *iter;
 450
 451         if (!predicate || predicate(decl->getKind()))
 452         {
 453             if (log)
 454             {
 455                 ASTDumper ast_dumper(decl);
 456                 if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl))
 457                     log->Printf("  FELD[%d] Adding [to %sDecl %s] lexical %sDecl %s", current_id, context_named_decl->getDeclKindName(), context_named_decl->getNameAsString().c_str(), decl->getDeclKindName(), ast_dumper.GetCString());
 458                 else
 459                     log->Printf("  FELD[%d] Adding lexical %sDecl %s", current_id, decl->getDeclKindName(), ast_dumper.GetCString());
 460             }
 461
 462             Decl *copied_decl = m_ast_importer->CopyDecl(m_ast_context, original_ctx, decl);
 463
 464             if (!copied_decl)
 465                 continue;
 466
 467             if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl))
 468             {
 469                 QualType copied_field_type = copied_field->getType();
 470
 471                 m_ast_importer->RequireCompleteType(copied_field_type);
 472             }
 473
 474             decls.push_back(copied_decl);
 475
 476             DeclContext *decl_context_non_const = const_cast<DeclContext *>(decl_context);
 477
 478             if (copied_decl->getDeclContext() != decl_context)
 479             {
 480                 if (copied_decl->getDeclContext()->containsDecl(copied_decl))
 481                     copied_decl->getDeclContext()->removeDecl(copied_decl);
 482                 copied_decl->setDeclContext(decl_context_non_const);
 483             }
 484
 485             if (!decl_context_non_const->containsDecl(copied_decl))
 486                 decl_context_non_const->addDeclInternal(copied_decl);
 487         }
 488     }
 489
 490     return ELR_AlreadyLoaded;
 491 }
 492
 493 void
 494 ClangASTSource::FindExternalVisibleDecls (NameSearchContext &context)
 495 {
 496     assert (m_ast_context);
 497
 498     ClangASTMetrics::RegisterVisibleQuery();
 499
 500     const ConstString name(context.m_decl_name.getAsString().c_str());
 501
 502     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 503
 504     static unsigned int invocation_id = 0;
 505     unsigned int current_id = invocation_id++;
 506
 507     if (log)
 508     {
 509         if (!context.m_decl_context)
 510             log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on (ASTContext*)%p for '%s' in a NULL DeclContext", current_id, m_ast_context, name.GetCString());
 511         else if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context.m_decl_context))
 512             log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on (ASTContext*)%p for '%s' in '%s'", current_id, m_ast_context, name.GetCString(), context_named_decl->getNameAsString().c_str());
 513         else
 514             log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on (ASTContext*)%p for '%s' in a '%s'", current_id, m_ast_context, name.GetCString(), context.m_decl_context->getDeclKindName());
 515     }
 516
 517     context.m_namespace_map.reset(new ClangASTImporter::NamespaceMap);
 518
 519     if (const NamespaceDecl *namespace_context = dyn_cast<NamespaceDecl>(context.m_decl_context))
 520     {
 521         ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer->GetNamespaceMap(namespace_context);
 522
 523         if (log && log->GetVerbose())
 524             log->Printf("  CAS::FEVD[%u] Inspecting namespace map %p (%d entries)",
 525                         current_id,
 526                         namespace_map.get(),
 527                         (int)namespace_map->size());
 528
 529         if (!namespace_map)
 530             return;
 531
 532         for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), e = namespace_map->end();
 533              i != e;
 534              ++i)
 535         {
 536             if (log)
 537                 log->Printf("  CAS::FEVD[%u] Searching namespace %s in module %s",
 538                             current_id,
 539                             i->second.GetNamespaceDecl()->getNameAsString().c_str(),
 540                             i->first->GetFileSpec().GetFilename().GetCString());
 541
 542             FindExternalVisibleDecls(context,
 543                                      i->first,
 544                                      i->second,
 545                                      current_id);
 546         }
 547     }
 548     else if (isa<ObjCInterfaceDecl>(context.m_decl_context))
 549     {
 550         FindObjCPropertyAndIvarDecls(context);
 551     }
 552     else if (!isa<TranslationUnitDecl>(context.m_decl_context))
 553     {
 554         // we shouldn't be getting FindExternalVisibleDecls calls for these
 555         return;
 556     }
 557     else
 558     {
 559         ClangNamespaceDecl namespace_decl;
 560
 561         if (log)
 562             log->Printf("  CAS::FEVD[%u] Searching the root namespace", current_id);
 563
 564         FindExternalVisibleDecls(context,
 565                                  lldb::ModuleSP(),
 566                                  namespace_decl,
 567                                  current_id);
 568     }
 569
 570     if (!context.m_namespace_map->empty())
 571     {
 572         if (log && log->GetVerbose())
 573             log->Printf("  CAS::FEVD[%u] Registering namespace map %p (%d entries)",
 574                         current_id,
 575                         context.m_namespace_map.get(),
 576                         (int)context.m_namespace_map->size());
 577
 578         NamespaceDecl *clang_namespace_decl = AddNamespace(context, context.m_namespace_map);
 579
 580         if (clang_namespace_decl)
 581             clang_namespace_decl->setHasExternalVisibleStorage();
 582     }
 583 }
 584
 585 void
 586 ClangASTSource::FindExternalVisibleDecls (NameSearchContext &context,
 587                                           lldb::ModuleSP module_sp,
 588                                           ClangNamespaceDecl &namespace_decl,
 589                                           unsigned int current_id)
 590 {
 591     assert (m_ast_context);
 592
 593     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 594
 595     SymbolContextList sc_list;
 596
 597     const ConstString name(context.m_decl_name.getAsString().c_str());
 598
 599     const char *name_unique_cstr = name.GetCString();
 600
 601     static ConstString id_name("id");
 602     static ConstString Class_name("Class");
 603
 604     if (name == id_name || name == Class_name)
 605         return;
 606
 607     if (name_unique_cstr == NULL)
 608         return;
 609
 610     // The ClangASTSource is not responsible for finding $-names.
 611     if (name_unique_cstr[0] == '$')
 612         return;
 613
 614     if (module_sp && namespace_decl)
 615     {
 616         ClangNamespaceDecl found_namespace_decl;
 617
 618         SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
 619
 620         if (symbol_vendor)
 621         {
 622             SymbolContext null_sc;
 623
 624             found_namespace_decl = symbol_vendor->FindNamespace(null_sc, name, &namespace_decl);
 625
 626             if (found_namespace_decl)
 627             {
 628                 context.m_namespace_map->push_back(std::pair<lldb::ModuleSP, ClangNamespaceDecl>(module_sp, found_namespace_decl));
 629
 630                 if (log)
 631                     log->Printf("  CAS::FEVD[%u] Found namespace %s in module %s",
 632                                 current_id,
 633                                 name.GetCString(),
 634                                 module_sp->GetFileSpec().GetFilename().GetCString());
 635             }
 636         }
 637     }
 638     else
 639     {
 640         const ModuleList &target_images = m_target->GetImages();
 641         Mutex::Locker modules_locker (target_images.GetMutex());
 642
 643         for (size_t i = 0, e = target_images.GetSize(); i < e; ++i)
 644         {
 645             lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i);
 646
 647             if (!image)
 648                 continue;
 649
 650             ClangNamespaceDecl found_namespace_decl;
 651
 652             SymbolVendor *symbol_vendor = image->GetSymbolVendor();
 653
 654             if (!symbol_vendor)
 655                 continue;
 656
 657             SymbolContext null_sc;
 658
 659             found_namespace_decl = symbol_vendor->FindNamespace(null_sc, name, &namespace_decl);
 660
 661             if (found_namespace_decl)
 662             {
 663                 context.m_namespace_map->push_back(std::pair<lldb::ModuleSP, ClangNamespaceDecl>(image, found_namespace_decl));
 664
 665                 if (log)
 666                     log->Printf("  CAS::FEVD[%u] Found namespace %s in module %s",
 667                                 current_id,
 668                                 name.GetCString(),
 669                                 image->GetFileSpec().GetFilename().GetCString());
 670             }
 671         }
 672     }
 673
 674     do
 675     {
 676         TypeList types;
 677         SymbolContext null_sc;
 678         const bool exact_match = false;
 679
 680         if (module_sp && namespace_decl)
 681             module_sp->FindTypesInNamespace(null_sc, name, &namespace_decl, 1, types);
 682         else
 683             m_target->GetImages().FindTypes(null_sc, name, exact_match, 1, types);
 684
 685         if (types.GetSize())
 686         {
 687             lldb::TypeSP type_sp = types.GetTypeAtIndex(0);
 688
 689             if (log)
 690             {
 691                 const char *name_string = type_sp->GetName().GetCString();
 692
 693                 log->Printf("  CAS::FEVD[%u] Matching type found for \"%s\": %s",
 694                             current_id,
 695                             name.GetCString(),
 696                             (name_string ? name_string : "<anonymous>"));
 697             }
 698
 699             ClangASTType full_type = type_sp->GetClangFullType();
 700
 701             ClangASTType copied_clang_type (GuardedCopyType(full_type));
 702
 703             if (!copied_clang_type)
 704             {
 705                 if (log)
 706                     log->Printf("  CAS::FEVD[%u] - Couldn't export a type",
 707                                 current_id);
 708
 709                 break;
 710             }
 711
 712             context.AddTypeDecl(copied_clang_type);
 713         }
 714         else
 715         {
 716             do
 717             {
 718                 // Couldn't find any types elsewhere.  Try the Objective-C runtime if one exists.
 719
 720                 lldb::ProcessSP process(m_target->GetProcessSP());
 721
 722                 if (!process)
 723                     break;
 724
 725                 ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
 726
 727                 if (!language_runtime)
 728                     break;
 729
 730                 TypeVendor *type_vendor = language_runtime->GetTypeVendor();
 731
 732                 if (!type_vendor)
 733                     break;
 734
 735                 bool append = false;
 736                 uint32_t max_matches = 1;
 737                 std::vector <ClangASTType> types;
 738
 739                 if (!type_vendor->FindTypes(name,
 740                                             append,
 741                                             max_matches,
 742                                             types))
 743                     break;
 744
 745                 if (log)
 746                 {
 747                     log->Printf("  CAS::FEVD[%u] Matching type found for \"%s\" in the runtime",
 748                                 current_id,
 749                                 name.GetCString());
 750                 }
 751
 752                 ClangASTType copied_clang_type (GuardedCopyType(types[0]));
 753
 754                 if (!copied_clang_type)
 755                 {
 756                     if (log)
 757                         log->Printf("  CAS::FEVD[%u] - Couldn't export a type from the runtime",
 758                                     current_id);
 759
 760                     break;
 761                 }
 762
 763                 context.AddTypeDecl(copied_clang_type);
 764             }
 765             while(0);
 766         }
 767
 768     } while(0);
 769 }
 770
 771 template <class D> class TaggedASTDecl {
 772 public:
 773     TaggedASTDecl() : decl(NULL) { }
 774     TaggedASTDecl(D *_decl) : decl(_decl) { }
 775     bool IsValid() const { return (decl != NULL); }
 776     bool IsInvalid() const { return !IsValid(); }
 777     D *operator->() const { return decl; }
 778     D *decl;
 779 };
 780
 781 template <class D2, template <class D> class TD, class D1>
 782 TD<D2>
 783 DynCast(TD<D1> source)
 784 {
 785     return TD<D2> (dyn_cast<D2>(source.decl));
 786 }
 787
 788 template <class D = Decl> class DeclFromParser;
 789 template <class D = Decl> class DeclFromUser;
 790
 791 template <class D> class DeclFromParser : public TaggedASTDecl<D> {
 792 public:
 793     DeclFromParser() : TaggedASTDecl<D>() { }
 794     DeclFromParser(D *_decl) : TaggedASTDecl<D>(_decl) { }
 795
 796     DeclFromUser<D> GetOrigin(ClangASTImporter *importer);
 797 };
 798
 799 template <class D> class DeclFromUser : public TaggedASTDecl<D> {
 800 public:
 801     DeclFromUser() : TaggedASTDecl<D>() { }
 802     DeclFromUser(D *_decl) : TaggedASTDecl<D>(_decl) { }
 803
 804     DeclFromParser<D> Import(ClangASTImporter *importer, ASTContext &dest_ctx);
 805 };
 806
 807 template <class D>
 808 DeclFromUser<D>
 809 DeclFromParser<D>::GetOrigin(ClangASTImporter *importer)
 810 {
 811     DeclFromUser <> origin_decl;
 812     importer->ResolveDeclOrigin(this->decl, &origin_decl.decl, NULL);
 813     if (origin_decl.IsInvalid())
 814         return DeclFromUser<D>();
 815     return DeclFromUser<D>(dyn_cast<D>(origin_decl.decl));
 816 }
 817
 818 template <class D>
 819 DeclFromParser<D>
 820 DeclFromUser<D>::Import(ClangASTImporter *importer, ASTContext &dest_ctx)
 821 {
 822     DeclFromParser <> parser_generic_decl(importer->CopyDecl(&dest_ctx, &this->decl->getASTContext(), this->decl));
 823     if (parser_generic_decl.IsInvalid())
 824         return DeclFromParser<D>();
 825     return DeclFromParser<D>(dyn_cast<D>(parser_generic_decl.decl));
 826 }
 827
 828 static bool
 829 FindObjCMethodDeclsWithOrigin (unsigned int current_id,
 830                                NameSearchContext &context,
 831                                ObjCInterfaceDecl *original_interface_decl,
 832                                clang::ASTContext *ast_context,
 833                                ClangASTImporter *ast_importer,
 834                                const char *log_info)
 835 {
 836     const DeclarationName &decl_name(context.m_decl_name);
 837     clang::ASTContext *original_ctx = &original_interface_decl->getASTContext();
 838
 839     Selector original_selector;
 840
 841     if (decl_name.isObjCZeroArgSelector())
 842     {
 843         IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString());
 844         original_selector = original_ctx->Selectors.getSelector(0, &ident);
 845     }
 846     else if (decl_name.isObjCOneArgSelector())
 847     {
 848         const std::string &decl_name_string = decl_name.getAsString();
 849         std::string decl_name_string_without_colon(decl_name_string.c_str(), decl_name_string.length() - 1);
 850         IdentifierInfo *ident = &original_ctx->Idents.get(decl_name_string_without_colon.c_str());
 851         original_selector = original_ctx->Selectors.getSelector(1, &ident);
 852     }
 853     else
 854     {
 855         SmallVector<IdentifierInfo *, 4> idents;
 856
 857         clang::Selector sel = decl_name.getObjCSelector();
 858
 859         unsigned num_args = sel.getNumArgs();
 860
 861         for (unsigned i = 0;
 862              i != num_args;
 863              ++i)
 864         {
 865             idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i)));
 866         }
 867
 868         original_selector = original_ctx->Selectors.getSelector(num_args, idents.data());
 869     }
 870
 871     DeclarationName original_decl_name(original_selector);
 872
 873     ObjCInterfaceDecl::lookup_result result = original_interface_decl->lookup(original_decl_name);
 874
 875     if (result.empty())
 876         return false;
 877
 878     if (!result[0])
 879         return false;
 880
 881     ObjCMethodDecl *result_method = dyn_cast<ObjCMethodDecl>(result[0]);
 882
 883     if (!result_method)
 884         return false;
 885
 886     Decl *copied_decl = ast_importer->CopyDecl(ast_context, &result_method->getASTContext(), result_method);
 887
 888     if (!copied_decl)
 889         return false;
 890
 891     ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl);
 892
 893     if (!copied_method_decl)
 894         return false;
 895
 896     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 897
 898     if (log)
 899     {
 900         ASTDumper dumper((Decl*)copied_method_decl);
 901         log->Printf("  CAS::FOMD[%d] found (%s) %s", current_id, log_info, dumper.GetCString());
 902     }
 903
 904     context.AddNamedDecl(copied_method_decl);
 905
 906     return true;
 907 }
 908
 909 void
 910 ClangASTSource::FindObjCMethodDecls (NameSearchContext &context)
 911 {
 912     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 913
 914     static unsigned int invocation_id = 0;
 915     unsigned int current_id = invocation_id++;
 916
 917     const DeclarationName &decl_name(context.m_decl_name);
 918     const DeclContext *decl_ctx(context.m_decl_context);
 919
 920     const ObjCInterfaceDecl *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl_ctx);
 921
 922     if (!interface_decl)
 923         return;
 924
 925     do
 926     {
 927         Decl *original_decl = NULL;
 928         ASTContext *original_ctx = NULL;
 929
 930         m_ast_importer->ResolveDeclOrigin(interface_decl, &original_decl, &original_ctx);
 931
 932         if (!original_decl)
 933             break;
 934
 935         ObjCInterfaceDecl *original_interface_decl = dyn_cast<ObjCInterfaceDecl>(original_decl);
 936
 937         if (FindObjCMethodDeclsWithOrigin(current_id,
 938                                           context,
 939                                           original_interface_decl,
 940                                           m_ast_context,
 941                                           m_ast_importer,
 942                                           "at origin"))
 943             return; // found it, no need to look any further
 944     } while (0);
 945
 946     StreamString ss;
 947
 948     if (decl_name.isObjCZeroArgSelector())
 949     {
 950         ss.Printf("%s", decl_name.getAsString().c_str());
 951     }
 952     else if (decl_name.isObjCOneArgSelector())
 953     {
 954         ss.Printf("%s", decl_name.getAsString().c_str());
 955     }
 956     else
 957     {
 958         clang::Selector sel = decl_name.getObjCSelector();
 959
 960         for (unsigned i = 0, e = sel.getNumArgs();
 961              i != e;
 962              ++i)
 963         {
 964             llvm::StringRef r = sel.getNameForSlot(i);
 965             ss.Printf("%s:", r.str().c_str());
 966         }
 967     }
 968     ss.Flush();
 969
 970     ConstString selector_name(ss.GetData());
 971
 972     if (log)
 973         log->Printf("ClangASTSource::FindObjCMethodDecls[%d] on (ASTContext*)%p for selector [%s %s]",
 974                     current_id,
 975                     m_ast_context,
 976                     interface_decl->getNameAsString().c_str(),
 977                     selector_name.AsCString());
 978     SymbolContextList sc_list;
 979
 980     const bool include_symbols = false;
 981     const bool include_inlines = false;
 982     const bool append = false;
 983
 984     std::string interface_name = interface_decl->getNameAsString();
 985
 986     do
 987     {
 988         StreamString ms;
 989         ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString());
 990         ms.Flush();
 991         ConstString instance_method_name(ms.GetData());
 992
 993         m_target->GetImages().FindFunctions(instance_method_name, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, append, sc_list);
 994
 995         if (sc_list.GetSize())
 996             break;
 997
 998         ms.Clear();
 999         ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString());
1000         ms.Flush();
1001         ConstString class_method_name(ms.GetData());
1002
1003         m_target->GetImages().FindFunctions(class_method_name, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, append, sc_list);
1004
1005         if (sc_list.GetSize())
1006             break;
1007
1008         // Fall back and check for methods in categories.  If we find methods this way, we need to check that they're actually in
1009         // categories on the desired class.
1010
1011         SymbolContextList candidate_sc_list;
1012
1013         m_target->GetImages().FindFunctions(selector_name, lldb::eFunctionNameTypeSelector, include_symbols, include_inlines, append, candidate_sc_list);
1014
1015         for (uint32_t ci = 0, ce = candidate_sc_list.GetSize();
1016              ci != ce;
1017              ++ci)
1018         {
1019             SymbolContext candidate_sc;
1020
1021             if (!candidate_sc_list.GetContextAtIndex(ci, candidate_sc))
1022                 continue;
1023
1024             if (!candidate_sc.function)
1025                 continue;
1026
1027             const char *candidate_name = candidate_sc.function->GetName().AsCString();
1028
1029             const char *cursor = candidate_name;
1030
1031             if (*cursor != '+' && *cursor != '-')
1032                 continue;
1033
1034             ++cursor;
1035
1036             if (*cursor != '[')
1037                 continue;
1038
1039             ++cursor;
1040
1041             size_t interface_len = interface_name.length();
1042
1043             if (strncmp(cursor, interface_name.c_str(), interface_len))
1044                 continue;
1045
1046             cursor += interface_len;
1047
1048             if (*cursor == ' ' || *cursor == '(')
1049                 sc_list.Append(candidate_sc);
1050         }
1051     }
1052     while (0);
1053
1054     if (sc_list.GetSize())
1055     {
1056         // We found a good function symbol.  Use that.
1057
1058         for (uint32_t i = 0, e = sc_list.GetSize();
1059              i != e;
1060              ++i)
1061         {
1062             SymbolContext sc;
1063
1064             if (!sc_list.GetContextAtIndex(i, sc))
1065                 continue;
1066
1067             if (!sc.function)
1068                 continue;
1069
1070             DeclContext *function_ctx = sc.function->GetClangDeclContext();
1071
1072             if (!function_ctx)
1073                 continue;
1074
1075             ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(function_ctx);
1076
1077             if (!method_decl)
1078                 continue;
1079
1080             ObjCInterfaceDecl *found_interface_decl = method_decl->getClassInterface();
1081
1082             if (!found_interface_decl)
1083                 continue;
1084
1085             if (found_interface_decl->getName() == interface_decl->getName())
1086             {
1087                 Decl *copied_decl = m_ast_importer->CopyDecl(m_ast_context, &method_decl->getASTContext(), method_decl);
1088
1089                 if (!copied_decl)
1090                     continue;
1091
1092                 ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl);
1093
1094                 if (!copied_method_decl)
1095                     continue;
1096
1097                 if (log)
1098                 {
1099                     ASTDumper dumper((Decl*)copied_method_decl);
1100                     log->Printf("  CAS::FOMD[%d] found (in symbols) %s", current_id, dumper.GetCString());
1101                 }
1102
1103                 context.AddNamedDecl(copied_method_decl);
1104             }
1105         }
1106
1107         return;
1108     }
1109
1110     // Try the debug information.
1111
1112     do
1113     {
1114         ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(const_cast<ObjCInterfaceDecl*>(interface_decl));
1115
1116         if (!complete_interface_decl)
1117             break;
1118
1119         // We found the complete interface.  The runtime never needs to be queried in this scenario.
1120
1121         DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(complete_interface_decl);
1122
1123         if (complete_interface_decl == interface_decl)
1124             break; // already checked this one
1125
1126         if (log)
1127             log->Printf("CAS::FOPD[%d] trying origin (ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
1128                         current_id,
1129                         complete_interface_decl,
1130                         &complete_iface_decl->getASTContext());
1131
1132         FindObjCMethodDeclsWithOrigin(current_id,
1133                                       context,
1134                                       complete_interface_decl,
1135                                       m_ast_context,
1136                                       m_ast_importer,
1137                                       "in debug info");
1138
1139         return;
1140     }
1141     while (0);
1142
1143     do
1144     {
1145         // Check the runtime only if the debug information didn't have a complete interface.
1146
1147         lldb::ProcessSP process(m_target->GetProcessSP());
1148
1149         if (!process)
1150             break;
1151
1152         ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
1153
1154         if (!language_runtime)
1155             break;
1156
1157         TypeVendor *type_vendor = language_runtime->GetTypeVendor();
1158
1159         if (!type_vendor)
1160             break;
1161
1162         ConstString interface_name(interface_decl->getNameAsString().c_str());
1163         bool append = false;
1164         uint32_t max_matches = 1;
1165         std::vector <ClangASTType> types;
1166
1167         if (!type_vendor->FindTypes(interface_name,
1168                                     append,
1169                                     max_matches,
1170                                     types))
1171             break;
1172
1173         const clang::Type *runtime_clang_type = QualType::getFromOpaquePtr(types[0].GetOpaqueQualType()).getTypePtr();
1174
1175         const ObjCInterfaceType *runtime_interface_type = dyn_cast<ObjCInterfaceType>(runtime_clang_type);
1176
1177         if (!runtime_interface_type)
1178             break;
1179
1180         ObjCInterfaceDecl *runtime_interface_decl = runtime_interface_type->getDecl();
1181
1182         FindObjCMethodDeclsWithOrigin(current_id,
1183                                       context,
1184                                       runtime_interface_decl,
1185                                       m_ast_context,
1186                                       m_ast_importer,
1187                                       "in runtime");
1188     }
1189     while(0);
1190 }
1191
1192 static bool
1193 FindObjCPropertyAndIvarDeclsWithOrigin (unsigned int current_id,
1194                                         NameSearchContext &context,
1195                                         clang::ASTContext &ast_context,
1196                                         ClangASTImporter *ast_importer,
1197                                         DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl)
1198 {
1199     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1200
1201     if (origin_iface_decl.IsInvalid())
1202         return false;
1203
1204     std::string name_str = context.m_decl_name.getAsString();
1205     StringRef name(name_str.c_str());
1206     IdentifierInfo &name_identifier(origin_iface_decl->getASTContext().Idents.get(name));
1207
1208     DeclFromUser<ObjCPropertyDecl> origin_property_decl(origin_iface_decl->FindPropertyDeclaration(&name_identifier));
1209
1210     bool found = false;
1211
1212     if (origin_property_decl.IsValid())
1213     {
1214         DeclFromParser<ObjCPropertyDecl> parser_property_decl(origin_property_decl.Import(ast_importer, ast_context));
1215         if (parser_property_decl.IsValid())
1216         {
1217             if (log)
1218             {
1219                 ASTDumper dumper((Decl*)parser_property_decl.decl);
1220                 log->Printf("  CAS::FOPD[%d] found %s", current_id, dumper.GetCString());
1221             }
1222
1223             context.AddNamedDecl(parser_property_decl.decl);
1224             found = true;
1225         }
1226     }
1227
1228     DeclFromUser<ObjCIvarDecl> origin_ivar_decl(origin_iface_decl->getIvarDecl(&name_identifier));
1229
1230     if (origin_ivar_decl.IsValid())
1231     {
1232         DeclFromParser<ObjCIvarDecl> parser_ivar_decl(origin_ivar_decl.Import(ast_importer, ast_context));
1233         if (parser_ivar_decl.IsValid())
1234         {
1235             if (log)
1236             {
1237                 ASTDumper dumper((Decl*)parser_ivar_decl.decl);
1238                 log->Printf("  CAS::FOPD[%d] found %s", current_id, dumper.GetCString());
1239             }
1240
1241             context.AddNamedDecl(parser_ivar_decl.decl);
1242             found = true;
1243         }
1244     }
1245
1246     return found;
1247 }
1248
1249 void
1250 ClangASTSource::FindObjCPropertyAndIvarDecls (NameSearchContext &context)
1251 {
1252     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1253
1254     static unsigned int invocation_id = 0;
1255     unsigned int current_id = invocation_id++;
1256
1257     DeclFromParser<const ObjCInterfaceDecl> parser_iface_decl(cast<ObjCInterfaceDecl>(context.m_decl_context));
1258     DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl(parser_iface_decl.GetOrigin(m_ast_importer));
1259
1260     ConstString class_name(parser_iface_decl->getNameAsString().c_str());
1261
1262     if (log)
1263         log->Printf("ClangASTSource::FindObjCPropertyAndIvarDecls[%d] on (ASTContext*)%p for '%s.%s'",
1264                     current_id,
1265                     m_ast_context,
1266                     parser_iface_decl->getNameAsString().c_str(),
1267                     context.m_decl_name.getAsString().c_str());
1268
1269     if (FindObjCPropertyAndIvarDeclsWithOrigin(current_id,
1270                                                context,
1271                                                *m_ast_context,
1272                                                m_ast_importer,
1273                                                origin_iface_decl))
1274         return;
1275
1276     if (log)
1277         log->Printf("CAS::FOPD[%d] couldn't find the property on origin (ObjCInterfaceDecl*)%p/(ASTContext*)%p, searching elsewhere...",
1278                     current_id,
1279                     origin_iface_decl.decl,
1280                     &origin_iface_decl->getASTContext());
1281
1282     SymbolContext null_sc;
1283     TypeList type_list;
1284
1285     do
1286     {
1287         ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(const_cast<ObjCInterfaceDecl*>(parser_iface_decl.decl));
1288
1289         if (!complete_interface_decl)
1290             break;
1291
1292         // We found the complete interface.  The runtime never needs to be queried in this scenario.
1293
1294         DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(complete_interface_decl);
1295
1296         if (complete_iface_decl.decl == origin_iface_decl.decl)
1297             break; // already checked this one
1298
1299         if (log)
1300             log->Printf("CAS::FOPD[%d] trying origin (ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
1301                         current_id,
1302                         complete_iface_decl.decl,
1303                         &complete_iface_decl->getASTContext());
1304
1305         FindObjCPropertyAndIvarDeclsWithOrigin(current_id,
1306                                                context,
1307                                                *m_ast_context,
1308                                                m_ast_importer,
1309                                                complete_iface_decl);
1310
1311         return;
1312     }
1313     while(0);
1314
1315     do
1316     {
1317         // Check the runtime only if the debug information didn't have a complete interface.
1318
1319         lldb::ProcessSP process(m_target->GetProcessSP());
1320
1321         if (!process)
1322             return;
1323
1324         ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
1325
1326         if (!language_runtime)
1327             return;
1328
1329         TypeVendor *type_vendor = language_runtime->GetTypeVendor();
1330
1331         if (!type_vendor)
1332             break;
1333
1334         bool append = false;
1335         uint32_t max_matches = 1;
1336         std::vector <ClangASTType> types;
1337
1338         if (!type_vendor->FindTypes(class_name,
1339                                     append,
1340                                     max_matches,
1341                                     types))
1342             break;
1343
1344         const clang::Type *runtime_clang_type = QualType::getFromOpaquePtr(types[0].GetOpaqueQualType()).getTypePtr();
1345
1346         const ObjCInterfaceType *runtime_interface_type = dyn_cast<ObjCInterfaceType>(runtime_clang_type);
1347
1348         if (!runtime_interface_type)
1349             break;
1350
1351         DeclFromUser<const ObjCInterfaceDecl> runtime_iface_decl(runtime_interface_type->getDecl());
1352
1353         if (log)
1354             log->Printf("CAS::FOPD[%d] trying runtime (ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
1355                         current_id,
1356                         runtime_iface_decl.decl,
1357                         &runtime_iface_decl->getASTContext());
1358
1359         if (FindObjCPropertyAndIvarDeclsWithOrigin(current_id,
1360                                                    context,
1361                                                    *m_ast_context,
1362                                                    m_ast_importer,
1363                                                    runtime_iface_decl))
1364             return;
1365     }
1366     while(0);
1367 }
1368
1369 typedef llvm::DenseMap <const FieldDecl *, uint64_t> FieldOffsetMap;
1370 typedef llvm::DenseMap <const CXXRecordDecl *, CharUnits> BaseOffsetMap;
1371
1372 template <class D, class O>
1373 static bool
1374 ImportOffsetMap (llvm::DenseMap <const D*, O> &destination_map,
1375                  llvm::DenseMap <const D*, O> &source_map,
1376                  ClangASTImporter *importer,
1377                  ASTContext &dest_ctx)
1378 {
1379     typedef llvm::DenseMap <const D*, O> MapType;
1380
1381     for (typename MapType::iterator fi = source_map.begin(), fe = source_map.end();
1382          fi != fe;
1383          ++fi)
1384     {
1385         DeclFromUser <D> user_decl(const_cast<D*>(fi->first));
1386         DeclFromParser <D> parser_decl(user_decl.Import(importer, dest_ctx));
1387         if (parser_decl.IsInvalid())
1388             return false;
1389         destination_map.insert(std::pair<const D *, O>(parser_decl.decl, fi->second));
1390     }
1391
1392     return true;
1393 }
1394
1395 template <bool IsVirtual> bool ExtractBaseOffsets (const ASTRecordLayout &record_layout,
1396                                                    DeclFromUser<const CXXRecordDecl> &record,
1397                                                    BaseOffsetMap &base_offsets)
1398 {
1399     for (CXXRecordDecl::base_class_const_iterator
1400             bi = (IsVirtual ? record->vbases_begin() : record->bases_begin()),
1401             be = (IsVirtual ? record->vbases_end() : record->bases_end());
1402          bi != be;
1403          ++bi)
1404     {
1405         if (!IsVirtual && bi->isVirtual())
1406             continue;
1407
1408         const clang::Type *origin_base_type = bi->getType().getTypePtr();
1409         const clang::RecordType *origin_base_record_type = origin_base_type->getAs<RecordType>();
1410
1411         if (!origin_base_record_type)
1412             return false;
1413
1414         DeclFromUser <RecordDecl> origin_base_record(origin_base_record_type->getDecl());
1415
1416         if (origin_base_record.IsInvalid())
1417             return false;
1418
1419         DeclFromUser <CXXRecordDecl> origin_base_cxx_record(DynCast<CXXRecordDecl>(origin_base_record));
1420
1421         if (origin_base_cxx_record.IsInvalid())
1422             return false;
1423
1424         CharUnits base_offset;
1425
1426         if (IsVirtual)
1427             base_offset = record_layout.getVBaseClassOffset(origin_base_cxx_record.decl);
1428         else
1429             base_offset = record_layout.getBaseClassOffset(origin_base_cxx_record.decl);
1430
1431         base_offsets.insert(std::pair<const CXXRecordDecl *, CharUnits>(origin_base_cxx_record.decl, base_offset));
1432     }
1433
1434     return true;
1435 }
1436
1437 bool
1438 ClangASTSource::layoutRecordType(const RecordDecl *record,
1439                                  uint64_t &size,
1440                                  uint64_t &alignment,
1441                                  FieldOffsetMap &field_offsets,
1442                                  BaseOffsetMap &base_offsets,
1443                                  BaseOffsetMap &virtual_base_offsets)
1444 {
1445     ClangASTMetrics::RegisterRecordLayout();
1446
1447     static unsigned int invocation_id = 0;
1448     unsigned int current_id = invocation_id++;
1449
1450     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1451
1452     if (log)
1453     {
1454         log->Printf("LayoutRecordType[%u] on (ASTContext*)%p for (RecordDecl*)%p [name = '%s']",
1455                     current_id,
1456                     m_ast_context,
1457                     record,
1458                     record->getNameAsString().c_str());
1459     }
1460
1461
1462     DeclFromParser <const RecordDecl> parser_record(record);
1463     DeclFromUser <const RecordDecl> origin_record(parser_record.GetOrigin(m_ast_importer));
1464
1465     if (origin_record.IsInvalid())
1466         return false;
1467
1468     FieldOffsetMap origin_field_offsets;
1469     BaseOffsetMap origin_base_offsets;
1470     BaseOffsetMap origin_virtual_base_offsets;
1471
1472     ClangASTContext::GetCompleteDecl(&origin_record->getASTContext(), const_cast<RecordDecl*>(origin_record.decl));
1473
1474     if (!origin_record.decl->getDefinition())
1475         return false;
1476
1477     const ASTRecordLayout &record_layout(origin_record->getASTContext().getASTRecordLayout(origin_record.decl));
1478
1479     int field_idx = 0, field_count = record_layout.getFieldCount();
1480
1481     for (RecordDecl::field_iterator fi = origin_record->field_begin(), fe = origin_record->field_end();
1482          fi != fe;
1483          ++fi)
1484     {
1485         if (field_idx >= field_count)
1486             return false; // Layout didn't go well.  Bail out.
1487
1488         uint64_t field_offset = record_layout.getFieldOffset(field_idx);
1489
1490         origin_field_offsets.insert(std::pair<const FieldDecl *, uint64_t>(*fi, field_offset));
1491
1492         field_idx++;
1493     }
1494
1495     ASTContext &parser_ast_context(record->getASTContext());
1496
1497     DeclFromUser <const CXXRecordDecl> origin_cxx_record(DynCast<const CXXRecordDecl>(origin_record));
1498
1499     if (origin_cxx_record.IsValid())
1500     {
1501         if (!ExtractBaseOffsets<false>(record_layout, origin_cxx_record, origin_base_offsets) ||
1502             !ExtractBaseOffsets<true>(record_layout, origin_cxx_record, origin_virtual_base_offsets))
1503             return false;
1504     }
1505
1506     if (!ImportOffsetMap(field_offsets, origin_field_offsets, m_ast_importer, parser_ast_context) ||
1507         !ImportOffsetMap(base_offsets, origin_base_offsets, m_ast_importer, parser_ast_context) ||
1508         !ImportOffsetMap(virtual_base_offsets, origin_virtual_base_offsets, m_ast_importer, parser_ast_context))
1509         return false;
1510
1511     size = record_layout.getSize().getQuantity() * m_ast_context->getCharWidth();
1512     alignment = record_layout.getAlignment().getQuantity() * m_ast_context->getCharWidth();
1513
1514     if (log)
1515     {
1516         log->Printf("LRT[%u] returned:", current_id);
1517         log->Printf("LRT[%u]   Original = (RecordDecl*)%p", current_id, origin_record.decl);
1518         log->Printf("LRT[%u]   Size = %" PRId64, current_id, size);
1519         log->Printf("LRT[%u]   Alignment = %" PRId64, current_id, alignment);
1520         log->Printf("LRT[%u]   Fields:", current_id);
1521         for (RecordDecl::field_iterator fi = record->field_begin(), fe = record->field_end();
1522              fi != fe;
1523              ++fi)
1524         {
1525             log->Printf("LRT[%u]     (FieldDecl*)%p, Name = '%s', Offset = %" PRId64 " bits",
1526                         current_id,
1527                         *fi,
1528                         fi->getNameAsString().c_str(),
1529                         field_offsets[*fi]);
1530         }
1531         DeclFromParser <const CXXRecordDecl> parser_cxx_record = DynCast<const CXXRecordDecl>(parser_record);
1532         if (parser_cxx_record.IsValid())
1533         {
1534             log->Printf("LRT[%u]   Bases:", current_id);
1535             for (CXXRecordDecl::base_class_const_iterator bi = parser_cxx_record->bases_begin(), be = parser_cxx_record->bases_end();
1536                  bi != be;
1537                  ++bi)
1538             {
1539                 bool is_virtual = bi->isVirtual();
1540
1541                 QualType base_type = bi->getType();
1542                 const RecordType *base_record_type = base_type->getAs<RecordType>();
1543                 DeclFromParser <RecordDecl> base_record(base_record_type->getDecl());
1544                 DeclFromParser <CXXRecordDecl> base_cxx_record = DynCast<CXXRecordDecl>(base_record);
1545
1546                 log->Printf("LRT[%u]     %s(CXXRecordDecl*)%p, Name = '%s', Offset = %" PRId64 " chars",
1547                             current_id,
1548                             (is_virtual ? "Virtual " : ""),
1549                             base_cxx_record.decl,
1550                             base_cxx_record.decl->getNameAsString().c_str(),
1551                             (is_virtual ? virtual_base_offsets[base_cxx_record.decl].getQuantity() :
1552                                           base_offsets[base_cxx_record.decl].getQuantity()));
1553             }
1554         }
1555         else
1556         {
1557             log->Printf("LRD[%u]   Not a CXXRecord, so no bases", current_id);
1558         }
1559     }
1560
1561     return true;
1562 }
1563
1564 void
1565 ClangASTSource::CompleteNamespaceMap (ClangASTImporter::NamespaceMapSP &namespace_map,
1566                                       const ConstString &name,
1567                                       ClangASTImporter::NamespaceMapSP &parent_map) const
1568 {
1569     static unsigned int invocation_id = 0;
1570     unsigned int current_id = invocation_id++;
1571
1572     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1573
1574     if (log)
1575     {
1576         if (parent_map && parent_map->size())
1577             log->Printf("CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for namespace %s in namespace %s",
1578                         current_id,
1579                         m_ast_context,
1580                         name.GetCString(),
1581                         parent_map->begin()->second.GetNamespaceDecl()->getDeclName().getAsString().c_str());
1582         else
1583             log->Printf("CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for namespace %s",
1584                         current_id,
1585                         m_ast_context,
1586                         name.GetCString());
1587     }
1588
1589
1590     if (parent_map)
1591     {
1592         for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(), e = parent_map->end();
1593              i != e;
1594              ++i)
1595         {
1596             ClangNamespaceDecl found_namespace_decl;
1597
1598             lldb::ModuleSP module_sp = i->first;
1599             ClangNamespaceDecl module_parent_namespace_decl = i->second;
1600
1601             SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
1602
1603             if (!symbol_vendor)
1604                 continue;
1605
1606             SymbolContext null_sc;
1607
1608             found_namespace_decl = symbol_vendor->FindNamespace(null_sc, name, &module_parent_namespace_decl);
1609
1610             if (!found_namespace_decl)
1611                 continue;
1612
1613             namespace_map->push_back(std::pair<lldb::ModuleSP, ClangNamespaceDecl>(module_sp, found_namespace_decl));
1614
1615             if (log)
1616                 log->Printf("  CMN[%u] Found namespace %s in module %s",
1617                             current_id,
1618                             name.GetCString(),
1619                             module_sp->GetFileSpec().GetFilename().GetCString());
1620         }
1621     }
1622     else
1623     {
1624         const ModuleList &target_images = m_target->GetImages();
1625         Mutex::Locker modules_locker(target_images.GetMutex());
1626
1627         ClangNamespaceDecl null_namespace_decl;
1628
1629         for (size_t i = 0, e = target_images.GetSize(); i < e; ++i)
1630         {
1631             lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i);
1632
1633             if (!image)
1634                 continue;
1635
1636             ClangNamespaceDecl found_namespace_decl;
1637
1638             SymbolVendor *symbol_vendor = image->GetSymbolVendor();
1639
1640             if (!symbol_vendor)
1641                 continue;
1642
1643             SymbolContext null_sc;
1644
1645             found_namespace_decl = symbol_vendor->FindNamespace(null_sc, name, &null_namespace_decl);
1646
1647             if (!found_namespace_decl)
1648                 continue;
1649
1650             namespace_map->push_back(std::pair<lldb::ModuleSP, ClangNamespaceDecl>(image, found_namespace_decl));
1651
1652             if (log)
1653                 log->Printf("  CMN[%u] Found namespace %s in module %s",
1654                             current_id,
1655                             name.GetCString(),
1656                             image->GetFileSpec().GetFilename().GetCString());
1657         }
1658     }
1659 }
1660
1661 NamespaceDecl *
1662 ClangASTSource::AddNamespace (NameSearchContext &context, ClangASTImporter::NamespaceMapSP &namespace_decls)
1663 {
1664     if (!namespace_decls)
1665         return NULL;
1666
1667     const ClangNamespaceDecl &namespace_decl = namespace_decls->begin()->second;
1668
1669     Decl *copied_decl = m_ast_importer->CopyDecl(m_ast_context, namespace_decl.GetASTContext(), namespace_decl.GetNamespaceDecl());
1670
1671     if (!copied_decl)
1672         return NULL;
1673
1674     NamespaceDecl *copied_namespace_decl = dyn_cast<NamespaceDecl>(copied_decl);
1675
1676     if (!copied_namespace_decl)
1677         return NULL;
1678
1679     context.m_decls.push_back(copied_namespace_decl);
1680
1681     m_ast_importer->RegisterNamespaceMap(copied_namespace_decl, namespace_decls);
1682
1683     return dyn_cast<NamespaceDecl>(copied_decl);
1684 }
1685
1686 ClangASTType
1687 ClangASTSource::GuardedCopyType (const ClangASTType &src_type)
1688 {
1689     ClangASTMetrics::RegisterLLDBImport();
1690
1691     SetImportInProgress(true);
1692
1693     QualType copied_qual_type = m_ast_importer->CopyType (m_ast_context, src_type.GetASTContext(), src_type.GetQualType());
1694
1695     SetImportInProgress(false);
1696
1697     if (copied_qual_type.getAsOpaquePtr() && copied_qual_type->getCanonicalTypeInternal().isNull())
1698         // this shouldn't happen, but we're hardening because the AST importer seems to be generating bad types
1699         // on occasion.
1700         return ClangASTType();
1701
1702     return ClangASTType(m_ast_context, copied_qual_type);
1703 }
1704
1705 clang::NamedDecl *
1706 NameSearchContext::AddVarDecl(const ClangASTType &type)
1707 {
1708     assert (type && "Type for variable must be valid!");
1709
1710     if (!type.IsValid())
1711         return NULL;
1712
1713     IdentifierInfo *ii = m_decl_name.getAsIdentifierInfo();
1714
1715     clang::ASTContext *ast = type.GetASTContext();
1716
1717     clang::NamedDecl *Decl = VarDecl::Create(*ast,
1718                                              const_cast<DeclContext*>(m_decl_context),
1719                                              SourceLocation(),
1720                                              SourceLocation(),
1721                                              ii,
1722                                              type.GetQualType(),
1723                                              0,
1724                                              SC_Static);
1725     m_decls.push_back(Decl);
1726
1727     return Decl;
1728 }
1729
1730 clang::NamedDecl *
1731 NameSearchContext::AddFunDecl (const ClangASTType &type)
1732 {
1733     assert (type && "Type for variable must be valid!");
1734
1735     if (!type.IsValid())
1736         return NULL;
1737
1738     if (m_function_types.count(type))
1739         return NULL;
1740
1741     m_function_types.insert(type);
1742
1743     QualType qual_type (type.GetQualType());
1744
1745     clang::ASTContext *ast = type.GetASTContext();
1746
1747     const bool isInlineSpecified = false;
1748     const bool hasWrittenPrototype = true;
1749     const bool isConstexprSpecified = false;
1750
1751     clang::FunctionDecl *func_decl = FunctionDecl::Create (*ast,
1752                                                            const_cast<DeclContext*>(m_decl_context),
1753                                                            SourceLocation(),
1754                                                            SourceLocation(),
1755                                                            m_decl_name.getAsIdentifierInfo(),
1756                                                            qual_type,
1757                                                            NULL,
1758                                                            SC_Static,
1759                                                            isInlineSpecified,
1760                                                            hasWrittenPrototype,
1761                                                            isConstexprSpecified);
1762
1763     // We have to do more than just synthesize the FunctionDecl.  We have to
1764     // synthesize ParmVarDecls for all of the FunctionDecl's arguments.  To do
1765     // this, we raid the function's FunctionProtoType for types.
1766
1767     const FunctionProtoType *func_proto_type = qual_type.getTypePtr()->getAs<FunctionProtoType>();
1768
1769     if (func_proto_type)
1770     {
1771         unsigned NumArgs = func_proto_type->getNumArgs();
1772         unsigned ArgIndex;
1773
1774         SmallVector<ParmVarDecl *, 5> parm_var_decls;
1775
1776         for (ArgIndex = 0; ArgIndex < NumArgs; ++ArgIndex)
1777         {
1778             QualType arg_qual_type (func_proto_type->getArgType(ArgIndex));
1779
1780             parm_var_decls.push_back(ParmVarDecl::Create (*ast,
1781                                                           const_cast<DeclContext*>(m_decl_context),
1782                                                           SourceLocation(),
1783                                                           SourceLocation(),
1784                                                           NULL,
1785                                                           arg_qual_type,
1786                                                           NULL,
1787                                                           SC_Static,
1788                                                           NULL));
1789         }
1790
1791         func_decl->setParams(ArrayRef<ParmVarDecl*>(parm_var_decls));
1792     }
1793     else
1794     {
1795         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1796
1797         if (log)
1798             log->Printf("Function type wasn't a FunctionProtoType");
1799     }
1800
1801     m_decls.push_back(func_decl);
1802
1803     return func_decl;
1804 }
1805
1806 clang::NamedDecl *
1807 NameSearchContext::AddGenericFunDecl()
1808 {
1809     FunctionProtoType::ExtProtoInfo proto_info;
1810
1811     proto_info.Variadic = true;
1812
1813     QualType generic_function_type(m_ast_source.m_ast_context->getFunctionType (m_ast_source.m_ast_context->UnknownAnyTy,    // result
1814                                                                                 ArrayRef<QualType>(),                                        // argument types
1815                                                                                 proto_info));
1816
1817     return AddFunDecl(ClangASTType (m_ast_source.m_ast_context, generic_function_type));
1818 }
1819
1820 clang::NamedDecl *
1821 NameSearchContext::AddTypeDecl(const ClangASTType &clang_type)
1822 {
1823     if (clang_type)
1824     {
1825         QualType qual_type = clang_type.GetQualType();
1826
1827         if (const TypedefType *typedef_type = llvm::dyn_cast<TypedefType>(qual_type))
1828         {
1829             TypedefNameDecl *typedef_name_decl = typedef_type->getDecl();
1830
1831             m_decls.push_back(typedef_name_decl);
1832
1833             return (NamedDecl*)typedef_name_decl;
1834         }
1835         else if (const TagType *tag_type = qual_type->getAs<TagType>())
1836         {
1837             TagDecl *tag_decl = tag_type->getDecl();
1838
1839             m_decls.push_back(tag_decl);
1840
1841             return tag_decl;
1842         }
1843         else if (const ObjCObjectType *objc_object_type = qual_type->getAs<ObjCObjectType>())
1844         {
1845             ObjCInterfaceDecl *interface_decl = objc_object_type->getInterface();
1846
1847             m_decls.push_back((NamedDecl*)interface_decl);
1848
1849             return (NamedDecl*)interface_decl;
1850         }
1851     }
1852     return NULL;
1853 }
1854
1855 void
1856 NameSearchContext::AddLookupResult (clang::DeclContextLookupConstResult result)
1857 {
1858     for (clang::NamedDecl *decl : result)
1859         m_decls.push_back (decl);
1860 }
1861
1862 void
1863 NameSearchContext::AddNamedDecl (clang::NamedDecl *decl)
1864 {
1865     m_decls.push_back (decl);
1866 }