LLDB mainline
ClangASTSource.cpp
Go to the documentation of this file.
1//===-- ClangASTSource.cpp ------------------------------------------------===//
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 "ClangDeclVendor.h"
13
14#include "lldb/Core/Module.h"
20#include "lldb/Target/Target.h"
22#include "lldb/Utility/Log.h"
23#include "clang/AST/ASTContext.h"
24#include "clang/Basic/SourceManager.h"
25
29
30#include <memory>
31#include <vector>
32
33using namespace clang;
34using namespace lldb_private;
35
36// Scoped class that will remove an active lexical decl from the set when it
37// goes out of scope.
38namespace {
39class ScopedLexicalDeclEraser {
40public:
41 ScopedLexicalDeclEraser(std::set<const clang::Decl *> &decls,
42 const clang::Decl *decl)
43 : m_active_lexical_decls(decls), m_decl(decl) {}
44
45 ~ScopedLexicalDeclEraser() { m_active_lexical_decls.erase(m_decl); }
46
47private:
48 std::set<const clang::Decl *> &m_active_lexical_decls;
49 const clang::Decl *m_decl;
50};
51}
52
54 const lldb::TargetSP &target,
55 const std::shared_ptr<ClangASTImporter> &importer)
56 : m_lookups_enabled(false), m_target(target), m_ast_context(nullptr),
57 m_ast_importer_sp(importer), m_active_lexical_decls(),
58 m_active_lookups() {
59 assert(m_ast_importer_sp && "No ClangASTImporter passed to ClangASTSource?");
60}
61
63 m_ast_context = &clang_ast_context.getASTContext();
64 m_clang_ast_context = &clang_ast_context;
65 m_file_manager = &m_ast_context->getSourceManager().getFileManager();
66 m_ast_importer_sp->InstallMapCompleter(m_ast_context, *this);
67}
68
70 m_ast_importer_sp->ForgetDestination(m_ast_context);
71
72 if (!m_target)
73 return;
74
75 // Unregister the current ASTContext as a source for all scratch
76 // ASTContexts in the ClangASTImporter. Without this the scratch AST might
77 // query the deleted ASTContext for additional type information.
78 // We unregister from *all* scratch ASTContexts in case a type got exported
79 // to a scratch AST that isn't the best fitting scratch ASTContext.
82
83 if (!scratch_ts_sp)
84 return;
85
86 ScratchTypeSystemClang *default_scratch_ast =
87 llvm::cast<ScratchTypeSystemClang>(scratch_ts_sp.get());
88 // Unregister from the default scratch AST (and all sub-ASTs).
89 default_scratch_ast->ForgetSource(m_ast_context, *m_ast_importer_sp);
90}
91
92void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) {
93 if (!m_ast_context)
94 return;
95
96 m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage();
97 m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage();
98}
99
100// The core lookup interface.
102 const DeclContext *decl_ctx, DeclarationName clang_decl_name) {
103 if (!m_ast_context) {
104 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
105 return false;
106 }
107
108 std::string decl_name(clang_decl_name.getAsString());
109
110 switch (clang_decl_name.getNameKind()) {
111 // Normal identifiers.
112 case DeclarationName::Identifier: {
113 clang::IdentifierInfo *identifier_info =
114 clang_decl_name.getAsIdentifierInfo();
115
116 if (!identifier_info || identifier_info->getBuiltinID() != 0) {
117 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
118 return false;
119 }
120 } break;
121
122 // Operator names.
123 case DeclarationName::CXXOperatorName:
124 case DeclarationName::CXXLiteralOperatorName:
125 break;
126
127 // Using directives found in this context.
128 // Tell Sema we didn't find any or we'll end up getting asked a *lot*.
129 case DeclarationName::CXXUsingDirective:
130 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
131 return false;
132
133 case DeclarationName::ObjCZeroArgSelector:
134 case DeclarationName::ObjCOneArgSelector:
135 case DeclarationName::ObjCMultiArgSelector: {
136 llvm::SmallVector<NamedDecl *, 1> method_decls;
137
138 NameSearchContext method_search_context(*m_clang_ast_context, method_decls,
139 clang_decl_name, decl_ctx);
140
141 FindObjCMethodDecls(method_search_context);
142
143 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, method_decls);
144 return (method_decls.size() > 0);
145 }
146 // These aren't possible in the global context.
147 case DeclarationName::CXXConstructorName:
148 case DeclarationName::CXXDestructorName:
149 case DeclarationName::CXXConversionFunctionName:
150 case DeclarationName::CXXDeductionGuideName:
151 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
152 return false;
153 }
154
155 if (!GetLookupsEnabled()) {
156 // Wait until we see a '$' at the start of a name before we start doing any
157 // lookups so we can avoid lookup up all of the builtin types.
158 if (!decl_name.empty() && decl_name[0] == '$') {
159 SetLookupsEnabled(true);
160 } else {
161 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
162 return false;
163 }
164 }
165
166 ConstString const_decl_name(decl_name.c_str());
167
168 const char *uniqued_const_decl_name = const_decl_name.GetCString();
169 if (m_active_lookups.find(uniqued_const_decl_name) !=
170 m_active_lookups.end()) {
171 // We are currently looking up this name...
172 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
173 return false;
174 }
175 m_active_lookups.insert(uniqued_const_decl_name);
176 llvm::SmallVector<NamedDecl *, 4> name_decls;
177 NameSearchContext name_search_context(*m_clang_ast_context, name_decls,
178 clang_decl_name, decl_ctx);
179 FindExternalVisibleDecls(name_search_context);
180 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, name_decls);
181 m_active_lookups.erase(uniqued_const_decl_name);
182 return (name_decls.size() != 0);
183}
184
185TagDecl *ClangASTSource::FindCompleteType(const TagDecl *decl) {
187
188 if (const NamespaceDecl *namespace_context =
189 dyn_cast<NamespaceDecl>(decl->getDeclContext())) {
191 m_ast_importer_sp->GetNamespaceMap(namespace_context);
192
193 if (!namespace_map)
194 return nullptr;
195
196 LLDB_LOGV(log, " CTD Inspecting namespace map{0:x} ({1} entries)",
197 namespace_map.get(), namespace_map->size());
198
199 for (const ClangASTImporter::NamespaceMapItem &item : *namespace_map) {
200 LLDB_LOG(log, " CTD Searching namespace {0} in module {1}",
201 item.second.GetName(), item.first->GetFileSpec().GetFilename());
202
203 ConstString name(decl->getName());
204
205 // Create a type matcher using the CompilerDeclContext for the namespace
206 // as the context (item.second) and search for the name inside of this
207 // context.
208 TypeQuery query(item.second, name);
209 TypeResults results;
210 item.first->FindTypes(query, results);
211
212 for (const lldb::TypeSP &type_sp : results.GetTypeMap().Types()) {
213 CompilerType clang_type(type_sp->GetFullCompilerType());
214
215 if (!ClangUtil::IsClangType(clang_type))
216 continue;
217
218 const TagType *tag_type =
219 ClangUtil::GetQualType(clang_type)->getAs<TagType>();
220
221 if (!tag_type)
222 continue;
223
224 TagDecl *candidate_tag_decl =
225 const_cast<TagDecl *>(tag_type->getDecl());
226
228 &candidate_tag_decl->getASTContext(), candidate_tag_decl))
229 return candidate_tag_decl;
230 }
231 }
232 } else {
233 const ModuleList &module_list = m_target->GetImages();
234 // Create a type matcher using a CompilerDecl. Each TypeSystem class knows
235 // how to fill out a CompilerContext array using a CompilerDecl.
236 TypeQuery query(CompilerDecl(m_clang_ast_context, (void *)decl));
237 TypeResults results;
238 module_list.FindTypes(nullptr, query, results);
239 for (const lldb::TypeSP &type_sp : results.GetTypeMap().Types()) {
240
241 CompilerType clang_type(type_sp->GetFullCompilerType());
242
243 if (!ClangUtil::IsClangType(clang_type))
244 continue;
245
246 const TagType *tag_type =
247 ClangUtil::GetQualType(clang_type)->getAs<TagType>();
248
249 if (!tag_type)
250 continue;
251
252 TagDecl *candidate_tag_decl = const_cast<TagDecl *>(tag_type->getDecl());
253
254 if (TypeSystemClang::GetCompleteDecl(&candidate_tag_decl->getASTContext(),
255 candidate_tag_decl))
256 return candidate_tag_decl;
257 }
258 }
259 return nullptr;
260}
261
262void ClangASTSource::CompleteType(TagDecl *tag_decl) {
264
265 if (log) {
266 LLDB_LOG(log,
267 " CompleteTagDecl on (ASTContext*){0} Completing "
268 "(TagDecl*){1:x} named {2}",
270 tag_decl->getName());
271
272 LLDB_LOG(log, " CTD Before:\n{0}", ClangUtil::DumpDecl(tag_decl));
273 }
274
275 auto iter = m_active_lexical_decls.find(tag_decl);
276 if (iter != m_active_lexical_decls.end())
277 return;
278 m_active_lexical_decls.insert(tag_decl);
279 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl);
280
281 if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
282 // We couldn't complete the type. Maybe there's a definition somewhere
283 // else that can be completed.
284 if (TagDecl *alternate = FindCompleteType(tag_decl))
285 m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, alternate);
286 }
287
288 LLDB_LOG(log, " [CTD] After:\n{0}", ClangUtil::DumpDecl(tag_decl));
289}
290
291void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) {
293
294 LLDB_LOG(log,
295 " [CompleteObjCInterfaceDecl] on (ASTContext*){0:x} '{1}' "
296 "Completing an ObjCInterfaceDecl named {1}",
298 interface_decl->getName());
299 LLDB_LOG(log, " [COID] Before:\n{0}",
300 ClangUtil::DumpDecl(interface_decl));
301
302 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl);
303
304 if (original.Valid()) {
305 if (ObjCInterfaceDecl *original_iface_decl =
306 dyn_cast<ObjCInterfaceDecl>(original.decl)) {
307 ObjCInterfaceDecl *complete_iface_decl =
308 GetCompleteObjCInterface(original_iface_decl);
309
310 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) {
311 m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl);
312 }
313 }
314 }
315
316 m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl);
317
318 if (interface_decl->getSuperClass() &&
319 interface_decl->getSuperClass() != interface_decl)
320 CompleteType(interface_decl->getSuperClass());
321
322 LLDB_LOG(log, " [COID] After:");
323 LLDB_LOG(log, " [COID] {0}", ClangUtil::DumpDecl(interface_decl));
324}
325
327 const clang::ObjCInterfaceDecl *interface_decl) {
328 lldb::ProcessSP process(m_target->GetProcessSP());
329
330 if (!process)
331 return nullptr;
332
333 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
334
335 if (!language_runtime)
336 return nullptr;
337
338 ConstString class_name(interface_decl->getNameAsString().c_str());
339
340 lldb::TypeSP complete_type_sp(
341 language_runtime->LookupInCompleteClassCache(class_name));
342
343 if (!complete_type_sp)
344 return nullptr;
345
346 TypeFromUser complete_type =
347 TypeFromUser(complete_type_sp->GetFullCompilerType());
348 lldb::opaque_compiler_type_t complete_opaque_type =
349 complete_type.GetOpaqueQualType();
350
351 if (!complete_opaque_type)
352 return nullptr;
353
354 const clang::Type *complete_clang_type =
355 QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr();
356 const ObjCInterfaceType *complete_interface_type =
357 dyn_cast<ObjCInterfaceType>(complete_clang_type);
358
359 if (!complete_interface_type)
360 return nullptr;
361
362 ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl());
363
364 return complete_iface_decl;
365}
366
368 const DeclContext *decl_context,
369 llvm::function_ref<bool(Decl::Kind)> predicate,
371
373
374 const Decl *context_decl = dyn_cast<Decl>(decl_context);
375
376 if (!context_decl)
377 return;
378
379 auto iter = m_active_lexical_decls.find(context_decl);
380 if (iter != m_active_lexical_decls.end())
381 return;
382 m_active_lexical_decls.insert(context_decl);
383 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl);
384
385 if (log) {
386 if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl))
387 LLDB_LOG(log,
388 "FindExternalLexicalDecls on (ASTContext*){0:x} '{1}' in "
389 "'{2}' ({3}Decl*){4}",
391 context_named_decl->getNameAsString().c_str(),
392 context_decl->getDeclKindName(),
393 static_cast<const void *>(context_decl));
394 else if (context_decl)
395 LLDB_LOG(log,
396 "FindExternalLexicalDecls on (ASTContext*){0:x} '{1}' in "
397 "({2}Decl*){3}",
399 context_decl->getDeclKindName(),
400 static_cast<const void *>(context_decl));
401 else
402 LLDB_LOG(log,
403 "FindExternalLexicalDecls on (ASTContext*){0:x} '{1}' in a "
404 "NULL context",
406 }
407
408 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(context_decl);
409
410 if (!original.Valid())
411 return;
412
413 LLDB_LOG(log, " FELD Original decl (ASTContext*){0:x} (Decl*){1:x}:\n{2}",
414 static_cast<void *>(original.ctx),
415 static_cast<void *>(original.decl),
416 ClangUtil::DumpDecl(original.decl));
417
418 if (ObjCInterfaceDecl *original_iface_decl =
419 dyn_cast<ObjCInterfaceDecl>(original.decl)) {
420 ObjCInterfaceDecl *complete_iface_decl =
421 GetCompleteObjCInterface(original_iface_decl);
422
423 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) {
424 original.decl = complete_iface_decl;
425 original.ctx = &complete_iface_decl->getASTContext();
426
427 m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl);
428 }
429 }
430
431 if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original.decl)) {
432 ExternalASTSource *external_source = original.ctx->getExternalSource();
433
434 if (external_source)
435 external_source->CompleteType(original_tag_decl);
436 }
437
438 const DeclContext *original_decl_context =
439 dyn_cast<DeclContext>(original.decl);
440
441 if (!original_decl_context)
442 return;
443
444 // Indicates whether we skipped any Decls of the original DeclContext.
445 bool SkippedDecls = false;
446 for (Decl *decl : original_decl_context->decls()) {
447 // The predicate function returns true if the passed declaration kind is
448 // the one we are looking for.
449 // See clang::ExternalASTSource::FindExternalLexicalDecls()
450 if (predicate(decl->getKind())) {
451 if (log) {
452 std::string ast_dump = ClangUtil::DumpDecl(decl);
453 if (const NamedDecl *context_named_decl =
454 dyn_cast<NamedDecl>(context_decl))
455 LLDB_LOG(log, " FELD Adding [to {0}Decl {1}] lexical {2}Decl {3}",
456 context_named_decl->getDeclKindName(),
457 context_named_decl->getName(), decl->getDeclKindName(),
458 ast_dump);
459 else
460 LLDB_LOG(log, " FELD Adding lexical {0}Decl {1}",
461 decl->getDeclKindName(), ast_dump);
462 }
463
464 Decl *copied_decl = CopyDecl(decl);
465
466 if (!copied_decl)
467 continue;
468
469 // FIXME: We should add the copied decl to the 'decls' list. This would
470 // add the copied Decl into the DeclContext and make sure that we
471 // correctly propagate that we added some Decls back to Clang.
472 // By leaving 'decls' empty we incorrectly return false from
473 // DeclContext::LoadLexicalDeclsFromExternalStorage which might cause
474 // lookup issues later on.
475 // We can't just add them for now as the ASTImporter already added the
476 // decl into the DeclContext and this would add it twice.
477
478 if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl)) {
479 QualType copied_field_type = copied_field->getType();
480
481 m_ast_importer_sp->RequireCompleteType(copied_field_type);
482 }
483 } else {
484 SkippedDecls = true;
485 }
486 }
487
488 // CopyDecl may build a lookup table which may set up ExternalLexicalStorage
489 // to false. However, since we skipped some of the external Decls we must
490 // set it back!
491 if (SkippedDecls) {
492 decl_context->setHasExternalLexicalStorage(true);
493 // This sets HasLazyExternalLexicalLookups to true. By setting this bit we
494 // ensure that the lookup table is rebuilt, which means the external source
495 // is consulted again when a clang::DeclContext::lookup is called.
496 const_cast<DeclContext *>(decl_context)->setMustBuildLookupTable();
497 }
498}
499
501 assert(m_ast_context);
502
503 const ConstString name(context.m_decl_name.getAsString().c_str());
504
506
507 if (log) {
508 if (!context.m_decl_context)
509 LLDB_LOG(log,
510 "ClangASTSource::FindExternalVisibleDecls on "
511 "(ASTContext*){0:x} '{1}' for '{2}' in a NULL DeclContext",
513 else if (const NamedDecl *context_named_decl =
514 dyn_cast<NamedDecl>(context.m_decl_context))
515 LLDB_LOG(log,
516 "ClangASTSource::FindExternalVisibleDecls on "
517 "(ASTContext*){0:x} '{1}' for '{2}' in '{3}'",
519 context_named_decl->getName());
520 else
521 LLDB_LOG(log,
522 "ClangASTSource::FindExternalVisibleDecls on "
523 "(ASTContext*){0:x} '{1}' for '{2}' in a '{3}'",
525 context.m_decl_context->getDeclKindName());
526 }
527
528 if (isa<NamespaceDecl>(context.m_decl_context)) {
529 LookupInNamespace(context);
530 } else if (isa<ObjCInterfaceDecl>(context.m_decl_context)) {
532 } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) {
533 // we shouldn't be getting FindExternalVisibleDecls calls for these
534 return;
535 } else {
536 CompilerDeclContext namespace_decl;
537
538 LLDB_LOG(log, " CAS::FEVD Searching the root namespace");
539
540 FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl);
541 }
542
543 if (!context.m_namespace_map->empty()) {
544 if (log && log->GetVerbose())
545 LLDB_LOG(log, " CAS::FEVD Registering namespace map {0:x} ({1} entries)",
546 context.m_namespace_map.get(), context.m_namespace_map->size());
547
548 NamespaceDecl *clang_namespace_decl =
549 AddNamespace(context, context.m_namespace_map);
550
551 if (clang_namespace_decl)
552 clang_namespace_decl->setHasExternalVisibleStorage();
553 }
554}
555
558}
559
561 bool ignore_all_dollar_names) {
562 static const ConstString id_name("id");
563 static const ConstString Class_name("Class");
564
565 if (m_ast_context->getLangOpts().ObjC)
566 if (name == id_name || name == Class_name)
567 return true;
568
569 StringRef name_string_ref = name.GetStringRef();
570
571 // The ClangASTSource is not responsible for finding $-names.
572 return name_string_ref.empty() ||
573 (ignore_all_dollar_names && name_string_ref.starts_with("$")) ||
574 name_string_ref.starts_with("_$");
575}
576
578 NameSearchContext &context, lldb::ModuleSP module_sp,
579 CompilerDeclContext &namespace_decl) {
580 assert(m_ast_context);
581
583
584 SymbolContextList sc_list;
585
586 const ConstString name(context.m_decl_name.getAsString().c_str());
587 if (IgnoreName(name, true))
588 return;
589
590 if (!m_target)
591 return;
592
593 FillNamespaceMap(context, module_sp, namespace_decl);
594
595 if (context.m_found_type)
596 return;
597
598 lldb::TypeSP type_sp;
599 TypeResults results;
600 if (module_sp && namespace_decl) {
601 // Match the name in the specified decl context.
602 TypeQuery query(namespace_decl, name, TypeQueryOptions::e_find_one);
603 module_sp->FindTypes(query, results);
604 type_sp = results.GetFirstType();
605 } else {
606 // Match the exact name of the type at the root level.
607 TypeQuery query(name.GetStringRef(), TypeQueryOptions::e_exact_match |
608 TypeQueryOptions::e_find_one);
609 m_target->GetImages().FindTypes(nullptr, query, results);
610 type_sp = results.GetFirstType();
611 }
612
613 if (type_sp) {
614 if (log) {
615 const char *name_string = type_sp->GetName().GetCString();
616
617 LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\": {1}", name,
618 (name_string ? name_string : "<anonymous>"));
619 }
620
621 CompilerType full_type = type_sp->GetFullCompilerType();
622
623 CompilerType copied_clang_type(GuardedCopyType(full_type));
624
625 if (!copied_clang_type) {
626 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type");
627 } else {
628
629 context.AddTypeDecl(copied_clang_type);
630
631 context.m_found_type = true;
632 }
633 }
634
635 if (!context.m_found_type) {
636 // Try the modules next.
637 FindDeclInModules(context, name);
638 }
639
640 if (!context.m_found_type && m_ast_context->getLangOpts().ObjC) {
641 FindDeclInObjCRuntime(context, name);
642 }
643}
644
646 NameSearchContext &context, lldb::ModuleSP module_sp,
647 const CompilerDeclContext &namespace_decl) {
648 const ConstString name(context.m_decl_name.getAsString().c_str());
649 if (IgnoreName(name, true))
650 return;
651
653
654 if (module_sp && namespace_decl) {
655 CompilerDeclContext found_namespace_decl;
656
657 if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) {
658 found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl);
659
660 if (found_namespace_decl) {
661 context.m_namespace_map->push_back(
662 std::pair<lldb::ModuleSP, CompilerDeclContext>(
663 module_sp, found_namespace_decl));
664
665 LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name,
666 module_sp->GetFileSpec().GetFilename());
667 }
668 }
669 return;
670 }
671
672 for (lldb::ModuleSP image : m_target->GetImages().Modules()) {
673 if (!image)
674 continue;
675
676 CompilerDeclContext found_namespace_decl;
677
678 SymbolFile *symbol_file = image->GetSymbolFile();
679
680 if (!symbol_file)
681 continue;
682
683 // If namespace_decl is not valid, 'FindNamespace' would look for
684 // any namespace called 'name' (ignoring parent contexts) and return
685 // the first one it finds. Thus if we're doing a qualified lookup only
686 // consider root namespaces. E.g., in an expression ::A::B::Foo, the
687 // lookup of ::A will result in a qualified lookup. Note, namespace
688 // disambiguation for function calls are handled separately in
689 // SearchFunctionsInSymbolContexts.
690 const bool find_root_namespaces =
691 context.m_decl_context &&
692 context.m_decl_context->shouldUseQualifiedLookup();
693 found_namespace_decl = symbol_file->FindNamespace(
694 name, namespace_decl, /* only root namespaces */ find_root_namespaces);
695
696 if (found_namespace_decl) {
697 context.m_namespace_map->push_back(
698 std::pair<lldb::ModuleSP, CompilerDeclContext>(image,
699 found_namespace_decl));
700
701 LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name,
702 image->GetFileSpec().GetFilename());
703 }
704 }
705}
706
708 NameSearchContext &context, ObjCInterfaceDecl *original_interface_decl,
709 const char *log_info) {
710 const DeclarationName &decl_name(context.m_decl_name);
711 clang::ASTContext *original_ctx = &original_interface_decl->getASTContext();
712
713 Selector original_selector;
714
715 if (decl_name.isObjCZeroArgSelector()) {
716 const IdentifierInfo *ident =
717 &original_ctx->Idents.get(decl_name.getAsString());
718 original_selector = original_ctx->Selectors.getSelector(0, &ident);
719 } else if (decl_name.isObjCOneArgSelector()) {
720 const std::string &decl_name_string = decl_name.getAsString();
721 std::string decl_name_string_without_colon(decl_name_string.c_str(),
722 decl_name_string.length() - 1);
723 const IdentifierInfo *ident =
724 &original_ctx->Idents.get(decl_name_string_without_colon);
725 original_selector = original_ctx->Selectors.getSelector(1, &ident);
726 } else {
727 SmallVector<const IdentifierInfo *, 4> idents;
728
729 clang::Selector sel = decl_name.getObjCSelector();
730
731 unsigned num_args = sel.getNumArgs();
732
733 for (unsigned i = 0; i != num_args; ++i) {
734 idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i)));
735 }
736
737 original_selector =
738 original_ctx->Selectors.getSelector(num_args, idents.data());
739 }
740
741 DeclarationName original_decl_name(original_selector);
742
743 llvm::SmallVector<NamedDecl *, 1> methods;
744
745 TypeSystemClang::GetCompleteDecl(original_ctx, original_interface_decl);
746
747 if (ObjCMethodDecl *instance_method_decl =
748 original_interface_decl->lookupInstanceMethod(original_selector)) {
749 methods.push_back(instance_method_decl);
750 } else if (ObjCMethodDecl *class_method_decl =
751 original_interface_decl->lookupClassMethod(
752 original_selector)) {
753 methods.push_back(class_method_decl);
754 }
755
756 if (methods.empty()) {
757 return false;
758 }
759
760 for (NamedDecl *named_decl : methods) {
761 if (!named_decl)
762 continue;
763
764 ObjCMethodDecl *result_method = dyn_cast<ObjCMethodDecl>(named_decl);
765
766 if (!result_method)
767 continue;
768
769 Decl *copied_decl = CopyDecl(result_method);
770
771 if (!copied_decl)
772 continue;
773
774 ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl);
775
776 if (!copied_method_decl)
777 continue;
778
780
781 LLDB_LOG(log, " CAS::FOMD found ({0}) {1}", log_info,
782 ClangUtil::DumpDecl(copied_method_decl));
783
784 context.AddNamedDecl(copied_method_decl);
785 }
786
787 return true;
788}
789
791 ConstString name) {
793
794 std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
796 if (!modules_decl_vendor)
797 return;
798
799 bool append = false;
800 uint32_t max_matches = 1;
801 std::vector<clang::NamedDecl *> decls;
802
803 if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
804 return;
805
806 LLDB_LOG(log, " CAS::FEVD Matching entity found for \"{0}\" in the modules",
807 name);
808
809 clang::NamedDecl *const decl_from_modules = decls[0];
810
811 if (llvm::isa<clang::TypeDecl>(decl_from_modules) ||
812 llvm::isa<clang::ObjCContainerDecl>(decl_from_modules) ||
813 llvm::isa<clang::EnumConstantDecl>(decl_from_modules)) {
814 clang::Decl *copied_decl = CopyDecl(decl_from_modules);
815 clang::NamedDecl *copied_named_decl =
816 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
817
818 if (!copied_named_decl) {
819 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the modules");
820
821 return;
822 }
823
824 context.AddNamedDecl(copied_named_decl);
825
826 context.m_found_type = true;
827 }
828}
829
831 ConstString name) {
833
834 lldb::ProcessSP process(m_target->GetProcessSP());
835
836 if (!process)
837 return;
838
839 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
840
841 if (!language_runtime)
842 return;
843
844 DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
845
846 if (!decl_vendor)
847 return;
848
849 bool append = false;
850 uint32_t max_matches = 1;
851 std::vector<clang::NamedDecl *> decls;
852
853 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
854 if (!clang_decl_vendor->FindDecls(name, append, max_matches, decls))
855 return;
856
857 LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\" in the runtime",
858 name);
859
860 clang::Decl *copied_decl = CopyDecl(decls[0]);
861 clang::NamedDecl *copied_named_decl =
862 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
863
864 if (!copied_named_decl) {
865 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the runtime");
866
867 return;
868 }
869
870 context.AddNamedDecl(copied_named_decl);
871}
872
875
876 const DeclarationName &decl_name(context.m_decl_name);
877 const DeclContext *decl_ctx(context.m_decl_context);
878
879 const ObjCInterfaceDecl *interface_decl =
880 dyn_cast<ObjCInterfaceDecl>(decl_ctx);
881
882 if (!interface_decl)
883 return;
884
885 do {
886 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl);
887
888 if (!original.Valid())
889 break;
890
891 ObjCInterfaceDecl *original_interface_decl =
892 dyn_cast<ObjCInterfaceDecl>(original.decl);
893
894 if (FindObjCMethodDeclsWithOrigin(context, original_interface_decl,
895 "at origin"))
896 return; // found it, no need to look any further
897 } while (false);
898
899 StreamString ss;
900
901 if (decl_name.isObjCZeroArgSelector()) {
902 ss.Printf("%s", decl_name.getAsString().c_str());
903 } else if (decl_name.isObjCOneArgSelector()) {
904 ss.Printf("%s", decl_name.getAsString().c_str());
905 } else {
906 clang::Selector sel = decl_name.getObjCSelector();
907
908 for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) {
909 llvm::StringRef r = sel.getNameForSlot(i);
910 ss.Printf("%s:", r.str().c_str());
911 }
912 }
913 ss.Flush();
914
915 if (ss.GetString().contains("$__lldb"))
916 return; // we don't need any results
917
918 ConstString selector_name(ss.GetString());
919
920 LLDB_LOG(log,
921 "ClangASTSource::FindObjCMethodDecls on (ASTContext*){0:x} '{1}' "
922 "for selector [{2} {3}]",
924 interface_decl->getName(), selector_name);
925 SymbolContextList sc_list;
926
927 ModuleFunctionSearchOptions function_options;
928 function_options.include_symbols = false;
929 function_options.include_inlines = false;
930
931 std::string interface_name = interface_decl->getNameAsString();
932
933 do {
934 StreamString ms;
935 ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString());
936 ms.Flush();
937 ConstString instance_method_name(ms.GetString());
938
939 sc_list.Clear();
940 m_target->GetImages().FindFunctions(instance_method_name,
941 lldb::eFunctionNameTypeFull,
942 function_options, sc_list);
943
944 if (sc_list.GetSize())
945 break;
946
947 ms.Clear();
948 ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString());
949 ms.Flush();
950 ConstString class_method_name(ms.GetString());
951
952 sc_list.Clear();
953 m_target->GetImages().FindFunctions(class_method_name,
954 lldb::eFunctionNameTypeFull,
955 function_options, sc_list);
956
957 if (sc_list.GetSize())
958 break;
959
960 // Fall back and check for methods in categories. If we find methods this
961 // way, we need to check that they're actually in categories on the desired
962 // class.
963
964 SymbolContextList candidate_sc_list;
965
966 m_target->GetImages().FindFunctions(selector_name,
967 lldb::eFunctionNameTypeSelector,
968 function_options, candidate_sc_list);
969
970 for (const SymbolContext &candidate_sc : candidate_sc_list) {
971 if (!candidate_sc.function)
972 continue;
973
974 const char *candidate_name = candidate_sc.function->GetName().AsCString();
975
976 const char *cursor = candidate_name;
977
978 if (*cursor != '+' && *cursor != '-')
979 continue;
980
981 ++cursor;
982
983 if (*cursor != '[')
984 continue;
985
986 ++cursor;
987
988 size_t interface_len = interface_name.length();
989
990 if (strncmp(cursor, interface_name.c_str(), interface_len))
991 continue;
992
993 cursor += interface_len;
994
995 if (*cursor == ' ' || *cursor == '(')
996 sc_list.Append(candidate_sc);
997 }
998 } while (false);
999
1000 if (sc_list.GetSize()) {
1001 // We found a good function symbol. Use that.
1002
1003 for (const SymbolContext &sc : sc_list) {
1004 if (!sc.function)
1005 continue;
1006
1007 CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext();
1008 if (!function_decl_ctx)
1009 continue;
1010
1011 ObjCMethodDecl *method_decl =
1013
1014 if (!method_decl)
1015 continue;
1016
1017 ObjCInterfaceDecl *found_interface_decl =
1018 method_decl->getClassInterface();
1019
1020 if (!found_interface_decl)
1021 continue;
1022
1023 if (found_interface_decl->getName() == interface_decl->getName()) {
1024 Decl *copied_decl = CopyDecl(method_decl);
1025
1026 if (!copied_decl)
1027 continue;
1028
1029 ObjCMethodDecl *copied_method_decl =
1030 dyn_cast<ObjCMethodDecl>(copied_decl);
1031
1032 if (!copied_method_decl)
1033 continue;
1034
1035 LLDB_LOG(log, " CAS::FOMD found (in symbols)\n{0}",
1036 ClangUtil::DumpDecl(copied_method_decl));
1037
1038 context.AddNamedDecl(copied_method_decl);
1039 }
1040 }
1041
1042 return;
1043 }
1044
1045 // Try the debug information.
1046
1047 do {
1048 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(
1049 const_cast<ObjCInterfaceDecl *>(interface_decl));
1050
1051 if (!complete_interface_decl)
1052 break;
1053
1054 // We found the complete interface. The runtime never needs to be queried
1055 // in this scenario.
1056
1057 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
1058 complete_interface_decl);
1059
1060 if (complete_interface_decl == interface_decl)
1061 break; // already checked this one
1062
1063 LLDB_LOG(log,
1064 "CAS::FOPD trying origin "
1065 "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...",
1066 complete_interface_decl, &complete_iface_decl->getASTContext());
1067
1068 FindObjCMethodDeclsWithOrigin(context, complete_interface_decl,
1069 "in debug info");
1070
1071 return;
1072 } while (false);
1073
1074 do {
1075 // Check the modules only if the debug information didn't have a complete
1076 // interface.
1077
1078 if (std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
1080 ConstString interface_name(interface_decl->getNameAsString().c_str());
1081 bool append = false;
1082 uint32_t max_matches = 1;
1083 std::vector<clang::NamedDecl *> decls;
1084
1085 if (!modules_decl_vendor->FindDecls(interface_name, append, max_matches,
1086 decls))
1087 break;
1088
1089 ObjCInterfaceDecl *interface_decl_from_modules =
1090 dyn_cast<ObjCInterfaceDecl>(decls[0]);
1091
1092 if (!interface_decl_from_modules)
1093 break;
1094
1095 if (FindObjCMethodDeclsWithOrigin(context, interface_decl_from_modules,
1096 "in modules"))
1097 return;
1098 }
1099 } while (false);
1100
1101 do {
1102 // Check the runtime only if the debug information didn't have a complete
1103 // interface and the modules don't get us anywhere.
1104
1105 lldb::ProcessSP process(m_target->GetProcessSP());
1106
1107 if (!process)
1108 break;
1109
1110 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
1111
1112 if (!language_runtime)
1113 break;
1114
1115 DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
1116
1117 if (!decl_vendor)
1118 break;
1119
1120 ConstString interface_name(interface_decl->getNameAsString().c_str());
1121 bool append = false;
1122 uint32_t max_matches = 1;
1123 std::vector<clang::NamedDecl *> decls;
1124
1125 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
1126 if (!clang_decl_vendor->FindDecls(interface_name, append, max_matches,
1127 decls))
1128 break;
1129
1130 ObjCInterfaceDecl *runtime_interface_decl =
1131 dyn_cast<ObjCInterfaceDecl>(decls[0]);
1132
1133 if (!runtime_interface_decl)
1134 break;
1135
1136 FindObjCMethodDeclsWithOrigin(context, runtime_interface_decl,
1137 "in runtime");
1138 } while (false);
1139}
1140
1142 NameSearchContext &context,
1143 DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) {
1145
1146 if (origin_iface_decl.IsInvalid())
1147 return false;
1148
1149 std::string name_str = context.m_decl_name.getAsString();
1150 StringRef name(name_str);
1151 IdentifierInfo &name_identifier(
1152 origin_iface_decl->getASTContext().Idents.get(name));
1153
1154 DeclFromUser<ObjCPropertyDecl> origin_property_decl(
1155 origin_iface_decl->FindPropertyDeclaration(
1156 &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance));
1157
1158 bool found = false;
1159
1160 if (origin_property_decl.IsValid()) {
1161 DeclFromParser<ObjCPropertyDecl> parser_property_decl(
1162 origin_property_decl.Import(m_ast_context, *m_ast_importer_sp));
1163 if (parser_property_decl.IsValid()) {
1164 LLDB_LOG(log, " CAS::FOPD found\n{0}",
1165 ClangUtil::DumpDecl(parser_property_decl.decl));
1166
1167 context.AddNamedDecl(parser_property_decl.decl);
1168 found = true;
1169 }
1170 }
1171
1172 DeclFromUser<ObjCIvarDecl> origin_ivar_decl(
1173 origin_iface_decl->getIvarDecl(&name_identifier));
1174
1175 if (origin_ivar_decl.IsValid()) {
1176 DeclFromParser<ObjCIvarDecl> parser_ivar_decl(
1177 origin_ivar_decl.Import(m_ast_context, *m_ast_importer_sp));
1178 if (parser_ivar_decl.IsValid()) {
1179 LLDB_LOG(log, " CAS::FOPD found\n{0}",
1180 ClangUtil::DumpDecl(parser_ivar_decl.decl));
1181
1182 context.AddNamedDecl(parser_ivar_decl.decl);
1183 found = true;
1184 }
1185 }
1186
1187 return found;
1188}
1189
1192
1194 cast<ObjCInterfaceDecl>(context.m_decl_context));
1195 DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl(
1196 parser_iface_decl.GetOrigin(*m_ast_importer_sp));
1197
1198 ConstString class_name(parser_iface_decl->getNameAsString().c_str());
1199
1200 LLDB_LOG(log,
1201 "ClangASTSource::FindObjCPropertyAndIvarDecls on "
1202 "(ASTContext*){0:x} '{1}' for '{2}.{3}'",
1204 parser_iface_decl->getName(), context.m_decl_name.getAsString());
1205
1206 if (FindObjCPropertyAndIvarDeclsWithOrigin(context, origin_iface_decl))
1207 return;
1208
1209 LLDB_LOG(log,
1210 "CAS::FOPD couldn't find the property on origin "
1211 "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}, searching "
1212 "elsewhere...",
1213 origin_iface_decl.decl, &origin_iface_decl->getASTContext());
1214
1215 SymbolContext null_sc;
1216 TypeList type_list;
1217
1218 do {
1219 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(
1220 const_cast<ObjCInterfaceDecl *>(parser_iface_decl.decl));
1221
1222 if (!complete_interface_decl)
1223 break;
1224
1225 // We found the complete interface. The runtime never needs to be queried
1226 // in this scenario.
1227
1228 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
1229 complete_interface_decl);
1230
1231 if (complete_iface_decl.decl == origin_iface_decl.decl)
1232 break; // already checked this one
1233
1234 LLDB_LOG(log,
1235 "CAS::FOPD trying origin "
1236 "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...",
1237 complete_iface_decl.decl, &complete_iface_decl->getASTContext());
1238
1239 FindObjCPropertyAndIvarDeclsWithOrigin(context, complete_iface_decl);
1240
1241 return;
1242 } while (false);
1243
1244 do {
1245 // Check the modules only if the debug information didn't have a complete
1246 // interface.
1247
1248 std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
1250
1251 if (!modules_decl_vendor)
1252 break;
1253
1254 bool append = false;
1255 uint32_t max_matches = 1;
1256 std::vector<clang::NamedDecl *> decls;
1257
1258 if (!modules_decl_vendor->FindDecls(class_name, append, max_matches, decls))
1259 break;
1260
1261 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_modules(
1262 dyn_cast<ObjCInterfaceDecl>(decls[0]));
1263
1264 if (!interface_decl_from_modules.IsValid())
1265 break;
1266
1267 LLDB_LOG(log,
1268 "CAS::FOPD[{0:x}] trying module "
1269 "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...",
1270 interface_decl_from_modules.decl,
1271 &interface_decl_from_modules->getASTContext());
1272
1274 interface_decl_from_modules))
1275 return;
1276 } while (false);
1277
1278 do {
1279 // Check the runtime only if the debug information didn't have a complete
1280 // interface and nothing was in the modules.
1281
1282 lldb::ProcessSP process(m_target->GetProcessSP());
1283
1284 if (!process)
1285 return;
1286
1287 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
1288
1289 if (!language_runtime)
1290 return;
1291
1292 DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
1293
1294 if (!decl_vendor)
1295 break;
1296
1297 bool append = false;
1298 uint32_t max_matches = 1;
1299 std::vector<clang::NamedDecl *> decls;
1300
1301 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
1302 if (!clang_decl_vendor->FindDecls(class_name, append, max_matches, decls))
1303 break;
1304
1305 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime(
1306 dyn_cast<ObjCInterfaceDecl>(decls[0]));
1307
1308 if (!interface_decl_from_runtime.IsValid())
1309 break;
1310
1311 LLDB_LOG(log,
1312 "CAS::FOPD[{0:x}] trying runtime "
1313 "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...",
1314 interface_decl_from_runtime.decl,
1315 &interface_decl_from_runtime->getASTContext());
1316
1318 interface_decl_from_runtime))
1319 return;
1320 } while (false);
1321}
1322
1324 const NamespaceDecl *namespace_context =
1325 dyn_cast<NamespaceDecl>(context.m_decl_context);
1326
1328
1329 ClangASTImporter::NamespaceMapSP namespace_map =
1330 m_ast_importer_sp->GetNamespaceMap(namespace_context);
1331
1332 LLDB_LOGV(log, " CAS::FEVD Inspecting namespace map {0:x} ({1} entries)",
1333 namespace_map.get(), namespace_map->size());
1334
1335 if (!namespace_map)
1336 return;
1337
1338 for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
1339 e = namespace_map->end();
1340 i != e; ++i) {
1341 LLDB_LOG(log, " CAS::FEVD Searching namespace {0} in module {1}",
1342 i->second.GetName(), i->first->GetFileSpec().GetFilename());
1343
1344 FindExternalVisibleDecls(context, i->first, i->second);
1345 }
1346}
1347
1349 const RecordDecl *record, uint64_t &size, uint64_t &alignment,
1350 llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
1351 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
1352 &base_offsets,
1353 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
1354 &virtual_base_offsets) {
1355 return m_ast_importer_sp->importRecordLayoutFromOrigin(
1356 record, size, alignment, field_offsets, base_offsets,
1357 virtual_base_offsets);
1358}
1359
1361 ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
1362 ClangASTImporter::NamespaceMapSP &parent_map) const {
1363
1365
1366 if (log) {
1367 if (parent_map && parent_map->size())
1368 LLDB_LOG(log,
1369 "CompleteNamespaceMap on (ASTContext*){0:x} '{1}' Searching "
1370 "for namespace {2} in namespace {3}",
1372 parent_map->begin()->second.GetName());
1373 else
1374 LLDB_LOG(log,
1375 "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching "
1376 "for namespace {2}",
1378 }
1379
1380 if (parent_map) {
1381 for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
1382 e = parent_map->end();
1383 i != e; ++i) {
1384 CompilerDeclContext found_namespace_decl;
1385
1386 lldb::ModuleSP module_sp = i->first;
1387 CompilerDeclContext module_parent_namespace_decl = i->second;
1388
1389 SymbolFile *symbol_file = module_sp->GetSymbolFile();
1390
1391 if (!symbol_file)
1392 continue;
1393
1394 found_namespace_decl =
1395 symbol_file->FindNamespace(name, module_parent_namespace_decl);
1396
1397 if (!found_namespace_decl)
1398 continue;
1399
1400 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
1401 module_sp, found_namespace_decl));
1402
1403 LLDB_LOG(log, " CMN Found namespace {0} in module {1}", name,
1404 module_sp->GetFileSpec().GetFilename());
1405 }
1406 } else {
1407 CompilerDeclContext null_namespace_decl;
1408 for (lldb::ModuleSP image : m_target->GetImages().Modules()) {
1409 if (!image)
1410 continue;
1411
1412 CompilerDeclContext found_namespace_decl;
1413
1414 SymbolFile *symbol_file = image->GetSymbolFile();
1415
1416 if (!symbol_file)
1417 continue;
1418
1419 found_namespace_decl =
1420 symbol_file->FindNamespace(name, null_namespace_decl);
1421
1422 if (!found_namespace_decl)
1423 continue;
1424
1425 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
1426 image, found_namespace_decl));
1427
1428 LLDB_LOG(log, " CMN[{0}] Found namespace {0} in module {1}", name,
1429 image->GetFileSpec().GetFilename());
1430 }
1431 }
1432}
1433
1435 NameSearchContext &context,
1436 ClangASTImporter::NamespaceMapSP &namespace_decls) {
1437 if (!namespace_decls)
1438 return nullptr;
1439
1440 const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second;
1441
1442 clang::ASTContext *src_ast =
1444 if (!src_ast)
1445 return nullptr;
1446 clang::NamespaceDecl *src_namespace_decl =
1448
1449 if (!src_namespace_decl)
1450 return nullptr;
1451
1452 Decl *copied_decl = CopyDecl(src_namespace_decl);
1453
1454 if (!copied_decl)
1455 return nullptr;
1456
1457 NamespaceDecl *copied_namespace_decl = dyn_cast<NamespaceDecl>(copied_decl);
1458
1459 if (!copied_namespace_decl)
1460 return nullptr;
1461
1462 context.m_decls.push_back(copied_namespace_decl);
1463
1464 m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl,
1465 namespace_decls);
1466
1467 return dyn_cast<NamespaceDecl>(copied_decl);
1468}
1469
1470clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) {
1471 return m_ast_importer_sp->CopyDecl(m_ast_context, src_decl);
1472}
1473
1475 return m_ast_importer_sp->GetDeclOrigin(decl);
1476}
1477
1479 auto ts = src_type.GetTypeSystem();
1480 auto src_ast = ts.dyn_cast_or_null<TypeSystemClang>();
1481 if (!src_ast)
1482 return {};
1483
1484 QualType copied_qual_type = ClangUtil::GetQualType(
1485 m_ast_importer_sp->CopyType(*m_clang_ast_context, src_type));
1486
1487 if (copied_qual_type.getAsOpaquePtr() &&
1488 copied_qual_type->getCanonicalTypeInternal().isNull())
1489 // this shouldn't happen, but we're hardening because the AST importer
1490 // seems to be generating bad types on occasion.
1491 return {};
1492
1493 return m_clang_ast_context->GetType(copied_qual_type);
1494}
1495
1496std::shared_ptr<ClangModulesDeclVendor>
1498 auto persistent_vars = llvm::cast<ClangPersistentVariables>(
1499 m_target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC));
1500 return persistent_vars->GetClangModulesDeclVendor();
1501}
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:359
#define LLDB_LOGV(log,...)
Definition: Log.h:373
std::shared_ptr< NamespaceMap > NamespaceMapSP
std::pair< lldb::ModuleSP, CompilerDeclContext > NamespaceMapItem
bool FindExternalVisibleDeclsByName(const clang::DeclContext *DC, clang::DeclarationName Name) override
Look up all Decls that match a particular name.
std::set< const char * > m_active_lookups
void LookupInNamespace(NameSearchContext &context)
Performs lookup into a namespace.
void SetLookupsEnabled(bool lookups_enabled)
clang::TagDecl * FindCompleteType(const clang::TagDecl *decl)
clang::ASTContext * m_ast_context
The AST context requests are coming in for.
ClangASTSource(const lldb::TargetSP &target, const std::shared_ptr< ClangASTImporter > &importer)
Constructor.
std::set< const clang::Decl * > m_active_lexical_decls
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.
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.
clang::Decl * CopyDecl(clang::Decl *src_decl)
Copies a single Decl into the parser's AST context.
bool IgnoreName(const ConstString name, bool ignore_all_dollar_names)
Returns true if a name should be ignored by name lookup.
virtual void FindExternalVisibleDecls(NameSearchContext &context)
The worker function for FindExternalVisibleDeclsByName.
void FindObjCPropertyAndIvarDecls(NameSearchContext &context)
Find all Objective-C properties and ivars with a given name.
ClangASTImporter::DeclOrigin GetDeclOrigin(const clang::Decl *decl)
Determined the origin of a single Decl, if it can be found.
bool FindObjCPropertyAndIvarDeclsWithOrigin(NameSearchContext &context, DeclFromUser< const clang::ObjCInterfaceDecl > &origin_iface_decl)
bool FindObjCMethodDeclsWithOrigin(NameSearchContext &context, clang::ObjCInterfaceDecl *original_interface_decl, const char *log_info)
std::shared_ptr< ClangModulesDeclVendor > GetClangModulesDeclVendor()
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...
void FindDeclInObjCRuntime(NameSearchContext &context, ConstString name)
void CompleteType(clang::TagDecl *Tag) override
Complete a TagDecl.
~ClangASTSource() override
Destructor.
void FillNamespaceMap(NameSearchContext &context, lldb::ModuleSP module_sp, const CompilerDeclContext &namespace_decl)
Fills the namespace map of the given NameSearchContext.
CompilerType GuardedCopyType(const CompilerType &src_type)
A wrapper for TypeSystemClang::CopyType that sets a flag that indicates that we should not respond to...
void FindDeclInModules(NameSearchContext &context, ConstString name)
clang::NamespaceDecl * AddNamespace(NameSearchContext &context, ClangASTImporter::NamespaceMapSP &namespace_decls)
std::shared_ptr< ClangASTImporter > m_ast_importer_sp
The target's AST importer.
void InstallASTContext(TypeSystemClang &ast_context)
TypeSystemClang * m_clang_ast_context
The TypeSystemClang for m_ast_context.
void FindObjCMethodDecls(NameSearchContext &context)
Find all Objective-C methods matching a given selector.
const lldb::TargetSP m_target
The target to use in finding variables and types.
clang::ObjCInterfaceDecl * GetCompleteObjCInterface(const clang::ObjCInterfaceDecl *interface_decl)
Look for the complete version of an Objective-C interface, and return it if found.
void StartTranslationUnit(clang::ASTConsumer *Consumer) override
Called on entering a translation unit.
clang::FileManager * m_file_manager
The file manager paired with the AST context.
Represents a generic declaration context in a program.
Represents a generic declaration such as a function declaration.
Definition: CompilerDecl.h:28
std::shared_ptr< TypeSystemType > dyn_cast_or_null()
Return a shared_ptr<TypeSystemType> if dyn_cast succeeds.
Definition: CompilerType.h:65
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
TypeSystemSPWrapper GetTypeSystem() const
Accessors.
lldb::opaque_compiler_type_t GetOpaqueQualType() const
Definition: CompilerType.h:287
A uniqued constant string class.
Definition: ConstString.h:40
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:197
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
DeclFromUser< D > GetOrigin(ClangASTImporter &importer)
DeclFromParser< D > Import(clang::ASTContext *dest_ctx, ClangASTImporter &importer)
virtual DeclVendor * GetDeclVendor()
bool GetVerbose() const
Definition: Log.cpp:314
A collection class for Module objects.
Definition: ModuleList.h:103
void FindTypes(Module *search_first, const TypeQuery &query, lldb_private::TypeResults &results) const
Find types using a type-matching object that contains all search parameters.
Definition: ModuleList.cpp:587
lldb::TypeSP LookupInCompleteClassCache(ConstString &name)
static ObjCLanguageRuntime * Get(Process &process)
The TypeSystemClang instance used for the scratch ASTContext in a lldb::Target.
static lldb::TypeSystemClangSP GetForTarget(Target &target, std::optional< IsolatedASTKind > ast_kind=DefaultAST, bool create_on_demand=true)
Returns the scratch TypeSystemClang for the given target.
void ForgetSource(clang::ASTContext *src_ctx, ClangASTImporter &importer)
Unregisters the given ASTContext as a source from the scratch AST (and all sub-ASTs).
static const std::nullopt_t DefaultAST
Alias for requesting the default scratch TypeSystemClang in GetForTarget.
void Flush() override
Flush the stream.
llvm::StringRef GetString() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
Defines a list of symbol context objects.
uint32_t GetSize() const
Get accessor for a symbol context list size.
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
void Clear()
Clear the object's state.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:50
virtual CompilerDeclContext FindNamespace(ConstString name, const CompilerDeclContext &parent_decl_ctx, bool only_root_namespaces=false)
Finds a namespace of name name and whose parent context is parent_decl_ctx.
Definition: SymbolFile.h:341
TypeIterable Types() const
Definition: TypeMap.h:49
A class that contains all state required for type lookups.
Definition: Type.h:100
This class tracks the state and results of a TypeQuery.
Definition: Type.h:308
TypeMap & GetTypeMap()
Definition: Type.h:350
lldb::TypeSP GetFirstType() const
Definition: Type.h:349
A TypeSystem implementation based on Clang.
CompilerType GetType(clang::QualType qt)
Creates a CompilerType from the given QualType with the current TypeSystemClang instance as the Compi...
llvm::StringRef getDisplayName() const
Returns the display name of this TypeSystemClang that indicates what purpose it serves in LLDB.
static clang::ASTContext * DeclContextGetTypeSystemClang(const CompilerDeclContext &dc)
static clang::ObjCMethodDecl * DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc)
static clang::NamespaceDecl * DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc)
bool GetCompleteDecl(clang::Decl *decl)
clang::ASTContext & getASTContext() const
Returns the clang::ASTContext instance managed by this TypeSystemClang.
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
TaggedASTType< 1 > TypeFromUser
Definition: TaggedASTType.h:41
void * opaque_compiler_type_t
Definition: lldb-types.h:89
@ eLanguageTypeC
Non-standardized C, such as K&R.
std::shared_ptr< lldb_private::Type > TypeSP
Definition: lldb-forward.h:455
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:385
std::shared_ptr< lldb_private::TypeSystemClang > TypeSystemClangSP
Definition: lldb-forward.h:464
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:442
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:369
static clang::QualType GetQualType(const CompilerType &ct)
Definition: ClangUtil.cpp:36
static std::string DumpDecl(const clang::Decl *d)
Returns a textual representation of the given Decl's AST.
Definition: ClangUtil.cpp:68
static bool IsClangType(const CompilerType &ct)
Definition: ClangUtil.cpp:17
Options used by Module::FindFunctions.
Definition: Module.h:65
bool include_inlines
Include inlined functions.
Definition: Module.h:69
bool include_symbols
Include the symbol table.
Definition: Module.h:67
"lldb/Expression/ClangASTSource.h" Container for all objects relevant to a single name lookup
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...
const clang::DeclarationName m_decl_name
The name being looked for.
llvm::SmallVectorImpl< clang::NamedDecl * > & m_decls
The list of declarations already constructed.
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.
ClangASTImporter::NamespaceMapSP m_namespace_map
The mapping of all namespaces found for this request back to their modules.