LLDB  mainline
ClangASTSource.cpp
Go to the documentation of this file.
1 //===-- ClangASTSource.cpp ---------------------------------------*- C++-*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "ClangASTSource.h"
10 
11 #include "ASTDumper.h"
12 #include "ClangModulesDeclVendor.h"
13 
14 #include "lldb/Core/Module.h"
15 #include "lldb/Core/ModuleList.h"
17 #include "lldb/Symbol/ClangUtil.h"
19 #include "lldb/Symbol/Function.h"
20 #include "lldb/Symbol/SymbolFile.h"
24 #include "lldb/Target/Target.h"
25 #include "lldb/Utility/Log.h"
26 #include "clang/AST/ASTContext.h"
27 #include "clang/AST/RecordLayout.h"
28 
29 #include <memory>
30 #include <vector>
31 
32 using namespace clang;
33 using namespace lldb_private;
34 
35 // Scoped class that will remove an active lexical decl from the set when it
36 // goes out of scope.
37 namespace {
38 class ScopedLexicalDeclEraser {
39 public:
40  ScopedLexicalDeclEraser(std::set<const clang::Decl *> &decls,
41  const clang::Decl *decl)
42  : m_active_lexical_decls(decls), m_decl(decl) {}
43 
44  ~ScopedLexicalDeclEraser() { m_active_lexical_decls.erase(m_decl); }
45 
46 private:
47  std::set<const clang::Decl *> &m_active_lexical_decls;
48  const clang::Decl *m_decl;
49 };
50 }
51 
52 ClangASTSource::ClangASTSource(const lldb::TargetSP &target)
53  : m_import_in_progress(false), m_lookups_enabled(false), m_target(target),
54  m_ast_context(NULL), m_active_lexical_decls(), m_active_lookups() {
55  if (!target->GetUseModernTypeLookup()) {
56  m_ast_importer_sp = m_target->GetClangASTImporter();
57  }
58 }
59 
60 void ClangASTSource::InstallASTContext(clang::ASTContext &ast_context,
61  clang::FileManager &file_manager,
62  bool is_shared_context) {
63  m_ast_context = &ast_context;
64  m_file_manager = &file_manager;
65  if (m_target->GetUseModernTypeLookup()) {
66  // Configure the ExternalASTMerger. The merger needs to be able to import
67  // types from any source that we would do lookups in, which includes the
68  // persistent AST context as well as the modules and Objective-C runtime
69  // AST contexts.
70 
72  clang::ExternalASTMerger::ImporterTarget target = {ast_context,
73  file_manager};
74  std::vector<clang::ExternalASTMerger::ImporterSource> sources;
75  for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) {
76  if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>(
77  module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC))) {
78  lldbassert(module_ast_ctx->getASTContext());
79  lldbassert(module_ast_ctx->getFileManager());
80  sources.push_back({*module_ast_ctx->getASTContext(),
81  *module_ast_ctx->getFileManager(),
82  module_ast_ctx->GetOriginMap()
83  });
84  }
85  }
86 
87  do {
88  lldb::ProcessSP process(m_target->GetProcessSP());
89 
90  if (!process)
91  break;
92 
93  ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
94 
95  if (!language_runtime)
96  break;
97 
98  DeclVendor *runtime_decl_vendor = language_runtime->GetDeclVendor();
99 
100  if (!runtime_decl_vendor)
101  break;
102 
103  sources.push_back(runtime_decl_vendor->GetImporterSource());
104  } while (0);
105 
106  do {
107  DeclVendor *modules_decl_vendor =
108  m_target->GetClangModulesDeclVendor();
109 
110  if (!modules_decl_vendor)
111  break;
112 
113  sources.push_back(modules_decl_vendor->GetImporterSource());
114  } while (0);
115 
116  if (!is_shared_context) {
117  // Update the scratch AST context's merger to reflect any new sources we
118  // might have come across since the last time an expression was parsed.
119 
120  auto scratch_ast_context = static_cast<ClangASTContextForExpressions*>(
121  m_target->GetScratchClangASTContext());
122 
123  scratch_ast_context->GetMergerUnchecked().AddSources(sources);
124 
125  sources.push_back({*scratch_ast_context->getASTContext(),
126  *scratch_ast_context->getFileManager(),
127  scratch_ast_context->GetOriginMap()});
128  } while (0);
129 
130  m_merger_up =
131  llvm::make_unique<clang::ExternalASTMerger>(target, sources);
132  } else {
133  m_ast_importer_sp->InstallMapCompleter(&ast_context, *this);
134  }
135 }
136 
138  if (m_ast_importer_sp)
139  m_ast_importer_sp->ForgetDestination(m_ast_context);
140 
141  // We are in the process of destruction, don't create clang ast context on
142  // demand by passing false to
143  // Target::GetScratchClangASTContext(create_on_demand).
144  ClangASTContext *scratch_clang_ast_context =
145  m_target->GetScratchClangASTContext(false);
146 
147  if (!scratch_clang_ast_context)
148  return;
149 
150  clang::ASTContext *scratch_ast_context =
151  scratch_clang_ast_context->getASTContext();
152 
153  if (!scratch_ast_context)
154  return;
155 
156  if (m_ast_context != scratch_ast_context && m_ast_importer_sp)
157  m_ast_importer_sp->ForgetSource(scratch_ast_context, m_ast_context);
158 }
159 
160 void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) {
161  if (!m_ast_context)
162  return;
163 
164  m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage();
165  m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage();
166 }
167 
168 // The core lookup interface.
170  const DeclContext *decl_ctx, DeclarationName clang_decl_name) {
171  if (!m_ast_context) {
172  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
173  return false;
174  }
175 
176  if (GetImportInProgress()) {
177  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
178  return false;
179  }
180 
181  std::string decl_name(clang_decl_name.getAsString());
182 
183  // if (m_decl_map.DoingASTImport ())
184  // return DeclContext::lookup_result();
185  //
186  switch (clang_decl_name.getNameKind()) {
187  // Normal identifiers.
188  case DeclarationName::Identifier: {
189  clang::IdentifierInfo *identifier_info =
190  clang_decl_name.getAsIdentifierInfo();
191 
192  if (!identifier_info || identifier_info->getBuiltinID() != 0) {
193  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
194  return false;
195  }
196  } break;
197 
198  // Operator names.
199  case DeclarationName::CXXOperatorName:
200  case DeclarationName::CXXLiteralOperatorName:
201  break;
202 
203  // Using directives found in this context.
204  // Tell Sema we didn't find any or we'll end up getting asked a *lot*.
205  case DeclarationName::CXXUsingDirective:
206  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
207  return false;
208 
209  case DeclarationName::ObjCZeroArgSelector:
210  case DeclarationName::ObjCOneArgSelector:
211  case DeclarationName::ObjCMultiArgSelector: {
212  llvm::SmallVector<NamedDecl *, 1> method_decls;
213 
214  NameSearchContext method_search_context(*this, method_decls,
215  clang_decl_name, decl_ctx);
216 
217  FindObjCMethodDecls(method_search_context);
218 
219  SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, method_decls);
220  return (method_decls.size() > 0);
221  }
222  // These aren't possible in the global context.
223  case DeclarationName::CXXConstructorName:
224  case DeclarationName::CXXDestructorName:
225  case DeclarationName::CXXConversionFunctionName:
226  case DeclarationName::CXXDeductionGuideName:
227  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
228  return false;
229  }
230 
231  if (!GetLookupsEnabled()) {
232  // Wait until we see a '$' at the start of a name before we start doing any
233  // lookups so we can avoid lookup up all of the builtin types.
234  if (!decl_name.empty() && decl_name[0] == '$') {
235  SetLookupsEnabled(true);
236  } else {
237  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
238  return false;
239  }
240  }
241 
242  ConstString const_decl_name(decl_name.c_str());
243 
244  const char *uniqued_const_decl_name = const_decl_name.GetCString();
245  if (m_active_lookups.find(uniqued_const_decl_name) !=
246  m_active_lookups.end()) {
247  // We are currently looking up this name...
248  SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
249  return false;
250  }
251  m_active_lookups.insert(uniqued_const_decl_name);
252  // static uint32_t g_depth = 0;
253  // ++g_depth;
254  // printf("[%5u] FindExternalVisibleDeclsByName() \"%s\"\n", g_depth,
255  // uniqued_const_decl_name);
256  llvm::SmallVector<NamedDecl *, 4> name_decls;
257  NameSearchContext name_search_context(*this, name_decls, clang_decl_name,
258  decl_ctx);
259  FindExternalVisibleDecls(name_search_context);
260  SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, name_decls);
261  // --g_depth;
262  m_active_lookups.erase(uniqued_const_decl_name);
263  return (name_decls.size() != 0);
264 }
265 
266 void ClangASTSource::CompleteType(TagDecl *tag_decl) {
268 
269  static unsigned int invocation_id = 0;
270  unsigned int current_id = invocation_id++;
271 
272  if (log) {
273  log->Printf(" CompleteTagDecl[%u] on (ASTContext*)%p Completing "
274  "(TagDecl*)%p named %s",
275  current_id, static_cast<void *>(m_ast_context),
276  static_cast<void *>(tag_decl),
277  tag_decl->getName().str().c_str());
278 
279  log->Printf(" CTD[%u] Before:", current_id);
280  ASTDumper dumper((Decl *)tag_decl);
281  dumper.ToLog(log, " [CTD] ");
282  }
283 
284  auto iter = m_active_lexical_decls.find(tag_decl);
285  if (iter != m_active_lexical_decls.end())
286  return;
287  m_active_lexical_decls.insert(tag_decl);
288  ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl);
289 
290  if (!m_ast_importer_sp) {
291  if (HasMerger()) {
292  GetMergerUnchecked().CompleteType(tag_decl);
293  }
294  return;
295  }
296 
297  if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
298  // We couldn't complete the type. Maybe there's a definition somewhere
299  // else that can be completed.
300 
301  if (log)
302  log->Printf(" CTD[%u] Type could not be completed in the module in "
303  "which it was first found.",
304  current_id);
305 
306  bool found = false;
307 
308  DeclContext *decl_ctx = tag_decl->getDeclContext();
309 
310  if (const NamespaceDecl *namespace_context =
311  dyn_cast<NamespaceDecl>(decl_ctx)) {
312  ClangASTImporter::NamespaceMapSP namespace_map =
313  m_ast_importer_sp->GetNamespaceMap(namespace_context);
314 
315  if (log && log->GetVerbose())
316  log->Printf(" CTD[%u] Inspecting namespace map %p (%d entries)",
317  current_id, static_cast<void *>(namespace_map.get()),
318  static_cast<int>(namespace_map->size()));
319 
320  if (!namespace_map)
321  return;
322 
323  for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
324  e = namespace_map->end();
325  i != e && !found; ++i) {
326  if (log)
327  log->Printf(" CTD[%u] Searching namespace %s in module %s",
328  current_id, i->second.GetName().AsCString(),
329  i->first->GetFileSpec().GetFilename().GetCString());
330 
331  TypeList types;
332 
333  ConstString name(tag_decl->getName().str().c_str());
334 
335  i->first->FindTypesInNamespace(name, &i->second, UINT32_MAX, types);
336 
337  for (uint32_t ti = 0, te = types.GetSize(); ti != te && !found; ++ti) {
338  lldb::TypeSP type = types.GetTypeAtIndex(ti);
339 
340  if (!type)
341  continue;
342 
343  CompilerType clang_type(type->GetFullCompilerType());
344 
345  if (!ClangUtil::IsClangType(clang_type))
346  continue;
347 
348  const TagType *tag_type =
349  ClangUtil::GetQualType(clang_type)->getAs<TagType>();
350 
351  if (!tag_type)
352  continue;
353 
354  TagDecl *candidate_tag_decl =
355  const_cast<TagDecl *>(tag_type->getDecl());
356 
357  if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl,
358  candidate_tag_decl))
359  found = true;
360  }
361  }
362  } else {
363  TypeList types;
364 
365  ConstString name(tag_decl->getName().str().c_str());
366  CompilerDeclContext namespace_decl;
367 
368  const ModuleList &module_list = m_target->GetImages();
369 
370  bool exact_match = false;
371  llvm::DenseSet<SymbolFile *> searched_symbol_files;
372  module_list.FindTypes(nullptr, name, exact_match, UINT32_MAX,
373  searched_symbol_files, types);
374 
375  for (uint32_t ti = 0, te = types.GetSize(); ti != te && !found; ++ti) {
376  lldb::TypeSP type = types.GetTypeAtIndex(ti);
377 
378  if (!type)
379  continue;
380 
381  CompilerType clang_type(type->GetFullCompilerType());
382 
383  if (!ClangUtil::IsClangType(clang_type))
384  continue;
385 
386  const TagType *tag_type =
387  ClangUtil::GetQualType(clang_type)->getAs<TagType>();
388 
389  if (!tag_type)
390  continue;
391 
392  TagDecl *candidate_tag_decl =
393  const_cast<TagDecl *>(tag_type->getDecl());
394 
395  // We have found a type by basename and we need to make sure the decl
396  // contexts are the same before we can try to complete this type with
397  // another
398  if (!ClangASTContext::DeclsAreEquivalent(tag_decl, candidate_tag_decl))
399  continue;
400 
401  if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl,
402  candidate_tag_decl))
403  found = true;
404  }
405  }
406  }
407 
408  if (log) {
409  log->Printf(" [CTD] After:");
410  ASTDumper dumper((Decl *)tag_decl);
411  dumper.ToLog(log, " [CTD] ");
412  }
413 }
414 
415 void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) {
417 
418  if (log) {
419  log->Printf(" [CompleteObjCInterfaceDecl] on (ASTContext*)%p Completing "
420  "an ObjCInterfaceDecl named %s",
421  static_cast<void *>(m_ast_context),
422  interface_decl->getName().str().c_str());
423  log->Printf(" [COID] Before:");
424  ASTDumper dumper((Decl *)interface_decl);
425  dumper.ToLog(log, " [COID] ");
426  }
427 
428  if (!m_ast_importer_sp) {
429  if (HasMerger()) {
430  ObjCInterfaceDecl *complete_iface_decl =
431  GetCompleteObjCInterface(interface_decl);
432 
433  if (complete_iface_decl && (complete_iface_decl != interface_decl)) {
434  m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()});
435  }
436 
437  GetMergerUnchecked().CompleteType(interface_decl);
438  } else {
439  lldbassert(0 && "No mechanism for completing a type!");
440  }
441  return;
442  }
443 
444  Decl *original_decl = NULL;
445  ASTContext *original_ctx = NULL;
446 
447  if (m_ast_importer_sp->ResolveDeclOrigin(interface_decl, &original_decl,
448  &original_ctx)) {
449  if (ObjCInterfaceDecl *original_iface_decl =
450  dyn_cast<ObjCInterfaceDecl>(original_decl)) {
451  ObjCInterfaceDecl *complete_iface_decl =
452  GetCompleteObjCInterface(original_iface_decl);
453 
454  if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) {
455  m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl);
456  }
457  }
458  }
459 
460  m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl);
461 
462  if (interface_decl->getSuperClass() &&
463  interface_decl->getSuperClass() != interface_decl)
464  CompleteType(interface_decl->getSuperClass());
465 
466  if (log) {
467  log->Printf(" [COID] After:");
468  ASTDumper dumper((Decl *)interface_decl);
469  dumper.ToLog(log, " [COID] ");
470  }
471 }
472 
474  const clang::ObjCInterfaceDecl *interface_decl) {
475  lldb::ProcessSP process(m_target->GetProcessSP());
476 
477  if (!process)
478  return NULL;
479 
480  ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
481 
482  if (!language_runtime)
483  return NULL;
484 
485  ConstString class_name(interface_decl->getNameAsString().c_str());
486 
487  lldb::TypeSP complete_type_sp(
488  language_runtime->LookupInCompleteClassCache(class_name));
489 
490  if (!complete_type_sp)
491  return NULL;
492 
493  TypeFromUser complete_type =
494  TypeFromUser(complete_type_sp->GetFullCompilerType());
495  lldb::opaque_compiler_type_t complete_opaque_type =
496  complete_type.GetOpaqueQualType();
497 
498  if (!complete_opaque_type)
499  return NULL;
500 
501  const clang::Type *complete_clang_type =
502  QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr();
503  const ObjCInterfaceType *complete_interface_type =
504  dyn_cast<ObjCInterfaceType>(complete_clang_type);
505 
506  if (!complete_interface_type)
507  return NULL;
508 
509  ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl());
510 
511  return complete_iface_decl;
512 }
513 
515  const DeclContext *decl_context,
516  llvm::function_ref<bool(Decl::Kind)> predicate,
518 
519  if (HasMerger()) {
520  if (auto *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl_context)) {
521  ObjCInterfaceDecl *complete_iface_decl =
522  GetCompleteObjCInterface(interface_decl);
523 
524  if (complete_iface_decl && (complete_iface_decl != interface_decl)) {
525  m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()});
526  }
527  }
528  return GetMergerUnchecked().FindExternalLexicalDecls(decl_context,
529  predicate,
530  decls);
531  } else if (!m_ast_importer_sp)
532  return;
533 
535 
537 
538  const Decl *context_decl = dyn_cast<Decl>(decl_context);
539 
540  if (!context_decl)
541  return;
542 
543  auto iter = m_active_lexical_decls.find(context_decl);
544  if (iter != m_active_lexical_decls.end())
545  return;
546  m_active_lexical_decls.insert(context_decl);
547  ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl);
548 
549  static unsigned int invocation_id = 0;
550  unsigned int current_id = invocation_id++;
551 
552  if (log) {
553  if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl))
554  log->Printf(
555  "FindExternalLexicalDecls[%u] on (ASTContext*)%p in '%s' (%sDecl*)%p",
556  current_id, static_cast<void *>(m_ast_context),
557  context_named_decl->getNameAsString().c_str(),
558  context_decl->getDeclKindName(),
559  static_cast<const void *>(context_decl));
560  else if (context_decl)
561  log->Printf(
562  "FindExternalLexicalDecls[%u] on (ASTContext*)%p in (%sDecl*)%p",
563  current_id, static_cast<void *>(m_ast_context),
564  context_decl->getDeclKindName(),
565  static_cast<const void *>(context_decl));
566  else
567  log->Printf(
568  "FindExternalLexicalDecls[%u] on (ASTContext*)%p in a NULL context",
569  current_id, static_cast<const void *>(m_ast_context));
570  }
571 
572  Decl *original_decl = NULL;
573  ASTContext *original_ctx = NULL;
574 
575  if (!m_ast_importer_sp->ResolveDeclOrigin(context_decl, &original_decl,
576  &original_ctx))
577  return;
578 
579  if (log) {
580  log->Printf(" FELD[%u] Original decl (ASTContext*)%p (Decl*)%p:",
581  current_id, static_cast<void *>(original_ctx),
582  static_cast<void *>(original_decl));
583  ASTDumper(original_decl).ToLog(log, " ");
584  }
585 
586  if (ObjCInterfaceDecl *original_iface_decl =
587  dyn_cast<ObjCInterfaceDecl>(original_decl)) {
588  ObjCInterfaceDecl *complete_iface_decl =
589  GetCompleteObjCInterface(original_iface_decl);
590 
591  if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) {
592  original_decl = complete_iface_decl;
593  original_ctx = &complete_iface_decl->getASTContext();
594 
595  m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl);
596  }
597  }
598 
599  if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl)) {
600  ExternalASTSource *external_source = original_ctx->getExternalSource();
601 
602  if (external_source)
603  external_source->CompleteType(original_tag_decl);
604  }
605 
606  const DeclContext *original_decl_context =
607  dyn_cast<DeclContext>(original_decl);
608 
609  if (!original_decl_context)
610  return;
611 
612  for (TagDecl::decl_iterator iter = original_decl_context->decls_begin();
613  iter != original_decl_context->decls_end(); ++iter) {
614  Decl *decl = *iter;
615 
616  if (predicate(decl->getKind())) {
617  if (log) {
618  ASTDumper ast_dumper(decl);
619  if (const NamedDecl *context_named_decl =
620  dyn_cast<NamedDecl>(context_decl))
621  log->Printf(" FELD[%d] Adding [to %sDecl %s] lexical %sDecl %s",
622  current_id, context_named_decl->getDeclKindName(),
623  context_named_decl->getNameAsString().c_str(),
624  decl->getDeclKindName(), ast_dumper.GetCString());
625  else
626  log->Printf(" FELD[%d] Adding lexical %sDecl %s", current_id,
627  decl->getDeclKindName(), ast_dumper.GetCString());
628  }
629 
630  Decl *copied_decl = CopyDecl(decl);
631 
632  if (!copied_decl)
633  continue;
634 
635  if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl)) {
636  QualType copied_field_type = copied_field->getType();
637 
638  m_ast_importer_sp->RequireCompleteType(copied_field_type);
639  }
640 
641  DeclContext *decl_context_non_const =
642  const_cast<DeclContext *>(decl_context);
643 
644  if (copied_decl->getDeclContext() != decl_context) {
645  if (copied_decl->getDeclContext()->containsDecl(copied_decl))
646  copied_decl->getDeclContext()->removeDecl(copied_decl);
647  copied_decl->setDeclContext(decl_context_non_const);
648  }
649 
650  if (!decl_context_non_const->containsDecl(copied_decl))
651  decl_context_non_const->addDeclInternal(copied_decl);
652  }
653  }
654 
655  return;
656 }
657 
659  assert(m_ast_context);
660 
662 
663  const ConstString name(context.m_decl_name.getAsString().c_str());
664 
666 
667  static unsigned int invocation_id = 0;
668  unsigned int current_id = invocation_id++;
669 
670  if (log) {
671  if (!context.m_decl_context)
672  log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on "
673  "(ASTContext*)%p for '%s' in a NULL DeclContext",
674  current_id, static_cast<void *>(m_ast_context),
675  name.GetCString());
676  else if (const NamedDecl *context_named_decl =
677  dyn_cast<NamedDecl>(context.m_decl_context))
678  log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on "
679  "(ASTContext*)%p for '%s' in '%s'",
680  current_id, static_cast<void *>(m_ast_context),
681  name.GetCString(),
682  context_named_decl->getNameAsString().c_str());
683  else
684  log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on "
685  "(ASTContext*)%p for '%s' in a '%s'",
686  current_id, static_cast<void *>(m_ast_context),
687  name.GetCString(), context.m_decl_context->getDeclKindName());
688  }
689 
690  if (HasMerger() && !isa<TranslationUnitDecl>(context.m_decl_context)
691  /* possibly handle NamespaceDecls here? */) {
692  if (auto *interface_decl =
693  dyn_cast<ObjCInterfaceDecl>(context.m_decl_context)) {
694  ObjCInterfaceDecl *complete_iface_decl =
695  GetCompleteObjCInterface(interface_decl);
696 
697  if (complete_iface_decl && (complete_iface_decl != interface_decl)) {
698  GetMergerUnchecked().ForceRecordOrigin(
699  interface_decl,
700  {complete_iface_decl, &complete_iface_decl->getASTContext()});
701  }
702  }
703 
704  GetMergerUnchecked().FindExternalVisibleDeclsByName(context.m_decl_context,
705  context.m_decl_name);
706  return; // otherwise we may need to fall back
707  }
708 
709  context.m_namespace_map = std::make_shared<ClangASTImporter::NamespaceMap>();
710 
711  if (const NamespaceDecl *namespace_context =
712  dyn_cast<NamespaceDecl>(context.m_decl_context)) {
714  m_ast_importer_sp->GetNamespaceMap(namespace_context) : nullptr;
715 
716  if (log && log->GetVerbose())
717  log->Printf(" CAS::FEVD[%u] Inspecting namespace map %p (%d entries)",
718  current_id, static_cast<void *>(namespace_map.get()),
719  static_cast<int>(namespace_map->size()));
720 
721  if (!namespace_map)
722  return;
723 
724  for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
725  e = namespace_map->end();
726  i != e; ++i) {
727  if (log)
728  log->Printf(" CAS::FEVD[%u] Searching namespace %s in module %s",
729  current_id, i->second.GetName().AsCString(),
730  i->first->GetFileSpec().GetFilename().GetCString());
731 
732  FindExternalVisibleDecls(context, i->first, i->second, current_id);
733  }
734  } else if (isa<ObjCInterfaceDecl>(context.m_decl_context) && !HasMerger()) {
736  } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) {
737  // we shouldn't be getting FindExternalVisibleDecls calls for these
738  return;
739  } else {
740  CompilerDeclContext namespace_decl;
741 
742  if (log)
743  log->Printf(" CAS::FEVD[%u] Searching the root namespace", current_id);
744 
745  FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl,
746  current_id);
747  }
748 
749  if (!context.m_namespace_map->empty()) {
750  if (log && log->GetVerbose())
751  log->Printf(" CAS::FEVD[%u] Registering namespace map %p (%d entries)",
752  current_id,
753  static_cast<void *>(context.m_namespace_map.get()),
754  static_cast<int>(context.m_namespace_map->size()));
755 
756  NamespaceDecl *clang_namespace_decl =
757  AddNamespace(context, context.m_namespace_map);
758 
759  if (clang_namespace_decl)
760  clang_namespace_decl->setHasExternalVisibleStorage();
761  }
762 }
763 
764 clang::Sema *ClangASTSource::getSema() {
766 }
767 
769  bool ignore_all_dollar_names) {
770  static const ConstString id_name("id");
771  static const ConstString Class_name("Class");
772 
773  if (m_ast_context->getLangOpts().ObjC)
774  if (name == id_name || name == Class_name)
775  return true;
776 
777  StringRef name_string_ref = name.GetStringRef();
778 
779  // The ClangASTSource is not responsible for finding $-names.
780  return name_string_ref.empty() ||
781  (ignore_all_dollar_names && name_string_ref.startswith("$")) ||
782  name_string_ref.startswith("_$");
783 }
784 
786  NameSearchContext &context, lldb::ModuleSP module_sp,
787  CompilerDeclContext &namespace_decl, unsigned int current_id) {
788  assert(m_ast_context);
789 
791 
792  SymbolContextList sc_list;
793 
794  const ConstString name(context.m_decl_name.getAsString().c_str());
795  if (IgnoreName(name, true))
796  return;
797 
798  if (module_sp && namespace_decl) {
799  CompilerDeclContext found_namespace_decl;
800 
801  SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
802 
803  if (symbol_vendor) {
804  found_namespace_decl =
805  symbol_vendor->FindNamespace(name, &namespace_decl);
806 
807  if (found_namespace_decl) {
808  context.m_namespace_map->push_back(
809  std::pair<lldb::ModuleSP, CompilerDeclContext>(
810  module_sp, found_namespace_decl));
811 
812  if (log)
813  log->Printf(" CAS::FEVD[%u] Found namespace %s in module %s",
814  current_id, name.GetCString(),
815  module_sp->GetFileSpec().GetFilename().GetCString());
816  }
817  }
818  } else if (!HasMerger()) {
819  const ModuleList &target_images = m_target->GetImages();
820  std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
821 
822  for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
823  lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i);
824 
825  if (!image)
826  continue;
827 
828  CompilerDeclContext found_namespace_decl;
829 
830  SymbolVendor *symbol_vendor = image->GetSymbolVendor();
831 
832  if (!symbol_vendor)
833  continue;
834 
835  found_namespace_decl =
836  symbol_vendor->FindNamespace(name, &namespace_decl);
837 
838  if (found_namespace_decl) {
839  context.m_namespace_map->push_back(
840  std::pair<lldb::ModuleSP, CompilerDeclContext>(
841  image, found_namespace_decl));
842 
843  if (log)
844  log->Printf(" CAS::FEVD[%u] Found namespace %s in module %s",
845  current_id, name.GetCString(),
846  image->GetFileSpec().GetFilename().GetCString());
847  }
848  }
849  }
850 
851  do {
852  if (context.m_found.type)
853  break;
854 
855  TypeList types;
856  const bool exact_match = true;
857  llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
858  if (module_sp && namespace_decl)
859  module_sp->FindTypesInNamespace(name, &namespace_decl, 1, types);
860  else {
861  m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1,
862  searched_symbol_files, types);
863  }
864 
865  if (size_t num_types = types.GetSize()) {
866  for (size_t ti = 0; ti < num_types; ++ti) {
867  lldb::TypeSP type_sp = types.GetTypeAtIndex(ti);
868 
869  if (log) {
870  const char *name_string = type_sp->GetName().GetCString();
871 
872  log->Printf(" CAS::FEVD[%u] Matching type found for \"%s\": %s",
873  current_id, name.GetCString(),
874  (name_string ? name_string : "<anonymous>"));
875  }
876 
877  CompilerType full_type = type_sp->GetFullCompilerType();
878 
879  CompilerType copied_clang_type(GuardedCopyType(full_type));
880 
881  if (!copied_clang_type) {
882  if (log)
883  log->Printf(" CAS::FEVD[%u] - Couldn't export a type", current_id);
884 
885  continue;
886  }
887 
888  context.AddTypeDecl(copied_clang_type);
889 
890  context.m_found.type = true;
891  break;
892  }
893  }
894 
895  if (!context.m_found.type) {
896  // Try the modules next.
897 
898  do {
899  if (ClangModulesDeclVendor *modules_decl_vendor =
900  m_target->GetClangModulesDeclVendor()) {
901  bool append = false;
902  uint32_t max_matches = 1;
903  std::vector<clang::NamedDecl *> decls;
904 
905  if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
906  break;
907 
908  if (log) {
909  log->Printf(" CAS::FEVD[%u] Matching entity found for \"%s\" in "
910  "the modules",
911  current_id, name.GetCString());
912  }
913 
914  clang::NamedDecl *const decl_from_modules = decls[0];
915 
916  if (llvm::isa<clang::TypeDecl>(decl_from_modules) ||
917  llvm::isa<clang::ObjCContainerDecl>(decl_from_modules) ||
918  llvm::isa<clang::EnumConstantDecl>(decl_from_modules)) {
919  clang::Decl *copied_decl = CopyDecl(decl_from_modules);
920  clang::NamedDecl *copied_named_decl =
921  copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
922 
923  if (!copied_named_decl) {
924  if (log)
925  log->Printf(
926  " CAS::FEVD[%u] - Couldn't export a type from the modules",
927  current_id);
928 
929  break;
930  }
931 
932  context.AddNamedDecl(copied_named_decl);
933 
934  context.m_found.type = true;
935  }
936  }
937  } while (0);
938  }
939 
940  if (!context.m_found.type) {
941  do {
942  // Couldn't find any types elsewhere. Try the Objective-C runtime if
943  // one exists.
944 
945  lldb::ProcessSP process(m_target->GetProcessSP());
946 
947  if (!process)
948  break;
949 
950  ObjCLanguageRuntime *language_runtime(
951  process->GetObjCLanguageRuntime());
952 
953  if (!language_runtime)
954  break;
955 
956  DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
957 
958  if (!decl_vendor)
959  break;
960 
961  bool append = false;
962  uint32_t max_matches = 1;
963  std::vector<clang::NamedDecl *> decls;
964 
965  if (!decl_vendor->FindDecls(name, append, max_matches, decls))
966  break;
967 
968  if (log) {
969  log->Printf(
970  " CAS::FEVD[%u] Matching type found for \"%s\" in the runtime",
971  current_id, name.GetCString());
972  }
973 
974  clang::Decl *copied_decl = CopyDecl(decls[0]);
975  clang::NamedDecl *copied_named_decl =
976  copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
977 
978  if (!copied_named_decl) {
979  if (log)
980  log->Printf(
981  " CAS::FEVD[%u] - Couldn't export a type from the runtime",
982  current_id);
983 
984  break;
985  }
986 
987  context.AddNamedDecl(copied_named_decl);
988  } while (0);
989  }
990 
991  } while (0);
992 }
993 
994 template <class D> class TaggedASTDecl {
995 public:
996  TaggedASTDecl() : decl(NULL) {}
997  TaggedASTDecl(D *_decl) : decl(_decl) {}
998  bool IsValid() const { return (decl != NULL); }
999  bool IsInvalid() const { return !IsValid(); }
1000  D *operator->() const { return decl; }
1001  D *decl;
1002 };
1003 
1004 template <class D2, template <class D> class TD, class D1>
1005 TD<D2> DynCast(TD<D1> source) {
1006  return TD<D2>(dyn_cast<D2>(source.decl));
1007 }
1008 
1009 template <class D = Decl> class DeclFromParser;
1010 template <class D = Decl> class DeclFromUser;
1011 
1012 template <class D> class DeclFromParser : public TaggedASTDecl<D> {
1013 public:
1015  DeclFromParser(D *_decl) : TaggedASTDecl<D>(_decl) {}
1016 
1017  DeclFromUser<D> GetOrigin(ClangASTSource &source);
1018 };
1019 
1020 template <class D> class DeclFromUser : public TaggedASTDecl<D> {
1021 public:
1023  DeclFromUser(D *_decl) : TaggedASTDecl<D>(_decl) {}
1024 
1025  DeclFromParser<D> Import(ClangASTSource &source);
1026 };
1027 
1028 template <class D>
1030  DeclFromUser<> origin_decl;
1031  source.ResolveDeclOrigin(this->decl, &origin_decl.decl, NULL);
1032  if (origin_decl.IsInvalid())
1033  return DeclFromUser<D>();
1034  return DeclFromUser<D>(dyn_cast<D>(origin_decl.decl));
1035 }
1036 
1037 template <class D>
1039  DeclFromParser<> parser_generic_decl(source.CopyDecl(this->decl));
1040  if (parser_generic_decl.IsInvalid())
1041  return DeclFromParser<D>();
1042  return DeclFromParser<D>(dyn_cast<D>(parser_generic_decl.decl));
1043 }
1044 
1046  unsigned int current_id, NameSearchContext &context,
1047  ObjCInterfaceDecl *original_interface_decl, const char *log_info) {
1048  const DeclarationName &decl_name(context.m_decl_name);
1049  clang::ASTContext *original_ctx = &original_interface_decl->getASTContext();
1050 
1051  Selector original_selector;
1052 
1053  if (decl_name.isObjCZeroArgSelector()) {
1054  IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString());
1055  original_selector = original_ctx->Selectors.getSelector(0, &ident);
1056  } else if (decl_name.isObjCOneArgSelector()) {
1057  const std::string &decl_name_string = decl_name.getAsString();
1058  std::string decl_name_string_without_colon(decl_name_string.c_str(),
1059  decl_name_string.length() - 1);
1060  IdentifierInfo *ident =
1061  &original_ctx->Idents.get(decl_name_string_without_colon);
1062  original_selector = original_ctx->Selectors.getSelector(1, &ident);
1063  } else {
1064  SmallVector<IdentifierInfo *, 4> idents;
1065 
1066  clang::Selector sel = decl_name.getObjCSelector();
1067 
1068  unsigned num_args = sel.getNumArgs();
1069 
1070  for (unsigned i = 0; i != num_args; ++i) {
1071  idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i)));
1072  }
1073 
1074  original_selector =
1075  original_ctx->Selectors.getSelector(num_args, idents.data());
1076  }
1077 
1078  DeclarationName original_decl_name(original_selector);
1079 
1080  llvm::SmallVector<NamedDecl *, 1> methods;
1081 
1082  ClangASTContext::GetCompleteDecl(original_ctx, original_interface_decl);
1083 
1084  if (ObjCMethodDecl *instance_method_decl =
1085  original_interface_decl->lookupInstanceMethod(original_selector)) {
1086  methods.push_back(instance_method_decl);
1087  } else if (ObjCMethodDecl *class_method_decl =
1088  original_interface_decl->lookupClassMethod(
1089  original_selector)) {
1090  methods.push_back(class_method_decl);
1091  }
1092 
1093  if (methods.empty()) {
1094  return false;
1095  }
1096 
1097  for (NamedDecl *named_decl : methods) {
1098  if (!named_decl)
1099  continue;
1100 
1101  ObjCMethodDecl *result_method = dyn_cast<ObjCMethodDecl>(named_decl);
1102 
1103  if (!result_method)
1104  continue;
1105 
1106  Decl *copied_decl = CopyDecl(result_method);
1107 
1108  if (!copied_decl)
1109  continue;
1110 
1111  ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl);
1112 
1113  if (!copied_method_decl)
1114  continue;
1115 
1117 
1118  if (log) {
1119  ASTDumper dumper((Decl *)copied_method_decl);
1120  log->Printf(" CAS::FOMD[%d] found (%s) %s", current_id, log_info,
1121  dumper.GetCString());
1122  }
1123 
1124  context.AddNamedDecl(copied_method_decl);
1125  }
1126 
1127  return true;
1128 }
1129 
1132 
1133  if (HasMerger()) {
1134  if (auto *interface_decl = dyn_cast<ObjCInterfaceDecl>(context.m_decl_context)) {
1135  ObjCInterfaceDecl *complete_iface_decl =
1136  GetCompleteObjCInterface(interface_decl);
1137 
1138  if (complete_iface_decl && (complete_iface_decl != context.m_decl_context)) {
1139  m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()});
1140  }
1141  }
1142 
1143  GetMergerUnchecked().FindExternalVisibleDeclsByName(context.m_decl_context,
1144  context.m_decl_name);
1145  return;
1146  }
1147 
1148  static unsigned int invocation_id = 0;
1149  unsigned int current_id = invocation_id++;
1150 
1151  const DeclarationName &decl_name(context.m_decl_name);
1152  const DeclContext *decl_ctx(context.m_decl_context);
1153 
1154  const ObjCInterfaceDecl *interface_decl =
1155  dyn_cast<ObjCInterfaceDecl>(decl_ctx);
1156 
1157  if (!interface_decl)
1158  return;
1159 
1160  do {
1161  Decl *original_decl = NULL;
1162  ASTContext *original_ctx = NULL;
1163 
1164  m_ast_importer_sp->ResolveDeclOrigin(interface_decl, &original_decl,
1165  &original_ctx);
1166 
1167  if (!original_decl)
1168  break;
1169 
1170  ObjCInterfaceDecl *original_interface_decl =
1171  dyn_cast<ObjCInterfaceDecl>(original_decl);
1172 
1173  if (FindObjCMethodDeclsWithOrigin(current_id, context,
1174  original_interface_decl, "at origin"))
1175  return; // found it, no need to look any further
1176  } while (0);
1177 
1178  StreamString ss;
1179 
1180  if (decl_name.isObjCZeroArgSelector()) {
1181  ss.Printf("%s", decl_name.getAsString().c_str());
1182  } else if (decl_name.isObjCOneArgSelector()) {
1183  ss.Printf("%s", decl_name.getAsString().c_str());
1184  } else {
1185  clang::Selector sel = decl_name.getObjCSelector();
1186 
1187  for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) {
1188  llvm::StringRef r = sel.getNameForSlot(i);
1189  ss.Printf("%s:", r.str().c_str());
1190  }
1191  }
1192  ss.Flush();
1193 
1194  if (ss.GetString().contains("$__lldb"))
1195  return; // we don't need any results
1196 
1197  ConstString selector_name(ss.GetString());
1198 
1199  if (log)
1200  log->Printf("ClangASTSource::FindObjCMethodDecls[%d] on (ASTContext*)%p "
1201  "for selector [%s %s]",
1202  current_id, static_cast<void *>(m_ast_context),
1203  interface_decl->getNameAsString().c_str(),
1204  selector_name.AsCString());
1205  SymbolContextList sc_list;
1206 
1207  const bool include_symbols = false;
1208  const bool include_inlines = false;
1209  const bool append = false;
1210 
1211  std::string interface_name = interface_decl->getNameAsString();
1212 
1213  do {
1214  StreamString ms;
1215  ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString());
1216  ms.Flush();
1217  ConstString instance_method_name(ms.GetString());
1218 
1219  m_target->GetImages().FindFunctions(
1220  instance_method_name, lldb::eFunctionNameTypeFull, include_symbols,
1221  include_inlines, append, sc_list);
1222 
1223  if (sc_list.GetSize())
1224  break;
1225 
1226  ms.Clear();
1227  ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString());
1228  ms.Flush();
1229  ConstString class_method_name(ms.GetString());
1230 
1231  m_target->GetImages().FindFunctions(
1232  class_method_name, lldb::eFunctionNameTypeFull, include_symbols,
1233  include_inlines, append, sc_list);
1234 
1235  if (sc_list.GetSize())
1236  break;
1237 
1238  // Fall back and check for methods in categories. If we find methods this
1239  // way, we need to check that they're actually in categories on the desired
1240  // class.
1241 
1242  SymbolContextList candidate_sc_list;
1243 
1244  m_target->GetImages().FindFunctions(
1245  selector_name, lldb::eFunctionNameTypeSelector, include_symbols,
1246  include_inlines, append, candidate_sc_list);
1247 
1248  for (uint32_t ci = 0, ce = candidate_sc_list.GetSize(); ci != ce; ++ci) {
1249  SymbolContext candidate_sc;
1250 
1251  if (!candidate_sc_list.GetContextAtIndex(ci, candidate_sc))
1252  continue;
1253 
1254  if (!candidate_sc.function)
1255  continue;
1256 
1257  const char *candidate_name = candidate_sc.function->GetName().AsCString();
1258 
1259  const char *cursor = candidate_name;
1260 
1261  if (*cursor != '+' && *cursor != '-')
1262  continue;
1263 
1264  ++cursor;
1265 
1266  if (*cursor != '[')
1267  continue;
1268 
1269  ++cursor;
1270 
1271  size_t interface_len = interface_name.length();
1272 
1273  if (strncmp(cursor, interface_name.c_str(), interface_len))
1274  continue;
1275 
1276  cursor += interface_len;
1277 
1278  if (*cursor == ' ' || *cursor == '(')
1279  sc_list.Append(candidate_sc);
1280  }
1281  } while (0);
1282 
1283  if (sc_list.GetSize()) {
1284  // We found a good function symbol. Use that.
1285 
1286  for (uint32_t i = 0, e = sc_list.GetSize(); i != e; ++i) {
1287  SymbolContext sc;
1288 
1289  if (!sc_list.GetContextAtIndex(i, sc))
1290  continue;
1291 
1292  if (!sc.function)
1293  continue;
1294 
1295  CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext();
1296  if (!function_decl_ctx)
1297  continue;
1298 
1299  ObjCMethodDecl *method_decl =
1301 
1302  if (!method_decl)
1303  continue;
1304 
1305  ObjCInterfaceDecl *found_interface_decl =
1306  method_decl->getClassInterface();
1307 
1308  if (!found_interface_decl)
1309  continue;
1310 
1311  if (found_interface_decl->getName() == interface_decl->getName()) {
1312  Decl *copied_decl = CopyDecl(method_decl);
1313 
1314  if (!copied_decl)
1315  continue;
1316 
1317  ObjCMethodDecl *copied_method_decl =
1318  dyn_cast<ObjCMethodDecl>(copied_decl);
1319 
1320  if (!copied_method_decl)
1321  continue;
1322 
1323  if (log) {
1324  ASTDumper dumper((Decl *)copied_method_decl);
1325  log->Printf(" CAS::FOMD[%d] found (in symbols) %s", current_id,
1326  dumper.GetCString());
1327  }
1328 
1329  context.AddNamedDecl(copied_method_decl);
1330  }
1331  }
1332 
1333  return;
1334  }
1335 
1336  // Try the debug information.
1337 
1338  do {
1339  ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(
1340  const_cast<ObjCInterfaceDecl *>(interface_decl));
1341 
1342  if (!complete_interface_decl)
1343  break;
1344 
1345  // We found the complete interface. The runtime never needs to be queried
1346  // in this scenario.
1347 
1348  DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
1349  complete_interface_decl);
1350 
1351  if (complete_interface_decl == interface_decl)
1352  break; // already checked this one
1353 
1354  if (log)
1355  log->Printf("CAS::FOPD[%d] trying origin "
1356  "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
1357  current_id, static_cast<void *>(complete_interface_decl),
1358  static_cast<void *>(&complete_iface_decl->getASTContext()));
1359 
1360  FindObjCMethodDeclsWithOrigin(current_id, context, complete_interface_decl,
1361  "in debug info");
1362 
1363  return;
1364  } while (0);
1365 
1366  do {
1367  // Check the modules only if the debug information didn't have a complete
1368  // interface.
1369 
1370  if (ClangModulesDeclVendor *modules_decl_vendor =
1371  m_target->GetClangModulesDeclVendor()) {
1372  ConstString interface_name(interface_decl->getNameAsString().c_str());
1373  bool append = false;
1374  uint32_t max_matches = 1;
1375  std::vector<clang::NamedDecl *> decls;
1376 
1377  if (!modules_decl_vendor->FindDecls(interface_name, append, max_matches,
1378  decls))
1379  break;
1380 
1381  ObjCInterfaceDecl *interface_decl_from_modules =
1382  dyn_cast<ObjCInterfaceDecl>(decls[0]);
1383 
1384  if (!interface_decl_from_modules)
1385  break;
1386 
1388  current_id, context, interface_decl_from_modules, "in modules"))
1389  return;
1390  }
1391  } while (0);
1392 
1393  do {
1394  // Check the runtime only if the debug information didn't have a complete
1395  // interface and the modules don't get us anywhere.
1396 
1397  lldb::ProcessSP process(m_target->GetProcessSP());
1398 
1399  if (!process)
1400  break;
1401 
1402  ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
1403 
1404  if (!language_runtime)
1405  break;
1406 
1407  DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
1408 
1409  if (!decl_vendor)
1410  break;
1411 
1412  ConstString interface_name(interface_decl->getNameAsString().c_str());
1413  bool append = false;
1414  uint32_t max_matches = 1;
1415  std::vector<clang::NamedDecl *> decls;
1416 
1417  if (!decl_vendor->FindDecls(interface_name, append, max_matches, decls))
1418  break;
1419 
1420  ObjCInterfaceDecl *runtime_interface_decl =
1421  dyn_cast<ObjCInterfaceDecl>(decls[0]);
1422 
1423  if (!runtime_interface_decl)
1424  break;
1425 
1426  FindObjCMethodDeclsWithOrigin(current_id, context, runtime_interface_decl,
1427  "in runtime");
1428  } while (0);
1429 }
1430 
1432  unsigned int current_id, NameSearchContext &context, ClangASTSource &source,
1433  DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) {
1435 
1436  if (origin_iface_decl.IsInvalid())
1437  return false;
1438 
1439  std::string name_str = context.m_decl_name.getAsString();
1440  StringRef name(name_str);
1441  IdentifierInfo &name_identifier(
1442  origin_iface_decl->getASTContext().Idents.get(name));
1443 
1444  DeclFromUser<ObjCPropertyDecl> origin_property_decl(
1445  origin_iface_decl->FindPropertyDeclaration(
1446  &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance));
1447 
1448  bool found = false;
1449 
1450  if (origin_property_decl.IsValid()) {
1451  DeclFromParser<ObjCPropertyDecl> parser_property_decl(
1452  origin_property_decl.Import(source));
1453  if (parser_property_decl.IsValid()) {
1454  if (log) {
1455  ASTDumper dumper((Decl *)parser_property_decl.decl);
1456  log->Printf(" CAS::FOPD[%d] found %s", current_id,
1457  dumper.GetCString());
1458  }
1459 
1460  context.AddNamedDecl(parser_property_decl.decl);
1461  found = true;
1462  }
1463  }
1464 
1465  DeclFromUser<ObjCIvarDecl> origin_ivar_decl(
1466  origin_iface_decl->getIvarDecl(&name_identifier));
1467 
1468  if (origin_ivar_decl.IsValid()) {
1469  DeclFromParser<ObjCIvarDecl> parser_ivar_decl(
1470  origin_ivar_decl.Import(source));
1471  if (parser_ivar_decl.IsValid()) {
1472  if (log) {
1473  ASTDumper dumper((Decl *)parser_ivar_decl.decl);
1474  log->Printf(" CAS::FOPD[%d] found %s", current_id,
1475  dumper.GetCString());
1476  }
1477 
1478  context.AddNamedDecl(parser_ivar_decl.decl);
1479  found = true;
1480  }
1481  }
1482 
1483  return found;
1484 }
1485 
1488 
1489  static unsigned int invocation_id = 0;
1490  unsigned int current_id = invocation_id++;
1491 
1492  DeclFromParser<const ObjCInterfaceDecl> parser_iface_decl(
1493  cast<ObjCInterfaceDecl>(context.m_decl_context));
1494  DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl(
1495  parser_iface_decl.GetOrigin(*this));
1496 
1497  ConstString class_name(parser_iface_decl->getNameAsString().c_str());
1498 
1499  if (log)
1500  log->Printf("ClangASTSource::FindObjCPropertyAndIvarDecls[%d] on "
1501  "(ASTContext*)%p for '%s.%s'",
1502  current_id, static_cast<void *>(m_ast_context),
1503  parser_iface_decl->getNameAsString().c_str(),
1504  context.m_decl_name.getAsString().c_str());
1505 
1507  current_id, context, *this, origin_iface_decl))
1508  return;
1509 
1510  if (log)
1511  log->Printf("CAS::FOPD[%d] couldn't find the property on origin "
1512  "(ObjCInterfaceDecl*)%p/(ASTContext*)%p, searching "
1513  "elsewhere...",
1514  current_id, static_cast<const void *>(origin_iface_decl.decl),
1515  static_cast<void *>(&origin_iface_decl->getASTContext()));
1516 
1517  SymbolContext null_sc;
1518  TypeList type_list;
1519 
1520  do {
1521  ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(
1522  const_cast<ObjCInterfaceDecl *>(parser_iface_decl.decl));
1523 
1524  if (!complete_interface_decl)
1525  break;
1526 
1527  // We found the complete interface. The runtime never needs to be queried
1528  // in this scenario.
1529 
1530  DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
1531  complete_interface_decl);
1532 
1533  if (complete_iface_decl.decl == origin_iface_decl.decl)
1534  break; // already checked this one
1535 
1536  if (log)
1537  log->Printf("CAS::FOPD[%d] trying origin "
1538  "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
1539  current_id,
1540  static_cast<const void *>(complete_iface_decl.decl),
1541  static_cast<void *>(&complete_iface_decl->getASTContext()));
1542 
1543  FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this,
1544  complete_iface_decl);
1545 
1546  return;
1547  } while (0);
1548 
1549  do {
1550  // Check the modules only if the debug information didn't have a complete
1551  // interface.
1552 
1553  ClangModulesDeclVendor *modules_decl_vendor =
1554  m_target->GetClangModulesDeclVendor();
1555 
1556  if (!modules_decl_vendor)
1557  break;
1558 
1559  bool append = false;
1560  uint32_t max_matches = 1;
1561  std::vector<clang::NamedDecl *> decls;
1562 
1563  if (!modules_decl_vendor->FindDecls(class_name, append, max_matches, decls))
1564  break;
1565 
1566  DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_modules(
1567  dyn_cast<ObjCInterfaceDecl>(decls[0]));
1568 
1569  if (!interface_decl_from_modules.IsValid())
1570  break;
1571 
1572  if (log)
1573  log->Printf(
1574  "CAS::FOPD[%d] trying module "
1575  "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
1576  current_id,
1577  static_cast<const void *>(interface_decl_from_modules.decl),
1578  static_cast<void *>(&interface_decl_from_modules->getASTContext()));
1579 
1580  if (FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this,
1581  interface_decl_from_modules))
1582  return;
1583  } while (0);
1584 
1585  do {
1586  // Check the runtime only if the debug information didn't have a complete
1587  // interface and nothing was in the modules.
1588 
1589  lldb::ProcessSP process(m_target->GetProcessSP());
1590 
1591  if (!process)
1592  return;
1593 
1594  ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
1595 
1596  if (!language_runtime)
1597  return;
1598 
1599  DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
1600 
1601  if (!decl_vendor)
1602  break;
1603 
1604  bool append = false;
1605  uint32_t max_matches = 1;
1606  std::vector<clang::NamedDecl *> decls;
1607 
1608  if (!decl_vendor->FindDecls(class_name, append, max_matches, decls))
1609  break;
1610 
1611  DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime(
1612  dyn_cast<ObjCInterfaceDecl>(decls[0]));
1613 
1614  if (!interface_decl_from_runtime.IsValid())
1615  break;
1616 
1617  if (log)
1618  log->Printf(
1619  "CAS::FOPD[%d] trying runtime "
1620  "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...",
1621  current_id,
1622  static_cast<const void *>(interface_decl_from_runtime.decl),
1623  static_cast<void *>(&interface_decl_from_runtime->getASTContext()));
1624 
1626  current_id, context, *this, interface_decl_from_runtime))
1627  return;
1628  } while (0);
1629 }
1630 
1631 typedef llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsetMap;
1632 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap;
1633 
1634 template <class D, class O>
1635 static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
1636  llvm::DenseMap<const D *, O> &source_map,
1637  ClangASTSource &source) {
1638  // When importing fields into a new record, clang has a hard requirement that
1639  // fields be imported in field offset order. Since they are stored in a
1640  // DenseMap with a pointer as the key type, this means we cannot simply
1641  // iterate over the map, as the order will be non-deterministic. Instead we
1642  // have to sort by the offset and then insert in sorted order.
1643  typedef llvm::DenseMap<const D *, O> MapType;
1644  typedef typename MapType::value_type PairType;
1645  std::vector<PairType> sorted_items;
1646  sorted_items.reserve(source_map.size());
1647  sorted_items.assign(source_map.begin(), source_map.end());
1648  llvm::sort(sorted_items.begin(), sorted_items.end(),
1649  [](const PairType &lhs, const PairType &rhs) {
1650  return lhs.second < rhs.second;
1651  });
1652 
1653  for (const auto &item : sorted_items) {
1654  DeclFromUser<D> user_decl(const_cast<D *>(item.first));
1655  DeclFromParser<D> parser_decl(user_decl.Import(source));
1656  if (parser_decl.IsInvalid())
1657  return false;
1658  destination_map.insert(
1659  std::pair<const D *, O>(parser_decl.decl, item.second));
1660  }
1661 
1662  return true;
1663 }
1664 
1665 template <bool IsVirtual>
1666 bool ExtractBaseOffsets(const ASTRecordLayout &record_layout,
1668  BaseOffsetMap &base_offsets) {
1669  for (CXXRecordDecl::base_class_const_iterator
1670  bi = (IsVirtual ? record->vbases_begin() : record->bases_begin()),
1671  be = (IsVirtual ? record->vbases_end() : record->bases_end());
1672  bi != be; ++bi) {
1673  if (!IsVirtual && bi->isVirtual())
1674  continue;
1675 
1676  const clang::Type *origin_base_type = bi->getType().getTypePtr();
1677  const clang::RecordType *origin_base_record_type =
1678  origin_base_type->getAs<RecordType>();
1679 
1680  if (!origin_base_record_type)
1681  return false;
1682 
1683  DeclFromUser<RecordDecl> origin_base_record(
1684  origin_base_record_type->getDecl());
1685 
1686  if (origin_base_record.IsInvalid())
1687  return false;
1688 
1689  DeclFromUser<CXXRecordDecl> origin_base_cxx_record(
1690  DynCast<CXXRecordDecl>(origin_base_record));
1691 
1692  if (origin_base_cxx_record.IsInvalid())
1693  return false;
1694 
1695  CharUnits base_offset;
1696 
1697  if (IsVirtual)
1698  base_offset =
1699  record_layout.getVBaseClassOffset(origin_base_cxx_record.decl);
1700  else
1701  base_offset =
1702  record_layout.getBaseClassOffset(origin_base_cxx_record.decl);
1703 
1704  base_offsets.insert(std::pair<const CXXRecordDecl *, CharUnits>(
1705  origin_base_cxx_record.decl, base_offset));
1706  }
1707 
1708  return true;
1709 }
1710 
1711 bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size,
1712  uint64_t &alignment,
1713  FieldOffsetMap &field_offsets,
1714  BaseOffsetMap &base_offsets,
1715  BaseOffsetMap &virtual_base_offsets) {
1717 
1718  static unsigned int invocation_id = 0;
1719  unsigned int current_id = invocation_id++;
1720 
1722 
1723  if (log)
1724  log->Printf("LayoutRecordType[%u] on (ASTContext*)%p for (RecordDecl*)%p "
1725  "[name = '%s']",
1726  current_id, static_cast<void *>(m_ast_context),
1727  static_cast<const void *>(record),
1728  record->getNameAsString().c_str());
1729 
1730  DeclFromParser<const RecordDecl> parser_record(record);
1731  DeclFromUser<const RecordDecl> origin_record(
1732  parser_record.GetOrigin(*this));
1733 
1734  if (origin_record.IsInvalid())
1735  return false;
1736 
1737  FieldOffsetMap origin_field_offsets;
1738  BaseOffsetMap origin_base_offsets;
1739  BaseOffsetMap origin_virtual_base_offsets;
1740 
1742  &origin_record->getASTContext(),
1743  const_cast<RecordDecl *>(origin_record.decl));
1744 
1745  clang::RecordDecl *definition = origin_record.decl->getDefinition();
1746  if (!definition || !definition->isCompleteDefinition())
1747  return false;
1748 
1749  const ASTRecordLayout &record_layout(
1750  origin_record->getASTContext().getASTRecordLayout(origin_record.decl));
1751 
1752  int field_idx = 0, field_count = record_layout.getFieldCount();
1753 
1754  for (RecordDecl::field_iterator fi = origin_record->field_begin(),
1755  fe = origin_record->field_end();
1756  fi != fe; ++fi) {
1757  if (field_idx >= field_count)
1758  return false; // Layout didn't go well. Bail out.
1759 
1760  uint64_t field_offset = record_layout.getFieldOffset(field_idx);
1761 
1762  origin_field_offsets.insert(
1763  std::pair<const FieldDecl *, uint64_t>(*fi, field_offset));
1764 
1765  field_idx++;
1766  }
1767 
1768  lldbassert(&record->getASTContext() == m_ast_context);
1769 
1770  DeclFromUser<const CXXRecordDecl> origin_cxx_record(
1771  DynCast<const CXXRecordDecl>(origin_record));
1772 
1773  if (origin_cxx_record.IsValid()) {
1774  if (!ExtractBaseOffsets<false>(record_layout, origin_cxx_record,
1775  origin_base_offsets) ||
1776  !ExtractBaseOffsets<true>(record_layout, origin_cxx_record,
1777  origin_virtual_base_offsets))
1778  return false;
1779  }
1780 
1781  if (!ImportOffsetMap(field_offsets, origin_field_offsets, *this) ||
1782  !ImportOffsetMap(base_offsets, origin_base_offsets, *this) ||
1783  !ImportOffsetMap(virtual_base_offsets, origin_virtual_base_offsets,
1784  *this))
1785  return false;
1786 
1787  size = record_layout.getSize().getQuantity() * m_ast_context->getCharWidth();
1788  alignment = record_layout.getAlignment().getQuantity() *
1789  m_ast_context->getCharWidth();
1790 
1791  if (log) {
1792  log->Printf("LRT[%u] returned:", current_id);
1793  log->Printf("LRT[%u] Original = (RecordDecl*)%p", current_id,
1794  static_cast<const void *>(origin_record.decl));
1795  log->Printf("LRT[%u] Size = %" PRId64, current_id, size);
1796  log->Printf("LRT[%u] Alignment = %" PRId64, current_id, alignment);
1797  log->Printf("LRT[%u] Fields:", current_id);
1798  for (RecordDecl::field_iterator fi = record->field_begin(),
1799  fe = record->field_end();
1800  fi != fe; ++fi) {
1801  log->Printf("LRT[%u] (FieldDecl*)%p, Name = '%s', Offset = %" PRId64
1802  " bits",
1803  current_id, static_cast<void *>(*fi),
1804  fi->getNameAsString().c_str(), field_offsets[*fi]);
1805  }
1806  DeclFromParser<const CXXRecordDecl> parser_cxx_record =
1807  DynCast<const CXXRecordDecl>(parser_record);
1808  if (parser_cxx_record.IsValid()) {
1809  log->Printf("LRT[%u] Bases:", current_id);
1810  for (CXXRecordDecl::base_class_const_iterator
1811  bi = parser_cxx_record->bases_begin(),
1812  be = parser_cxx_record->bases_end();
1813  bi != be; ++bi) {
1814  bool is_virtual = bi->isVirtual();
1815 
1816  QualType base_type = bi->getType();
1817  const RecordType *base_record_type = base_type->getAs<RecordType>();
1818  DeclFromParser<RecordDecl> base_record(base_record_type->getDecl());
1819  DeclFromParser<CXXRecordDecl> base_cxx_record =
1820  DynCast<CXXRecordDecl>(base_record);
1821 
1822  log->Printf(
1823  "LRT[%u] %s(CXXRecordDecl*)%p, Name = '%s', Offset = %" PRId64
1824  " chars",
1825  current_id, (is_virtual ? "Virtual " : ""),
1826  static_cast<void *>(base_cxx_record.decl),
1827  base_cxx_record.decl->getNameAsString().c_str(),
1828  (is_virtual
1829  ? virtual_base_offsets[base_cxx_record.decl].getQuantity()
1830  : base_offsets[base_cxx_record.decl].getQuantity()));
1831  }
1832  } else {
1833  log->Printf("LRD[%u] Not a CXXRecord, so no bases", current_id);
1834  }
1835  }
1836 
1837  return true;
1838 }
1839 
1841  ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
1842  ClangASTImporter::NamespaceMapSP &parent_map) const {
1843  static unsigned int invocation_id = 0;
1844  unsigned int current_id = invocation_id++;
1845 
1847 
1848  if (log) {
1849  if (parent_map && parent_map->size())
1850  log->Printf("CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for "
1851  "namespace %s in namespace %s",
1852  current_id, static_cast<void *>(m_ast_context),
1853  name.GetCString(),
1854  parent_map->begin()->second.GetName().AsCString());
1855  else
1856  log->Printf("CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for "
1857  "namespace %s",
1858  current_id, static_cast<void *>(m_ast_context),
1859  name.GetCString());
1860  }
1861 
1862  if (parent_map) {
1863  for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
1864  e = parent_map->end();
1865  i != e; ++i) {
1866  CompilerDeclContext found_namespace_decl;
1867 
1868  lldb::ModuleSP module_sp = i->first;
1869  CompilerDeclContext module_parent_namespace_decl = i->second;
1870 
1871  SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
1872 
1873  if (!symbol_vendor)
1874  continue;
1875 
1876  found_namespace_decl =
1877  symbol_vendor->FindNamespace(name, &module_parent_namespace_decl);
1878 
1879  if (!found_namespace_decl)
1880  continue;
1881 
1882  namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
1883  module_sp, found_namespace_decl));
1884 
1885  if (log)
1886  log->Printf(" CMN[%u] Found namespace %s in module %s", current_id,
1887  name.GetCString(),
1888  module_sp->GetFileSpec().GetFilename().GetCString());
1889  }
1890  } else {
1891  const ModuleList &target_images = m_target->GetImages();
1892  std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
1893 
1894  CompilerDeclContext null_namespace_decl;
1895 
1896  for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
1897  lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i);
1898 
1899  if (!image)
1900  continue;
1901 
1902  CompilerDeclContext found_namespace_decl;
1903 
1904  SymbolVendor *symbol_vendor = image->GetSymbolVendor();
1905 
1906  if (!symbol_vendor)
1907  continue;
1908 
1909  found_namespace_decl =
1910  symbol_vendor->FindNamespace(name, &null_namespace_decl);
1911 
1912  if (!found_namespace_decl)
1913  continue;
1914 
1915  namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
1916  image, found_namespace_decl));
1917 
1918  if (log)
1919  log->Printf(" CMN[%u] Found namespace %s in module %s", current_id,
1920  name.GetCString(),
1921  image->GetFileSpec().GetFilename().GetCString());
1922  }
1923  }
1924 }
1925 
1927  NameSearchContext &context,
1928  ClangASTImporter::NamespaceMapSP &namespace_decls) {
1929  if (!namespace_decls)
1930  return nullptr;
1931 
1932  const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second;
1933 
1934  clang::ASTContext *src_ast =
1936  if (!src_ast)
1937  return nullptr;
1938  clang::NamespaceDecl *src_namespace_decl =
1940 
1941  if (!src_namespace_decl)
1942  return nullptr;
1943 
1944  Decl *copied_decl = CopyDecl(src_namespace_decl);
1945 
1946  if (!copied_decl)
1947  return nullptr;
1948 
1949  NamespaceDecl *copied_namespace_decl = dyn_cast<NamespaceDecl>(copied_decl);
1950 
1951  if (!copied_namespace_decl)
1952  return nullptr;
1953 
1954  context.m_decls.push_back(copied_namespace_decl);
1955 
1956  m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl,
1957  namespace_decls);
1958 
1959  return dyn_cast<NamespaceDecl>(copied_decl);
1960 }
1961 
1963  clang::ASTContext &from_context,
1964  clang::ExternalASTMerger &merger,
1965  clang::QualType type) {
1966  if (!merger.HasImporterForOrigin(from_context)) {
1967  lldbassert(0 && "Couldn't find the importer for a source context!");
1968  return QualType();
1969  }
1970 
1971  return merger.ImporterForOrigin(from_context).Import(type);
1972 }
1973 
1974 clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) {
1975  clang::ASTContext &from_context = src_decl->getASTContext();
1976  if (m_ast_importer_sp) {
1977  return m_ast_importer_sp->CopyDecl(m_ast_context, &from_context, src_decl);
1978  } else if (m_merger_up) {
1979  if (!m_merger_up->HasImporterForOrigin(from_context)) {
1980  lldbassert(0 && "Couldn't find the importer for a source context!");
1981  return nullptr;
1982  }
1983 
1984  return m_merger_up->ImporterForOrigin(from_context).Import(src_decl);
1985  } else {
1986  lldbassert(0 && "No mechanism for copying a decl!");
1987  return nullptr;
1988  }
1989 }
1990 
1991 bool ClangASTSource::ResolveDeclOrigin(const clang::Decl *decl,
1992  clang::Decl **original_decl,
1993  clang::ASTContext **original_ctx) {
1994  if (m_ast_importer_sp) {
1995  return m_ast_importer_sp->ResolveDeclOrigin(decl, original_decl,
1996  original_ctx);
1997  } else if (m_merger_up) {
1998  return false; // Implement this correctly in ExternalASTMerger
1999  } else {
2000  // this can happen early enough that no ExternalASTSource is installed.
2001  return false;
2002  }
2003 }
2004 
2005 clang::ExternalASTMerger &ClangASTSource::GetMergerUnchecked() {
2006  lldbassert(m_merger_up != nullptr);
2007  return *m_merger_up;
2008 }
2009 
2011  ClangASTContext *src_ast =
2012  llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
2013  if (src_ast == nullptr)
2014  return CompilerType();
2015 
2017 
2018  SetImportInProgress(true);
2019 
2020  QualType copied_qual_type;
2021 
2022  if (m_ast_importer_sp) {
2023  copied_qual_type =
2024  m_ast_importer_sp->CopyType(m_ast_context, src_ast->getASTContext(),
2025  ClangUtil::GetQualType(src_type));
2026  } else if (m_merger_up) {
2027  copied_qual_type =
2029  ClangUtil::GetQualType(src_type));
2030  } else {
2031  lldbassert(0 && "No mechanism for copying a type!");
2032  return CompilerType();
2033  }
2034 
2035  SetImportInProgress(false);
2036 
2037  if (copied_qual_type.getAsOpaquePtr() &&
2038  copied_qual_type->getCanonicalTypeInternal().isNull())
2039  // this shouldn't happen, but we're hardening because the AST importer
2040  // seems to be generating bad types on occasion.
2041  return CompilerType();
2042 
2043  return CompilerType(m_ast_context, copied_qual_type);
2044 }
2045 
2046 clang::NamedDecl *NameSearchContext::AddVarDecl(const CompilerType &type) {
2047  assert(type && "Type for variable must be valid!");
2048 
2049  if (!type.IsValid())
2050  return NULL;
2051 
2052  ClangASTContext *lldb_ast =
2053  llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
2054  if (!lldb_ast)
2055  return NULL;
2056 
2057  IdentifierInfo *ii = m_decl_name.getAsIdentifierInfo();
2058 
2059  clang::ASTContext *ast = lldb_ast->getASTContext();
2060 
2061  clang::NamedDecl *Decl = VarDecl::Create(
2062  *ast, const_cast<DeclContext *>(m_decl_context), SourceLocation(),
2063  SourceLocation(), ii, ClangUtil::GetQualType(type), 0, SC_Static);
2064  m_decls.push_back(Decl);
2065 
2066  return Decl;
2067 }
2068 
2069 clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type,
2070  bool extern_c) {
2071  assert(type && "Type for variable must be valid!");
2072 
2073  if (!type.IsValid())
2074  return NULL;
2075 
2076  if (m_function_types.count(type))
2077  return NULL;
2078 
2079  ClangASTContext *lldb_ast =
2080  llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
2081  if (!lldb_ast)
2082  return NULL;
2083 
2084  m_function_types.insert(type);
2085 
2086  QualType qual_type(ClangUtil::GetQualType(type));
2087 
2088  clang::ASTContext *ast = lldb_ast->getASTContext();
2089 
2090  const bool isInlineSpecified = false;
2091  const bool hasWrittenPrototype = true;
2092  const bool isConstexprSpecified = false;
2093 
2094  clang::DeclContext *context = const_cast<DeclContext *>(m_decl_context);
2095 
2096  if (extern_c) {
2097  context = LinkageSpecDecl::Create(
2098  *ast, context, SourceLocation(), SourceLocation(),
2099  clang::LinkageSpecDecl::LanguageIDs::lang_c, false);
2100  }
2101 
2102  // Pass the identifier info for functions the decl_name is needed for
2103  // operators
2104  clang::DeclarationName decl_name =
2105  m_decl_name.getNameKind() == DeclarationName::Identifier
2106  ? m_decl_name.getAsIdentifierInfo()
2107  : m_decl_name;
2108 
2109  clang::FunctionDecl *func_decl = FunctionDecl::Create(
2110  *ast, context, SourceLocation(), SourceLocation(), decl_name, qual_type,
2111  NULL, SC_Extern, isInlineSpecified, hasWrittenPrototype,
2112  isConstexprSpecified);
2113 
2114  // We have to do more than just synthesize the FunctionDecl. We have to
2115  // synthesize ParmVarDecls for all of the FunctionDecl's arguments. To do
2116  // this, we raid the function's FunctionProtoType for types.
2117 
2118  const FunctionProtoType *func_proto_type =
2119  qual_type.getTypePtr()->getAs<FunctionProtoType>();
2120 
2121  if (func_proto_type) {
2122  unsigned NumArgs = func_proto_type->getNumParams();
2123  unsigned ArgIndex;
2124 
2125  SmallVector<ParmVarDecl *, 5> parm_var_decls;
2126 
2127  for (ArgIndex = 0; ArgIndex < NumArgs; ++ArgIndex) {
2128  QualType arg_qual_type(func_proto_type->getParamType(ArgIndex));
2129 
2130  parm_var_decls.push_back(ParmVarDecl::Create(
2131  *ast, const_cast<DeclContext *>(context), SourceLocation(),
2132  SourceLocation(), NULL, arg_qual_type, NULL, SC_Static, NULL));
2133  }
2134 
2135  func_decl->setParams(ArrayRef<ParmVarDecl *>(parm_var_decls));
2136  } else {
2138 
2139  if (log)
2140  log->Printf("Function type wasn't a FunctionProtoType");
2141  }
2142 
2143  // If this is an operator (e.g. operator new or operator==), only insert the
2144  // declaration we inferred from the symbol if we can provide the correct
2145  // number of arguments. We shouldn't really inject random decl(s) for
2146  // functions that are analyzed semantically in a special way, otherwise we
2147  // will crash in clang.
2148  clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
2149  if (func_proto_type &&
2150  ClangASTContext::IsOperator(decl_name.getAsString().c_str(), op_kind)) {
2152  false, op_kind, func_proto_type->getNumParams()))
2153  return NULL;
2154  }
2155  m_decls.push_back(func_decl);
2156 
2157  return func_decl;
2158 }
2159 
2161  FunctionProtoType::ExtProtoInfo proto_info;
2162 
2163  proto_info.Variadic = true;
2164 
2165  QualType generic_function_type(m_ast_source.m_ast_context->getFunctionType(
2166  m_ast_source.m_ast_context->UnknownAnyTy, // result
2167  ArrayRef<QualType>(), // argument types
2168  proto_info));
2169 
2170  return AddFunDecl(
2171  CompilerType(m_ast_source.m_ast_context, generic_function_type), true);
2172 }
2173 
2174 clang::NamedDecl *
2176  if (ClangUtil::IsClangType(clang_type)) {
2177  QualType qual_type = ClangUtil::GetQualType(clang_type);
2178 
2179  if (const TypedefType *typedef_type =
2180  llvm::dyn_cast<TypedefType>(qual_type)) {
2181  TypedefNameDecl *typedef_name_decl = typedef_type->getDecl();
2182 
2183  m_decls.push_back(typedef_name_decl);
2184 
2185  return (NamedDecl *)typedef_name_decl;
2186  } else if (const TagType *tag_type = qual_type->getAs<TagType>()) {
2187  TagDecl *tag_decl = tag_type->getDecl();
2188 
2189  m_decls.push_back(tag_decl);
2190 
2191  return tag_decl;
2192  } else if (const ObjCObjectType *objc_object_type =
2193  qual_type->getAs<ObjCObjectType>()) {
2194  ObjCInterfaceDecl *interface_decl = objc_object_type->getInterface();
2195 
2196  m_decls.push_back((NamedDecl *)interface_decl);
2197 
2198  return (NamedDecl *)interface_decl;
2199  }
2200  }
2201  return NULL;
2202 }
2203 
2204 void NameSearchContext::AddLookupResult(clang::DeclContextLookupResult result) {
2205  for (clang::NamedDecl *decl : result)
2206  m_decls.push_back(decl);
2207 }
2208 
2209 void NameSearchContext::AddNamedDecl(clang::NamedDecl *decl) {
2210  m_decls.push_back(decl);
2211 }
void Flush() override
Flush the stream.
static clang::ASTContext * DeclContextGetClangASTContext(const CompilerDeclContext &dc)
llvm::DenseMap< const CXXRecordDecl *, CharUnits > BaseOffsetMap
lldb::TypeSP GetTypeAtIndex(uint32_t idx)
Definition: TypeList.cpp:66
void SetLookupsEnabled(bool lookups_enabled)
Defines a list of symbol context objects.
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:224
const clang::DeclarationName & m_decl_name
The name being looked for.
#define lldbassert(x)
Definition: LLDBAssert.h:15
Provider for named objects defined in the debug info for Clang.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
clang::ASTContext * getASTContext()
static bool FindObjCPropertyAndIvarDeclsWithOrigin(unsigned int current_id, NameSearchContext &context, ClangASTSource &source, DeclFromUser< const ObjCInterfaceDecl > &origin_iface_decl)
const char * GetCString()
Definition: ASTDumper.cpp:76
TaggedASTType< 1 > TypeFromUser
Definition: TaggedASTType.h:40
virtual void FindExternalVisibleDecls(NameSearchContext &context)
The worker function for FindExternalVisibleDeclsByName.
void * opaque_compiler_type_t
Definition: lldb-types.h:90
DeclFromParser(D *_decl)
"lldb/Expression/ClangASTSource.h" Container for all objects relevant to a single name lookup ...
bool ExtractBaseOffsets(const ASTRecordLayout &record_layout, DeclFromUser< const CXXRecordDecl > &record, BaseOffsetMap &base_offsets)
bool GetCompleteDecl(clang::Decl *decl)
void ToLog(Log *log, const char *prefix)
Definition: ASTDumper.cpp:80
void CompleteNamespaceMap(ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name, ClangASTImporter::NamespaceMapSP &parent_map) const override
Look up the modules containing a given namespace and put the appropriate entries in the namespace map...
static bool ImportOffsetMap(llvm::DenseMap< const D *, O > &destination_map, llvm::DenseMap< const D *, O > &source_map, ClangASTSource &source)
bool IgnoreName(const ConstString name, bool ignore_all_dollar_names)
Returns true if a name should be ignored by name lookup.
static ClangASTContext * GetASTContext(clang::ASTContext *ast_ctx)
clang::Decl * CopyDecl(clang::Decl *src_decl)
Copies a single Decl into the parser&#39;s AST context.
lldb::ClangASTImporterSP m_ast_importer_sp
The target&#39;s AST importer.
clang::NamespaceDecl * AddNamespace(NameSearchContext &context, ClangASTImporter::NamespaceMapSP &namespace_decls)
uint32_t GetSize() const
Definition: TypeList.cpp:60
clang::ExternalASTMerger & GetMergerUnchecked()
Returns m_merger_up.
uint32_t GetSize() const
Get accessor for a symbol context list size.
Function * function
The Function for a given query.
std::set< const char * > m_active_lookups
virtual CompilerDeclContext FindNamespace(ConstString name, const CompilerDeclContext *parent_decl_ctx)
~ClangASTSource() override
Destructor.
lldb::ModuleSP GetModuleAtIndexUnlocked(size_t idx) const
Get the module shared pointer for the module at index idx without acquiring the ModuleList mutex...
Definition: ModuleList.cpp:331
lldb::opaque_compiler_type_t GetOpaqueQualType() const
Definition: CompilerType.h:165
#define UINT32_MAX
Definition: lldb-defines.h:31
void AddLookupResult(clang::DeclContextLookupResult result)
Add Decls from the provided DeclContextLookupResult to the list of results.
const lldb::TargetSP m_target
The target to use in finding variables and types.
bool HasMerger()
Returns true if there is a merger.
struct lldb_private::NameSearchContext::@55 m_found
D * operator->() const
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
bool IsInvalid() const
A collection class for Module objects.
Definition: ModuleList.h:91
TypeSystem * GetTypeSystem() const
Definition: CompilerType.h:150
static bool IsOperator(const char *name, clang::OverloadedOperatorKind &op_kind)
llvm::SmallVectorImpl< clang::NamedDecl * > & m_decls
The list of declarations already constructed.
ConstString GetName() const
Definition: Function.cpp:598
std::set< const clang::Decl * > m_active_lexical_decls
std::shared_ptr< NamespaceMap > NamespaceMapSP
llvm::StringRef GetString() const
static bool CheckOverloadedOperatorKindParameterCount(bool is_method, clang::OverloadedOperatorKind op_kind, uint32_t num_params)
clang::NamedDecl * AddGenericFunDecl()
Create a FunDecl with the name being searched for and generic type (i.e.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:233
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
bool GetVerbose() const
Definition: Log.cpp:250
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
TD< D2 > DynCast(TD< D1 > source)
virtual clang::ExternalASTMerger::ImporterSource GetImporterSource()=0
Interface for ExternalASTMerger.
clang::NamedDecl * AddTypeDecl(const CompilerType &compiler_type)
Create a TypeDecl with the name being searched for and the provided type and register it in the right...
clang::ASTContext * m_ast_context
The AST context requests are coming in for.
CompilerDeclContext GetDeclContext()
Get the DeclContext for this function, if available.
Definition: Function.cpp:427
static clang::NamespaceDecl * DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc)
clang::NamedDecl * AddFunDecl(const CompilerType &type, bool extern_c=false)
Create a FunDecl with the name being searched for and the provided type and register it in the right ...
DeclFromUser< D > GetOrigin(ClangASTSource &source)
virtual uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches, std::vector< clang::NamedDecl *> &decls)=0
Look up the set of Decls that the DeclVendor currently knows about matching a given name...
clang::FileManager * m_file_manager
The file manager paired with the AST context.
void StartTranslationUnit(clang::ASTConsumer *Consumer) override
Called on entering a translation unit.
llvm::DenseMap< const FieldDecl *, uint64_t > FieldOffsetMap
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
bool FindExternalVisibleDeclsByName(const clang::DeclContext *DC, clang::DeclarationName Name) override
Look up all Decls that match a particular name.
TaggedASTDecl(D *_decl)
clang::QualType CopyTypeWithMerger(clang::ASTContext &src_context, clang::ExternalASTMerger &merger, clang::QualType type)
Copies a single Type to the target of the given ExternalASTMerger.
void InstallASTContext(clang::ASTContext &ast_context, clang::FileManager &file_manager, bool is_shared_context=false)
static bool DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl)
void SetImportInProgress(bool import_in_progress)
size_t GetSize() const
Gets the size of the module list.
Definition: ModuleList.cpp:611
A uniqued constant string class.
Definition: ConstString.h:38
void CompleteType(clang::TagDecl *Tag) override
Complete a TagDecl.
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:247
std::unique_ptr< clang::ExternalASTMerger > m_merger_up
The ExternalASTMerger for this parse.
clang::NamedDecl * AddVarDecl(const CompilerType &type)
Create a VarDecl with the name being searched for and the provided type and register it in the right ...
Non-standardized C, such as K&R.
bool layoutRecordType(const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment, llvm::DenseMap< const clang::FieldDecl *, uint64_t > &FieldOffsets, llvm::DenseMap< const clang::CXXRecordDecl *, clang::CharUnits > &BaseOffsets, llvm::DenseMap< const clang::CXXRecordDecl *, clang::CharUnits > &VirtualBaseOffsets) override
Specify the layout of the contents of a RecordDecl.
void FindObjCMethodDecls(NameSearchContext &context)
Find all Objective-C methods matching a given selector.
CompilerType GuardedCopyType(const CompilerType &src_type)
A wrapper for ClangASTContext::CopyType that sets a flag that indicates that we should not respond to...
void FindObjCPropertyAndIvarDecls(NameSearchContext &context)
Find all Objective-C properties and ivars with a given name.
bool IsValid() const
static clang::ObjCMethodDecl * DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc)
#define LIBLLDB_LOG_EXPRESSIONS
Definition: Logging.h:22
std::recursive_mutex & GetMutex() const
Definition: ModuleList.h:214
DeclFromUser(D *_decl)
void FindExternalLexicalDecls(const clang::DeclContext *DC, llvm::function_ref< bool(clang::Decl::Kind)> IsKindWeWant, llvm::SmallVectorImpl< clang::Decl *> &Decls) override
Enumerate all Decls in a given lexical context.
ClangASTImporter::NamespaceMapSP m_namespace_map
The mapping of all namespaces found for this request back to their modules.
static clang::QualType GetQualType(const CompilerType &ct)
Definition: ClangUtil.cpp:27
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
size_t FindTypes(Module *search_first, ConstString name, bool name_is_fully_qualified, size_t max_matches, llvm::DenseSet< SymbolFile *> &searched_symbol_files, TypeList &types) const
Find types by name.
Definition: ModuleList.cpp:536
DeclFromParser< D > Import(ClangASTSource &source)
clang::ObjCInterfaceDecl * GetCompleteObjCInterface(const clang::ObjCInterfaceDecl *interface_decl)
Look for the complete version of an Objective-C interface, and return it if found.
bool FindObjCMethodDeclsWithOrigin(unsigned int current_id, NameSearchContext &context, clang::ObjCInterfaceDecl *original_interface_decl, const char *log_info)
bool ResolveDeclOrigin(const clang::Decl *decl, clang::Decl **original_decl, clang::ASTContext **original_ctx)
Determined the origin of a single Decl, if it can be found.
const clang::DeclContext * m_decl_context
The DeclContext to put declarations into.
void AddNamedDecl(clang::NamedDecl *decl)
Add a NamedDecl to the list of results.
clang::ExternalASTMerger & GetMergerUnchecked()
static bool IsClangType(const CompilerType &ct)
Definition: ClangUtil.cpp:17