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/AST/RecordLayout.h"
25#include "clang/Basic/SourceManager.h"
26
30
31#include <memory>
32#include <vector>
33
34using namespace clang;
35using namespace lldb_private;
36
37// Scoped class that will remove an active lexical decl from the set when it
38// goes out of scope.
39namespace {
40class ScopedLexicalDeclEraser {
41public:
42 ScopedLexicalDeclEraser(std::set<const clang::Decl *> &decls,
43 const clang::Decl *decl)
44 : m_active_lexical_decls(decls), m_decl(decl) {}
45
46 ~ScopedLexicalDeclEraser() { m_active_lexical_decls.erase(m_decl); }
47
48private:
49 std::set<const clang::Decl *> &m_active_lexical_decls;
50 const clang::Decl *m_decl;
51};
52}
53
55 const lldb::TargetSP &target,
56 const std::shared_ptr<ClangASTImporter> &importer)
57 : m_lookups_enabled(false), m_target(target), m_ast_context(nullptr),
58 m_ast_importer_sp(importer), m_active_lexical_decls(),
59 m_active_lookups() {
60 assert(m_ast_importer_sp && "No ClangASTImporter passed to ClangASTSource?");
61}
62
64 m_ast_context = &clang_ast_context.getASTContext();
65 m_clang_ast_context = &clang_ast_context;
66 m_file_manager = &m_ast_context->getSourceManager().getFileManager();
67 m_ast_importer_sp->InstallMapCompleter(m_ast_context, *this);
68}
69
71 m_ast_importer_sp->ForgetDestination(m_ast_context);
72
73 if (!m_target)
74 return;
75
76 // Unregister the current ASTContext as a source for all scratch
77 // ASTContexts in the ClangASTImporter. Without this the scratch AST might
78 // query the deleted ASTContext for additional type information.
79 // We unregister from *all* scratch ASTContexts in case a type got exported
80 // to a scratch AST that isn't the best fitting scratch ASTContext.
83
84 if (!scratch_ts_sp)
85 return;
86
87 ScratchTypeSystemClang *default_scratch_ast =
88 llvm::cast<ScratchTypeSystemClang>(scratch_ts_sp.get());
89 // Unregister from the default scratch AST (and all sub-ASTs).
90 default_scratch_ast->ForgetSource(m_ast_context, *m_ast_importer_sp);
91}
92
93void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) {
94 if (!m_ast_context)
95 return;
96
97 m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage();
98 m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage();
99}
100
101// The core lookup interface.
103 const DeclContext *decl_ctx, DeclarationName clang_decl_name) {
104 if (!m_ast_context) {
105 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
106 return false;
107 }
108
109 std::string decl_name(clang_decl_name.getAsString());
110
111 switch (clang_decl_name.getNameKind()) {
112 // Normal identifiers.
113 case DeclarationName::Identifier: {
114 clang::IdentifierInfo *identifier_info =
115 clang_decl_name.getAsIdentifierInfo();
116
117 if (!identifier_info || identifier_info->getBuiltinID() != 0) {
118 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
119 return false;
120 }
121 } break;
122
123 // Operator names.
124 case DeclarationName::CXXOperatorName:
125 case DeclarationName::CXXLiteralOperatorName:
126 break;
127
128 // Using directives found in this context.
129 // Tell Sema we didn't find any or we'll end up getting asked a *lot*.
130 case DeclarationName::CXXUsingDirective:
131 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
132 return false;
133
134 case DeclarationName::ObjCZeroArgSelector:
135 case DeclarationName::ObjCOneArgSelector:
136 case DeclarationName::ObjCMultiArgSelector: {
137 llvm::SmallVector<NamedDecl *, 1> method_decls;
138
139 NameSearchContext method_search_context(*m_clang_ast_context, method_decls,
140 clang_decl_name, decl_ctx);
141
142 FindObjCMethodDecls(method_search_context);
143
144 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, method_decls);
145 return (method_decls.size() > 0);
146 }
147 // These aren't possible in the global context.
148 case DeclarationName::CXXConstructorName:
149 case DeclarationName::CXXDestructorName:
150 case DeclarationName::CXXConversionFunctionName:
151 case DeclarationName::CXXDeductionGuideName:
152 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
153 return false;
154 }
155
156 if (!GetLookupsEnabled()) {
157 // Wait until we see a '$' at the start of a name before we start doing any
158 // lookups so we can avoid lookup up all of the builtin types.
159 if (!decl_name.empty() && decl_name[0] == '$') {
160 SetLookupsEnabled(true);
161 } else {
162 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
163 return false;
164 }
165 }
166
167 ConstString const_decl_name(decl_name.c_str());
168
169 const char *uniqued_const_decl_name = const_decl_name.GetCString();
170 if (m_active_lookups.find(uniqued_const_decl_name) !=
171 m_active_lookups.end()) {
172 // We are currently looking up this name...
173 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name);
174 return false;
175 }
176 m_active_lookups.insert(uniqued_const_decl_name);
177 llvm::SmallVector<NamedDecl *, 4> name_decls;
178 NameSearchContext name_search_context(*m_clang_ast_context, name_decls,
179 clang_decl_name, decl_ctx);
180 FindExternalVisibleDecls(name_search_context);
181 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, name_decls);
182 m_active_lookups.erase(uniqued_const_decl_name);
183 return (name_decls.size() != 0);
184}
185
186TagDecl *ClangASTSource::FindCompleteType(const TagDecl *decl) {
188
189 if (const NamespaceDecl *namespace_context =
190 dyn_cast<NamespaceDecl>(decl->getDeclContext())) {
192 m_ast_importer_sp->GetNamespaceMap(namespace_context);
193
194 if (!namespace_map)
195 return nullptr;
196
197 LLDB_LOGV(log, " CTD Inspecting namespace map{0} ({1} entries)",
198 namespace_map.get(), namespace_map->size());
199
200 for (const ClangASTImporter::NamespaceMapItem &item : *namespace_map) {
201 LLDB_LOG(log, " CTD Searching namespace {0} in module {1}",
202 item.second.GetName(), item.first->GetFileSpec().GetFilename());
203
204 TypeList types;
205
206 ConstString name(decl->getName());
207
208 item.first->FindTypesInNamespace(name, item.second, UINT32_MAX, types);
209
210 for (uint32_t ti = 0, te = types.GetSize(); ti != te; ++ti) {
211 lldb::TypeSP type = types.GetTypeAtIndex(ti);
212
213 if (!type)
214 continue;
215
216 CompilerType clang_type(type->GetFullCompilerType());
217
218 if (!ClangUtil::IsClangType(clang_type))
219 continue;
220
221 const TagType *tag_type =
222 ClangUtil::GetQualType(clang_type)->getAs<TagType>();
223
224 if (!tag_type)
225 continue;
226
227 TagDecl *candidate_tag_decl =
228 const_cast<TagDecl *>(tag_type->getDecl());
229
231 &candidate_tag_decl->getASTContext(), candidate_tag_decl))
232 return candidate_tag_decl;
233 }
234 }
235 } else {
236 TypeList types;
237
238 ConstString name(decl->getName());
239
240 const ModuleList &module_list = m_target->GetImages();
241
242 bool exact_match = false;
243 llvm::DenseSet<SymbolFile *> searched_symbol_files;
244 module_list.FindTypes(nullptr, name, exact_match, UINT32_MAX,
245 searched_symbol_files, types);
246
247 for (uint32_t ti = 0, te = types.GetSize(); ti != te; ++ti) {
248 lldb::TypeSP type = types.GetTypeAtIndex(ti);
249
250 if (!type)
251 continue;
252
253 CompilerType clang_type(type->GetFullCompilerType());
254
255 if (!ClangUtil::IsClangType(clang_type))
256 continue;
257
258 const TagType *tag_type =
259 ClangUtil::GetQualType(clang_type)->getAs<TagType>();
260
261 if (!tag_type)
262 continue;
263
264 TagDecl *candidate_tag_decl = const_cast<TagDecl *>(tag_type->getDecl());
265
266 // We have found a type by basename and we need to make sure the decl
267 // contexts are the same before we can try to complete this type with
268 // another
269 if (!TypeSystemClang::DeclsAreEquivalent(const_cast<TagDecl *>(decl),
270 candidate_tag_decl))
271 continue;
272
273 if (TypeSystemClang::GetCompleteDecl(&candidate_tag_decl->getASTContext(),
274 candidate_tag_decl))
275 return candidate_tag_decl;
276 }
277 }
278 return nullptr;
279}
280
281void ClangASTSource::CompleteType(TagDecl *tag_decl) {
283
284 if (log) {
285 LLDB_LOG(log,
286 " CompleteTagDecl on (ASTContext*){0} Completing "
287 "(TagDecl*){1} named {2}",
289 tag_decl->getName());
290
291 LLDB_LOG(log, " CTD Before:\n{0}", ClangUtil::DumpDecl(tag_decl));
292 }
293
294 auto iter = m_active_lexical_decls.find(tag_decl);
295 if (iter != m_active_lexical_decls.end())
296 return;
297 m_active_lexical_decls.insert(tag_decl);
298 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl);
299
300 if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
301 // We couldn't complete the type. Maybe there's a definition somewhere
302 // else that can be completed.
303 if (TagDecl *alternate = FindCompleteType(tag_decl))
304 m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, alternate);
305 }
306
307 LLDB_LOG(log, " [CTD] After:\n{0}", ClangUtil::DumpDecl(tag_decl));
308}
309
310void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) {
312
313 LLDB_LOG(log,
314 " [CompleteObjCInterfaceDecl] on (ASTContext*){0} '{1}' "
315 "Completing an ObjCInterfaceDecl named {1}",
317 interface_decl->getName());
318 LLDB_LOG(log, " [COID] Before:\n{0}",
319 ClangUtil::DumpDecl(interface_decl));
320
321 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl);
322
323 if (original.Valid()) {
324 if (ObjCInterfaceDecl *original_iface_decl =
325 dyn_cast<ObjCInterfaceDecl>(original.decl)) {
326 ObjCInterfaceDecl *complete_iface_decl =
327 GetCompleteObjCInterface(original_iface_decl);
328
329 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) {
330 m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl);
331 }
332 }
333 }
334
335 m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl);
336
337 if (interface_decl->getSuperClass() &&
338 interface_decl->getSuperClass() != interface_decl)
339 CompleteType(interface_decl->getSuperClass());
340
341 LLDB_LOG(log, " [COID] After:");
342 LLDB_LOG(log, " [COID] {0}", ClangUtil::DumpDecl(interface_decl));
343}
344
346 const clang::ObjCInterfaceDecl *interface_decl) {
347 lldb::ProcessSP process(m_target->GetProcessSP());
348
349 if (!process)
350 return nullptr;
351
352 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
353
354 if (!language_runtime)
355 return nullptr;
356
357 ConstString class_name(interface_decl->getNameAsString().c_str());
358
359 lldb::TypeSP complete_type_sp(
360 language_runtime->LookupInCompleteClassCache(class_name));
361
362 if (!complete_type_sp)
363 return nullptr;
364
365 TypeFromUser complete_type =
366 TypeFromUser(complete_type_sp->GetFullCompilerType());
367 lldb::opaque_compiler_type_t complete_opaque_type =
368 complete_type.GetOpaqueQualType();
369
370 if (!complete_opaque_type)
371 return nullptr;
372
373 const clang::Type *complete_clang_type =
374 QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr();
375 const ObjCInterfaceType *complete_interface_type =
376 dyn_cast<ObjCInterfaceType>(complete_clang_type);
377
378 if (!complete_interface_type)
379 return nullptr;
380
381 ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl());
382
383 return complete_iface_decl;
384}
385
387 const DeclContext *decl_context,
388 llvm::function_ref<bool(Decl::Kind)> predicate,
390
392
393 const Decl *context_decl = dyn_cast<Decl>(decl_context);
394
395 if (!context_decl)
396 return;
397
398 auto iter = m_active_lexical_decls.find(context_decl);
399 if (iter != m_active_lexical_decls.end())
400 return;
401 m_active_lexical_decls.insert(context_decl);
402 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl);
403
404 if (log) {
405 if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl))
406 LLDB_LOG(log,
407 "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in "
408 "'{2}' ({3}Decl*){4}",
410 context_named_decl->getNameAsString().c_str(),
411 context_decl->getDeclKindName(),
412 static_cast<const void *>(context_decl));
413 else if (context_decl)
414 LLDB_LOG(log,
415 "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in "
416 "({2}Decl*){3}",
418 context_decl->getDeclKindName(),
419 static_cast<const void *>(context_decl));
420 else
421 LLDB_LOG(log,
422 "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in a "
423 "NULL context",
425 }
426
427 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(context_decl);
428
429 if (!original.Valid())
430 return;
431
432 LLDB_LOG(log, " FELD Original decl {0} (Decl*){1:x}:\n{2}",
433 static_cast<void *>(original.ctx),
434 static_cast<void *>(original.decl),
435 ClangUtil::DumpDecl(original.decl));
436
437 if (ObjCInterfaceDecl *original_iface_decl =
438 dyn_cast<ObjCInterfaceDecl>(original.decl)) {
439 ObjCInterfaceDecl *complete_iface_decl =
440 GetCompleteObjCInterface(original_iface_decl);
441
442 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) {
443 original.decl = complete_iface_decl;
444 original.ctx = &complete_iface_decl->getASTContext();
445
446 m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl);
447 }
448 }
449
450 if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original.decl)) {
451 ExternalASTSource *external_source = original.ctx->getExternalSource();
452
453 if (external_source)
454 external_source->CompleteType(original_tag_decl);
455 }
456
457 const DeclContext *original_decl_context =
458 dyn_cast<DeclContext>(original.decl);
459
460 if (!original_decl_context)
461 return;
462
463 // Indicates whether we skipped any Decls of the original DeclContext.
464 bool SkippedDecls = false;
465 for (Decl *decl : original_decl_context->decls()) {
466 // The predicate function returns true if the passed declaration kind is
467 // the one we are looking for.
468 // See clang::ExternalASTSource::FindExternalLexicalDecls()
469 if (predicate(decl->getKind())) {
470 if (log) {
471 std::string ast_dump = ClangUtil::DumpDecl(decl);
472 if (const NamedDecl *context_named_decl =
473 dyn_cast<NamedDecl>(context_decl))
474 LLDB_LOG(log, " FELD Adding [to {0}Decl {1}] lexical {2}Decl {3}",
475 context_named_decl->getDeclKindName(),
476 context_named_decl->getName(), decl->getDeclKindName(),
477 ast_dump);
478 else
479 LLDB_LOG(log, " FELD Adding lexical {0}Decl {1}",
480 decl->getDeclKindName(), ast_dump);
481 }
482
483 Decl *copied_decl = CopyDecl(decl);
484
485 if (!copied_decl)
486 continue;
487
488 // FIXME: We should add the copied decl to the 'decls' list. This would
489 // add the copied Decl into the DeclContext and make sure that we
490 // correctly propagate that we added some Decls back to Clang.
491 // By leaving 'decls' empty we incorrectly return false from
492 // DeclContext::LoadLexicalDeclsFromExternalStorage which might cause
493 // lookup issues later on.
494 // We can't just add them for now as the ASTImporter already added the
495 // decl into the DeclContext and this would add it twice.
496
497 if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl)) {
498 QualType copied_field_type = copied_field->getType();
499
500 m_ast_importer_sp->RequireCompleteType(copied_field_type);
501 }
502 } else {
503 SkippedDecls = true;
504 }
505 }
506
507 // CopyDecl may build a lookup table which may set up ExternalLexicalStorage
508 // to false. However, since we skipped some of the external Decls we must
509 // set it back!
510 if (SkippedDecls) {
511 decl_context->setHasExternalLexicalStorage(true);
512 // This sets HasLazyExternalLexicalLookups to true. By setting this bit we
513 // ensure that the lookup table is rebuilt, which means the external source
514 // is consulted again when a clang::DeclContext::lookup is called.
515 const_cast<DeclContext *>(decl_context)->setMustBuildLookupTable();
516 }
517}
518
520 assert(m_ast_context);
521
522 const ConstString name(context.m_decl_name.getAsString().c_str());
523
525
526 if (log) {
527 if (!context.m_decl_context)
528 LLDB_LOG(log,
529 "ClangASTSource::FindExternalVisibleDecls on "
530 "(ASTContext*){0} '{1}' for '{2}' in a NULL DeclContext",
532 else if (const NamedDecl *context_named_decl =
533 dyn_cast<NamedDecl>(context.m_decl_context))
534 LLDB_LOG(log,
535 "ClangASTSource::FindExternalVisibleDecls on "
536 "(ASTContext*){0} '{1}' for '{2}' in '{3}'",
538 context_named_decl->getName());
539 else
540 LLDB_LOG(log,
541 "ClangASTSource::FindExternalVisibleDecls on "
542 "(ASTContext*){0} '{1}' for '{2}' in a '{3}'",
544 context.m_decl_context->getDeclKindName());
545 }
546
547 if (isa<NamespaceDecl>(context.m_decl_context)) {
548 LookupInNamespace(context);
549 } else if (isa<ObjCInterfaceDecl>(context.m_decl_context)) {
551 } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) {
552 // we shouldn't be getting FindExternalVisibleDecls calls for these
553 return;
554 } else {
555 CompilerDeclContext namespace_decl;
556
557 LLDB_LOG(log, " CAS::FEVD Searching the root namespace");
558
559 FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl);
560 }
561
562 if (!context.m_namespace_map->empty()) {
563 if (log && log->GetVerbose())
564 LLDB_LOG(log, " CAS::FEVD Registering namespace map {0} ({1} entries)",
565 context.m_namespace_map.get(), context.m_namespace_map->size());
566
567 NamespaceDecl *clang_namespace_decl =
568 AddNamespace(context, context.m_namespace_map);
569
570 if (clang_namespace_decl)
571 clang_namespace_decl->setHasExternalVisibleStorage();
572 }
573}
574
577}
578
580 bool ignore_all_dollar_names) {
581 static const ConstString id_name("id");
582 static const ConstString Class_name("Class");
583
584 if (m_ast_context->getLangOpts().ObjC)
585 if (name == id_name || name == Class_name)
586 return true;
587
588 StringRef name_string_ref = name.GetStringRef();
589
590 // The ClangASTSource is not responsible for finding $-names.
591 return name_string_ref.empty() ||
592 (ignore_all_dollar_names && name_string_ref.startswith("$")) ||
593 name_string_ref.startswith("_$");
594}
595
597 NameSearchContext &context, lldb::ModuleSP module_sp,
598 CompilerDeclContext &namespace_decl) {
599 assert(m_ast_context);
600
602
603 SymbolContextList sc_list;
604
605 const ConstString name(context.m_decl_name.getAsString().c_str());
606 if (IgnoreName(name, true))
607 return;
608
609 if (!m_target)
610 return;
611
612 FillNamespaceMap(context, module_sp, namespace_decl);
613
614 if (context.m_found_type)
615 return;
616
617 TypeList types;
618 const bool exact_match = true;
619 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
620 if (module_sp && namespace_decl)
621 module_sp->FindTypesInNamespace(name, namespace_decl, 1, types);
622 else {
623 m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1,
624 searched_symbol_files, types);
625 }
626
627 if (size_t num_types = types.GetSize()) {
628 for (size_t ti = 0; ti < num_types; ++ti) {
629 lldb::TypeSP type_sp = types.GetTypeAtIndex(ti);
630
631 if (log) {
632 const char *name_string = type_sp->GetName().GetCString();
633
634 LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\": {1}", name,
635 (name_string ? name_string : "<anonymous>"));
636 }
637
638 CompilerType full_type = type_sp->GetFullCompilerType();
639
640 CompilerType copied_clang_type(GuardedCopyType(full_type));
641
642 if (!copied_clang_type) {
643 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type");
644
645 continue;
646 }
647
648 context.AddTypeDecl(copied_clang_type);
649
650 context.m_found_type = true;
651 break;
652 }
653 }
654
655 if (!context.m_found_type) {
656 // Try the modules next.
657 FindDeclInModules(context, name);
658 }
659
660 if (!context.m_found_type) {
661 FindDeclInObjCRuntime(context, name);
662 }
663}
664
666 NameSearchContext &context, lldb::ModuleSP module_sp,
667 const CompilerDeclContext &namespace_decl) {
668 const ConstString name(context.m_decl_name.getAsString().c_str());
669 if (IgnoreName(name, true))
670 return;
671
673
674 if (module_sp && namespace_decl) {
675 CompilerDeclContext found_namespace_decl;
676
677 if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) {
678 found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl);
679
680 if (found_namespace_decl) {
681 context.m_namespace_map->push_back(
682 std::pair<lldb::ModuleSP, CompilerDeclContext>(
683 module_sp, found_namespace_decl));
684
685 LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name,
686 module_sp->GetFileSpec().GetFilename());
687 }
688 }
689 return;
690 }
691
692 for (lldb::ModuleSP image : m_target->GetImages().Modules()) {
693 if (!image)
694 continue;
695
696 CompilerDeclContext found_namespace_decl;
697
698 SymbolFile *symbol_file = image->GetSymbolFile();
699
700 if (!symbol_file)
701 continue;
702
703 // If namespace_decl is not valid, 'FindNamespace' would look for
704 // any namespace called 'name' (ignoring parent contexts) and return
705 // the first one it finds. Thus if we're doing a qualified lookup only
706 // consider root namespaces. E.g., in an expression ::A::B::Foo, the
707 // lookup of ::A will result in a qualified lookup. Note, namespace
708 // disambiguation for function calls are handled separately in
709 // SearchFunctionsInSymbolContexts.
710 const bool find_root_namespaces =
711 context.m_decl_context &&
712 context.m_decl_context->shouldUseQualifiedLookup();
713 found_namespace_decl = symbol_file->FindNamespace(
714 name, namespace_decl, /* only root namespaces */ find_root_namespaces);
715
716 if (found_namespace_decl) {
717 context.m_namespace_map->push_back(
718 std::pair<lldb::ModuleSP, CompilerDeclContext>(image,
719 found_namespace_decl));
720
721 LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name,
722 image->GetFileSpec().GetFilename());
723 }
724 }
725}
726
727template <class D> class TaggedASTDecl {
728public:
729 TaggedASTDecl() : decl(nullptr) {}
730 TaggedASTDecl(D *_decl) : decl(_decl) {}
731 bool IsValid() const { return (decl != nullptr); }
732 bool IsInvalid() const { return !IsValid(); }
733 D *operator->() const { return decl; }
735};
736
737template <class D2, template <class D> class TD, class D1>
738TD<D2> DynCast(TD<D1> source) {
739 return TD<D2>(dyn_cast<D2>(source.decl));
740}
741
742template <class D = Decl> class DeclFromParser;
743template <class D = Decl> class DeclFromUser;
744
745template <class D> class DeclFromParser : public TaggedASTDecl<D> {
746public:
748 DeclFromParser(D *_decl) : TaggedASTDecl<D>(_decl) {}
749
750 DeclFromUser<D> GetOrigin(ClangASTSource &source);
751};
752
753template <class D> class DeclFromUser : public TaggedASTDecl<D> {
754public:
756 DeclFromUser(D *_decl) : TaggedASTDecl<D>(_decl) {}
757
758 DeclFromParser<D> Import(ClangASTSource &source);
759};
760
761template <class D>
763 ClangASTImporter::DeclOrigin origin = source.GetDeclOrigin(this->decl);
764 if (!origin.Valid())
765 return DeclFromUser<D>();
766 return DeclFromUser<D>(dyn_cast<D>(origin.decl));
767}
768
769template <class D>
771 DeclFromParser<> parser_generic_decl(source.CopyDecl(this->decl));
772 if (parser_generic_decl.IsInvalid())
773 return DeclFromParser<D>();
774 return DeclFromParser<D>(dyn_cast<D>(parser_generic_decl.decl));
775}
776
778 NameSearchContext &context, ObjCInterfaceDecl *original_interface_decl,
779 const char *log_info) {
780 const DeclarationName &decl_name(context.m_decl_name);
781 clang::ASTContext *original_ctx = &original_interface_decl->getASTContext();
782
783 Selector original_selector;
784
785 if (decl_name.isObjCZeroArgSelector()) {
786 IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString());
787 original_selector = original_ctx->Selectors.getSelector(0, &ident);
788 } else if (decl_name.isObjCOneArgSelector()) {
789 const std::string &decl_name_string = decl_name.getAsString();
790 std::string decl_name_string_without_colon(decl_name_string.c_str(),
791 decl_name_string.length() - 1);
792 IdentifierInfo *ident =
793 &original_ctx->Idents.get(decl_name_string_without_colon);
794 original_selector = original_ctx->Selectors.getSelector(1, &ident);
795 } else {
796 SmallVector<IdentifierInfo *, 4> idents;
797
798 clang::Selector sel = decl_name.getObjCSelector();
799
800 unsigned num_args = sel.getNumArgs();
801
802 for (unsigned i = 0; i != num_args; ++i) {
803 idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i)));
804 }
805
806 original_selector =
807 original_ctx->Selectors.getSelector(num_args, idents.data());
808 }
809
810 DeclarationName original_decl_name(original_selector);
811
812 llvm::SmallVector<NamedDecl *, 1> methods;
813
814 TypeSystemClang::GetCompleteDecl(original_ctx, original_interface_decl);
815
816 if (ObjCMethodDecl *instance_method_decl =
817 original_interface_decl->lookupInstanceMethod(original_selector)) {
818 methods.push_back(instance_method_decl);
819 } else if (ObjCMethodDecl *class_method_decl =
820 original_interface_decl->lookupClassMethod(
821 original_selector)) {
822 methods.push_back(class_method_decl);
823 }
824
825 if (methods.empty()) {
826 return false;
827 }
828
829 for (NamedDecl *named_decl : methods) {
830 if (!named_decl)
831 continue;
832
833 ObjCMethodDecl *result_method = dyn_cast<ObjCMethodDecl>(named_decl);
834
835 if (!result_method)
836 continue;
837
838 Decl *copied_decl = CopyDecl(result_method);
839
840 if (!copied_decl)
841 continue;
842
843 ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl);
844
845 if (!copied_method_decl)
846 continue;
847
849
850 LLDB_LOG(log, " CAS::FOMD found ({0}) {1}", log_info,
851 ClangUtil::DumpDecl(copied_method_decl));
852
853 context.AddNamedDecl(copied_method_decl);
854 }
855
856 return true;
857}
858
860 ConstString name) {
862
863 std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
865 if (!modules_decl_vendor)
866 return;
867
868 bool append = false;
869 uint32_t max_matches = 1;
870 std::vector<clang::NamedDecl *> decls;
871
872 if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
873 return;
874
875 LLDB_LOG(log, " CAS::FEVD Matching entity found for \"{0}\" in the modules",
876 name);
877
878 clang::NamedDecl *const decl_from_modules = decls[0];
879
880 if (llvm::isa<clang::TypeDecl>(decl_from_modules) ||
881 llvm::isa<clang::ObjCContainerDecl>(decl_from_modules) ||
882 llvm::isa<clang::EnumConstantDecl>(decl_from_modules)) {
883 clang::Decl *copied_decl = CopyDecl(decl_from_modules);
884 clang::NamedDecl *copied_named_decl =
885 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
886
887 if (!copied_named_decl) {
888 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the modules");
889
890 return;
891 }
892
893 context.AddNamedDecl(copied_named_decl);
894
895 context.m_found_type = true;
896 }
897}
898
900 ConstString name) {
902
903 lldb::ProcessSP process(m_target->GetProcessSP());
904
905 if (!process)
906 return;
907
908 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
909
910 if (!language_runtime)
911 return;
912
913 DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
914
915 if (!decl_vendor)
916 return;
917
918 bool append = false;
919 uint32_t max_matches = 1;
920 std::vector<clang::NamedDecl *> decls;
921
922 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
923 if (!clang_decl_vendor->FindDecls(name, append, max_matches, decls))
924 return;
925
926 LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\" in the runtime",
927 name);
928
929 clang::Decl *copied_decl = CopyDecl(decls[0]);
930 clang::NamedDecl *copied_named_decl =
931 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
932
933 if (!copied_named_decl) {
934 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the runtime");
935
936 return;
937 }
938
939 context.AddNamedDecl(copied_named_decl);
940}
941
944
945 const DeclarationName &decl_name(context.m_decl_name);
946 const DeclContext *decl_ctx(context.m_decl_context);
947
948 const ObjCInterfaceDecl *interface_decl =
949 dyn_cast<ObjCInterfaceDecl>(decl_ctx);
950
951 if (!interface_decl)
952 return;
953
954 do {
955 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl);
956
957 if (!original.Valid())
958 break;
959
960 ObjCInterfaceDecl *original_interface_decl =
961 dyn_cast<ObjCInterfaceDecl>(original.decl);
962
963 if (FindObjCMethodDeclsWithOrigin(context, original_interface_decl,
964 "at origin"))
965 return; // found it, no need to look any further
966 } while (false);
967
968 StreamString ss;
969
970 if (decl_name.isObjCZeroArgSelector()) {
971 ss.Printf("%s", decl_name.getAsString().c_str());
972 } else if (decl_name.isObjCOneArgSelector()) {
973 ss.Printf("%s", decl_name.getAsString().c_str());
974 } else {
975 clang::Selector sel = decl_name.getObjCSelector();
976
977 for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) {
978 llvm::StringRef r = sel.getNameForSlot(i);
979 ss.Printf("%s:", r.str().c_str());
980 }
981 }
982 ss.Flush();
983
984 if (ss.GetString().contains("$__lldb"))
985 return; // we don't need any results
986
987 ConstString selector_name(ss.GetString());
988
989 LLDB_LOG(log,
990 "ClangASTSource::FindObjCMethodDecls on (ASTContext*){0} '{1}' "
991 "for selector [{2} {3}]",
993 interface_decl->getName(), selector_name);
994 SymbolContextList sc_list;
995
996 ModuleFunctionSearchOptions function_options;
997 function_options.include_symbols = false;
998 function_options.include_inlines = false;
999
1000 std::string interface_name = interface_decl->getNameAsString();
1001
1002 do {
1003 StreamString ms;
1004 ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString());
1005 ms.Flush();
1006 ConstString instance_method_name(ms.GetString());
1007
1008 sc_list.Clear();
1009 m_target->GetImages().FindFunctions(instance_method_name,
1010 lldb::eFunctionNameTypeFull,
1011 function_options, sc_list);
1012
1013 if (sc_list.GetSize())
1014 break;
1015
1016 ms.Clear();
1017 ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString());
1018 ms.Flush();
1019 ConstString class_method_name(ms.GetString());
1020
1021 sc_list.Clear();
1022 m_target->GetImages().FindFunctions(class_method_name,
1023 lldb::eFunctionNameTypeFull,
1024 function_options, sc_list);
1025
1026 if (sc_list.GetSize())
1027 break;
1028
1029 // Fall back and check for methods in categories. If we find methods this
1030 // way, we need to check that they're actually in categories on the desired
1031 // class.
1032
1033 SymbolContextList candidate_sc_list;
1034
1035 m_target->GetImages().FindFunctions(selector_name,
1036 lldb::eFunctionNameTypeSelector,
1037 function_options, candidate_sc_list);
1038
1039 for (const SymbolContext &candidate_sc : candidate_sc_list) {
1040 if (!candidate_sc.function)
1041 continue;
1042
1043 const char *candidate_name = candidate_sc.function->GetName().AsCString();
1044
1045 const char *cursor = candidate_name;
1046
1047 if (*cursor != '+' && *cursor != '-')
1048 continue;
1049
1050 ++cursor;
1051
1052 if (*cursor != '[')
1053 continue;
1054
1055 ++cursor;
1056
1057 size_t interface_len = interface_name.length();
1058
1059 if (strncmp(cursor, interface_name.c_str(), interface_len))
1060 continue;
1061
1062 cursor += interface_len;
1063
1064 if (*cursor == ' ' || *cursor == '(')
1065 sc_list.Append(candidate_sc);
1066 }
1067 } while (false);
1068
1069 if (sc_list.GetSize()) {
1070 // We found a good function symbol. Use that.
1071
1072 for (const SymbolContext &sc : sc_list) {
1073 if (!sc.function)
1074 continue;
1075
1076 CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext();
1077 if (!function_decl_ctx)
1078 continue;
1079
1080 ObjCMethodDecl *method_decl =
1082
1083 if (!method_decl)
1084 continue;
1085
1086 ObjCInterfaceDecl *found_interface_decl =
1087 method_decl->getClassInterface();
1088
1089 if (!found_interface_decl)
1090 continue;
1091
1092 if (found_interface_decl->getName() == interface_decl->getName()) {
1093 Decl *copied_decl = CopyDecl(method_decl);
1094
1095 if (!copied_decl)
1096 continue;
1097
1098 ObjCMethodDecl *copied_method_decl =
1099 dyn_cast<ObjCMethodDecl>(copied_decl);
1100
1101 if (!copied_method_decl)
1102 continue;
1103
1104 LLDB_LOG(log, " CAS::FOMD found (in symbols)\n{0}",
1105 ClangUtil::DumpDecl(copied_method_decl));
1106
1107 context.AddNamedDecl(copied_method_decl);
1108 }
1109 }
1110
1111 return;
1112 }
1113
1114 // Try the debug information.
1115
1116 do {
1117 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(
1118 const_cast<ObjCInterfaceDecl *>(interface_decl));
1119
1120 if (!complete_interface_decl)
1121 break;
1122
1123 // We found the complete interface. The runtime never needs to be queried
1124 // in this scenario.
1125
1126 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
1127 complete_interface_decl);
1128
1129 if (complete_interface_decl == interface_decl)
1130 break; // already checked this one
1131
1132 LLDB_LOG(log,
1133 "CAS::FOPD trying origin "
1134 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...",
1135 complete_interface_decl, &complete_iface_decl->getASTContext());
1136
1137 FindObjCMethodDeclsWithOrigin(context, complete_interface_decl,
1138 "in debug info");
1139
1140 return;
1141 } while (false);
1142
1143 do {
1144 // Check the modules only if the debug information didn't have a complete
1145 // interface.
1146
1147 if (std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
1149 ConstString interface_name(interface_decl->getNameAsString().c_str());
1150 bool append = false;
1151 uint32_t max_matches = 1;
1152 std::vector<clang::NamedDecl *> decls;
1153
1154 if (!modules_decl_vendor->FindDecls(interface_name, append, max_matches,
1155 decls))
1156 break;
1157
1158 ObjCInterfaceDecl *interface_decl_from_modules =
1159 dyn_cast<ObjCInterfaceDecl>(decls[0]);
1160
1161 if (!interface_decl_from_modules)
1162 break;
1163
1164 if (FindObjCMethodDeclsWithOrigin(context, interface_decl_from_modules,
1165 "in modules"))
1166 return;
1167 }
1168 } while (false);
1169
1170 do {
1171 // Check the runtime only if the debug information didn't have a complete
1172 // interface and the modules don't get us anywhere.
1173
1174 lldb::ProcessSP process(m_target->GetProcessSP());
1175
1176 if (!process)
1177 break;
1178
1179 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
1180
1181 if (!language_runtime)
1182 break;
1183
1184 DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
1185
1186 if (!decl_vendor)
1187 break;
1188
1189 ConstString interface_name(interface_decl->getNameAsString().c_str());
1190 bool append = false;
1191 uint32_t max_matches = 1;
1192 std::vector<clang::NamedDecl *> decls;
1193
1194 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
1195 if (!clang_decl_vendor->FindDecls(interface_name, append, max_matches,
1196 decls))
1197 break;
1198
1199 ObjCInterfaceDecl *runtime_interface_decl =
1200 dyn_cast<ObjCInterfaceDecl>(decls[0]);
1201
1202 if (!runtime_interface_decl)
1203 break;
1204
1205 FindObjCMethodDeclsWithOrigin(context, runtime_interface_decl,
1206 "in runtime");
1207 } while (false);
1208}
1209
1211 NameSearchContext &context, ClangASTSource &source,
1212 DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) {
1214
1215 if (origin_iface_decl.IsInvalid())
1216 return false;
1217
1218 std::string name_str = context.m_decl_name.getAsString();
1219 StringRef name(name_str);
1220 IdentifierInfo &name_identifier(
1221 origin_iface_decl->getASTContext().Idents.get(name));
1222
1223 DeclFromUser<ObjCPropertyDecl> origin_property_decl(
1224 origin_iface_decl->FindPropertyDeclaration(
1225 &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance));
1226
1227 bool found = false;
1228
1229 if (origin_property_decl.IsValid()) {
1230 DeclFromParser<ObjCPropertyDecl> parser_property_decl(
1231 origin_property_decl.Import(source));
1232 if (parser_property_decl.IsValid()) {
1233 LLDB_LOG(log, " CAS::FOPD found\n{0}",
1234 ClangUtil::DumpDecl(parser_property_decl.decl));
1235
1236 context.AddNamedDecl(parser_property_decl.decl);
1237 found = true;
1238 }
1239 }
1240
1241 DeclFromUser<ObjCIvarDecl> origin_ivar_decl(
1242 origin_iface_decl->getIvarDecl(&name_identifier));
1243
1244 if (origin_ivar_decl.IsValid()) {
1245 DeclFromParser<ObjCIvarDecl> parser_ivar_decl(
1246 origin_ivar_decl.Import(source));
1247 if (parser_ivar_decl.IsValid()) {
1248 LLDB_LOG(log, " CAS::FOPD found\n{0}",
1249 ClangUtil::DumpDecl(parser_ivar_decl.decl));
1250
1251 context.AddNamedDecl(parser_ivar_decl.decl);
1252 found = true;
1253 }
1254 }
1255
1256 return found;
1257}
1258
1261
1263 cast<ObjCInterfaceDecl>(context.m_decl_context));
1264 DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl(
1265 parser_iface_decl.GetOrigin(*this));
1266
1267 ConstString class_name(parser_iface_decl->getNameAsString().c_str());
1268
1269 LLDB_LOG(log,
1270 "ClangASTSource::FindObjCPropertyAndIvarDecls on "
1271 "(ASTContext*){0} '{1}' for '{2}.{3}'",
1273 parser_iface_decl->getName(), context.m_decl_name.getAsString());
1274
1275 if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, origin_iface_decl))
1276 return;
1277
1278 LLDB_LOG(log,
1279 "CAS::FOPD couldn't find the property on origin "
1280 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}, searching "
1281 "elsewhere...",
1282 origin_iface_decl.decl, &origin_iface_decl->getASTContext());
1283
1284 SymbolContext null_sc;
1285 TypeList type_list;
1286
1287 do {
1288 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(
1289 const_cast<ObjCInterfaceDecl *>(parser_iface_decl.decl));
1290
1291 if (!complete_interface_decl)
1292 break;
1293
1294 // We found the complete interface. The runtime never needs to be queried
1295 // in this scenario.
1296
1297 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
1298 complete_interface_decl);
1299
1300 if (complete_iface_decl.decl == origin_iface_decl.decl)
1301 break; // already checked this one
1302
1303 LLDB_LOG(log,
1304 "CAS::FOPD trying origin "
1305 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...",
1306 complete_iface_decl.decl, &complete_iface_decl->getASTContext());
1307
1308 FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, complete_iface_decl);
1309
1310 return;
1311 } while (false);
1312
1313 do {
1314 // Check the modules only if the debug information didn't have a complete
1315 // interface.
1316
1317 std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
1319
1320 if (!modules_decl_vendor)
1321 break;
1322
1323 bool append = false;
1324 uint32_t max_matches = 1;
1325 std::vector<clang::NamedDecl *> decls;
1326
1327 if (!modules_decl_vendor->FindDecls(class_name, append, max_matches, decls))
1328 break;
1329
1330 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_modules(
1331 dyn_cast<ObjCInterfaceDecl>(decls[0]));
1332
1333 if (!interface_decl_from_modules.IsValid())
1334 break;
1335
1336 LLDB_LOG(log,
1337 "CAS::FOPD[{0}] trying module "
1338 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...",
1339 interface_decl_from_modules.decl,
1340 &interface_decl_from_modules->getASTContext());
1341
1342 if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this,
1343 interface_decl_from_modules))
1344 return;
1345 } while (false);
1346
1347 do {
1348 // Check the runtime only if the debug information didn't have a complete
1349 // interface and nothing was in the modules.
1350
1351 lldb::ProcessSP process(m_target->GetProcessSP());
1352
1353 if (!process)
1354 return;
1355
1356 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
1357
1358 if (!language_runtime)
1359 return;
1360
1361 DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
1362
1363 if (!decl_vendor)
1364 break;
1365
1366 bool append = false;
1367 uint32_t max_matches = 1;
1368 std::vector<clang::NamedDecl *> decls;
1369
1370 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
1371 if (!clang_decl_vendor->FindDecls(class_name, append, max_matches, decls))
1372 break;
1373
1374 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime(
1375 dyn_cast<ObjCInterfaceDecl>(decls[0]));
1376
1377 if (!interface_decl_from_runtime.IsValid())
1378 break;
1379
1380 LLDB_LOG(log,
1381 "CAS::FOPD[{0}] trying runtime "
1382 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...",
1383 interface_decl_from_runtime.decl,
1384 &interface_decl_from_runtime->getASTContext());
1385
1386 if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this,
1387 interface_decl_from_runtime))
1388 return;
1389 } while (false);
1390}
1391
1393 const NamespaceDecl *namespace_context =
1394 dyn_cast<NamespaceDecl>(context.m_decl_context);
1395
1397
1398 ClangASTImporter::NamespaceMapSP namespace_map =
1399 m_ast_importer_sp->GetNamespaceMap(namespace_context);
1400
1401 LLDB_LOGV(log, " CAS::FEVD Inspecting namespace map {0} ({1} entries)",
1402 namespace_map.get(), namespace_map->size());
1403
1404 if (!namespace_map)
1405 return;
1406
1407 for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
1408 e = namespace_map->end();
1409 i != e; ++i) {
1410 LLDB_LOG(log, " CAS::FEVD Searching namespace {0} in module {1}",
1411 i->second.GetName(), i->first->GetFileSpec().GetFilename());
1412
1413 FindExternalVisibleDecls(context, i->first, i->second);
1414 }
1415}
1416
1417typedef llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsetMap;
1418typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap;
1419
1420template <class D, class O>
1421static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
1422 llvm::DenseMap<const D *, O> &source_map,
1423 ClangASTSource &source) {
1424 // When importing fields into a new record, clang has a hard requirement that
1425 // fields be imported in field offset order. Since they are stored in a
1426 // DenseMap with a pointer as the key type, this means we cannot simply
1427 // iterate over the map, as the order will be non-deterministic. Instead we
1428 // have to sort by the offset and then insert in sorted order.
1429 typedef llvm::DenseMap<const D *, O> MapType;
1430 typedef typename MapType::value_type PairType;
1431 std::vector<PairType> sorted_items;
1432 sorted_items.reserve(source_map.size());
1433 sorted_items.assign(source_map.begin(), source_map.end());
1434 llvm::sort(sorted_items, llvm::less_second());
1435
1436 for (const auto &item : sorted_items) {
1437 DeclFromUser<D> user_decl(const_cast<D *>(item.first));
1438 DeclFromParser<D> parser_decl(user_decl.Import(source));
1439 if (parser_decl.IsInvalid())
1440 return false;
1441 destination_map.insert(
1442 std::pair<const D *, O>(parser_decl.decl, item.second));
1443 }
1444
1445 return true;
1446}
1447
1448template <bool IsVirtual>
1449bool ExtractBaseOffsets(const ASTRecordLayout &record_layout,
1451 BaseOffsetMap &base_offsets) {
1452 for (CXXRecordDecl::base_class_const_iterator
1453 bi = (IsVirtual ? record->vbases_begin() : record->bases_begin()),
1454 be = (IsVirtual ? record->vbases_end() : record->bases_end());
1455 bi != be; ++bi) {
1456 if (!IsVirtual && bi->isVirtual())
1457 continue;
1458
1459 const clang::Type *origin_base_type = bi->getType().getTypePtr();
1460 const clang::RecordType *origin_base_record_type =
1461 origin_base_type->getAs<RecordType>();
1462
1463 if (!origin_base_record_type)
1464 return false;
1465
1466 DeclFromUser<RecordDecl> origin_base_record(
1467 origin_base_record_type->getDecl());
1468
1469 if (origin_base_record.IsInvalid())
1470 return false;
1471
1472 DeclFromUser<CXXRecordDecl> origin_base_cxx_record(
1473 DynCast<CXXRecordDecl>(origin_base_record));
1474
1475 if (origin_base_cxx_record.IsInvalid())
1476 return false;
1477
1478 CharUnits base_offset;
1479
1480 if (IsVirtual)
1481 base_offset =
1482 record_layout.getVBaseClassOffset(origin_base_cxx_record.decl);
1483 else
1484 base_offset =
1485 record_layout.getBaseClassOffset(origin_base_cxx_record.decl);
1486
1487 base_offsets.insert(std::pair<const CXXRecordDecl *, CharUnits>(
1488 origin_base_cxx_record.decl, base_offset));
1489 }
1490
1491 return true;
1492}
1493
1494bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size,
1495 uint64_t &alignment,
1496 FieldOffsetMap &field_offsets,
1497 BaseOffsetMap &base_offsets,
1498 BaseOffsetMap &virtual_base_offsets) {
1499
1501
1502 LLDB_LOG(log,
1503 "LayoutRecordType on (ASTContext*){0} '{1}' for (RecordDecl*)"
1504 "{2} [name = '{3}']",
1506 record->getName());
1507
1508 DeclFromParser<const RecordDecl> parser_record(record);
1509 DeclFromUser<const RecordDecl> origin_record(
1510 parser_record.GetOrigin(*this));
1511
1512 if (origin_record.IsInvalid())
1513 return false;
1514
1515 FieldOffsetMap origin_field_offsets;
1516 BaseOffsetMap origin_base_offsets;
1517 BaseOffsetMap origin_virtual_base_offsets;
1518
1520 &origin_record->getASTContext(),
1521 const_cast<RecordDecl *>(origin_record.decl));
1522
1523 clang::RecordDecl *definition = origin_record.decl->getDefinition();
1524 if (!definition || !definition->isCompleteDefinition())
1525 return false;
1526
1527 const ASTRecordLayout &record_layout(
1528 origin_record->getASTContext().getASTRecordLayout(origin_record.decl));
1529
1530 int field_idx = 0, field_count = record_layout.getFieldCount();
1531
1532 for (RecordDecl::field_iterator fi = origin_record->field_begin(),
1533 fe = origin_record->field_end();
1534 fi != fe; ++fi) {
1535 if (field_idx >= field_count)
1536 return false; // Layout didn't go well. Bail out.
1537
1538 uint64_t field_offset = record_layout.getFieldOffset(field_idx);
1539
1540 origin_field_offsets.insert(
1541 std::pair<const FieldDecl *, uint64_t>(*fi, field_offset));
1542
1543 field_idx++;
1544 }
1545
1546 lldbassert(&record->getASTContext() == m_ast_context);
1547
1548 DeclFromUser<const CXXRecordDecl> origin_cxx_record(
1549 DynCast<const CXXRecordDecl>(origin_record));
1550
1551 if (origin_cxx_record.IsValid()) {
1552 if (!ExtractBaseOffsets<false>(record_layout, origin_cxx_record,
1553 origin_base_offsets) ||
1554 !ExtractBaseOffsets<true>(record_layout, origin_cxx_record,
1555 origin_virtual_base_offsets))
1556 return false;
1557 }
1558
1559 if (!ImportOffsetMap(field_offsets, origin_field_offsets, *this) ||
1560 !ImportOffsetMap(base_offsets, origin_base_offsets, *this) ||
1561 !ImportOffsetMap(virtual_base_offsets, origin_virtual_base_offsets,
1562 *this))
1563 return false;
1564
1565 size = record_layout.getSize().getQuantity() * m_ast_context->getCharWidth();
1566 alignment = record_layout.getAlignment().getQuantity() *
1567 m_ast_context->getCharWidth();
1568
1569 if (log) {
1570 LLDB_LOG(log, "LRT returned:");
1571 LLDB_LOG(log, "LRT Original = (RecordDecl*){0}",
1572 static_cast<const void *>(origin_record.decl));
1573 LLDB_LOG(log, "LRT Size = {0}", size);
1574 LLDB_LOG(log, "LRT Alignment = {0}", alignment);
1575 LLDB_LOG(log, "LRT Fields:");
1576 for (RecordDecl::field_iterator fi = record->field_begin(),
1577 fe = record->field_end();
1578 fi != fe; ++fi) {
1579 LLDB_LOG(log,
1580 "LRT (FieldDecl*){0}, Name = '{1}', Type = '{2}', Offset = "
1581 "{3} bits",
1582 *fi, fi->getName(), fi->getType().getAsString(),
1583 field_offsets[*fi]);
1584 }
1585 DeclFromParser<const CXXRecordDecl> parser_cxx_record =
1586 DynCast<const CXXRecordDecl>(parser_record);
1587 if (parser_cxx_record.IsValid()) {
1588 LLDB_LOG(log, "LRT Bases:");
1589 for (CXXRecordDecl::base_class_const_iterator
1590 bi = parser_cxx_record->bases_begin(),
1591 be = parser_cxx_record->bases_end();
1592 bi != be; ++bi) {
1593 bool is_virtual = bi->isVirtual();
1594
1595 QualType base_type = bi->getType();
1596 const RecordType *base_record_type = base_type->getAs<RecordType>();
1597 DeclFromParser<RecordDecl> base_record(base_record_type->getDecl());
1598 DeclFromParser<CXXRecordDecl> base_cxx_record =
1599 DynCast<CXXRecordDecl>(base_record);
1600
1601 LLDB_LOG(log,
1602 "LRT {0}(CXXRecordDecl*){1}, Name = '{2}', Offset = "
1603 "{3} chars",
1604 (is_virtual ? "Virtual " : ""), base_cxx_record.decl,
1605 base_cxx_record.decl->getName(),
1606 (is_virtual
1607 ? virtual_base_offsets[base_cxx_record.decl].getQuantity()
1608 : base_offsets[base_cxx_record.decl].getQuantity()));
1609 }
1610 } else {
1611 LLDB_LOG(log, "LRD Not a CXXRecord, so no bases");
1612 }
1613 }
1614
1615 return true;
1616}
1617
1619 ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
1620 ClangASTImporter::NamespaceMapSP &parent_map) const {
1621
1623
1624 if (log) {
1625 if (parent_map && parent_map->size())
1626 LLDB_LOG(log,
1627 "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching "
1628 "for namespace {2} in namespace {3}",
1630 parent_map->begin()->second.GetName());
1631 else
1632 LLDB_LOG(log,
1633 "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching "
1634 "for namespace {2}",
1636 }
1637
1638 if (parent_map) {
1639 for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
1640 e = parent_map->end();
1641 i != e; ++i) {
1642 CompilerDeclContext found_namespace_decl;
1643
1644 lldb::ModuleSP module_sp = i->first;
1645 CompilerDeclContext module_parent_namespace_decl = i->second;
1646
1647 SymbolFile *symbol_file = module_sp->GetSymbolFile();
1648
1649 if (!symbol_file)
1650 continue;
1651
1652 found_namespace_decl =
1653 symbol_file->FindNamespace(name, module_parent_namespace_decl);
1654
1655 if (!found_namespace_decl)
1656 continue;
1657
1658 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
1659 module_sp, found_namespace_decl));
1660
1661 LLDB_LOG(log, " CMN Found namespace {0} in module {1}", name,
1662 module_sp->GetFileSpec().GetFilename());
1663 }
1664 } else {
1665 CompilerDeclContext null_namespace_decl;
1666 for (lldb::ModuleSP image : m_target->GetImages().Modules()) {
1667 if (!image)
1668 continue;
1669
1670 CompilerDeclContext found_namespace_decl;
1671
1672 SymbolFile *symbol_file = image->GetSymbolFile();
1673
1674 if (!symbol_file)
1675 continue;
1676
1677 found_namespace_decl =
1678 symbol_file->FindNamespace(name, null_namespace_decl);
1679
1680 if (!found_namespace_decl)
1681 continue;
1682
1683 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
1684 image, found_namespace_decl));
1685
1686 LLDB_LOG(log, " CMN[{0}] Found namespace {0} in module {1}", name,
1687 image->GetFileSpec().GetFilename());
1688 }
1689 }
1690}
1691
1693 NameSearchContext &context,
1694 ClangASTImporter::NamespaceMapSP &namespace_decls) {
1695 if (!namespace_decls)
1696 return nullptr;
1697
1698 const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second;
1699
1700 clang::ASTContext *src_ast =
1702 if (!src_ast)
1703 return nullptr;
1704 clang::NamespaceDecl *src_namespace_decl =
1706
1707 if (!src_namespace_decl)
1708 return nullptr;
1709
1710 Decl *copied_decl = CopyDecl(src_namespace_decl);
1711
1712 if (!copied_decl)
1713 return nullptr;
1714
1715 NamespaceDecl *copied_namespace_decl = dyn_cast<NamespaceDecl>(copied_decl);
1716
1717 if (!copied_namespace_decl)
1718 return nullptr;
1719
1720 context.m_decls.push_back(copied_namespace_decl);
1721
1722 m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl,
1723 namespace_decls);
1724
1725 return dyn_cast<NamespaceDecl>(copied_decl);
1726}
1727
1728clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) {
1729 return m_ast_importer_sp->CopyDecl(m_ast_context, src_decl);
1730}
1731
1733 return m_ast_importer_sp->GetDeclOrigin(decl);
1734}
1735
1737 auto ts = src_type.GetTypeSystem();
1738 auto src_ast = ts.dyn_cast_or_null<TypeSystemClang>();
1739 if (!src_ast)
1740 return {};
1741
1742 QualType copied_qual_type = ClangUtil::GetQualType(
1743 m_ast_importer_sp->CopyType(*m_clang_ast_context, src_type));
1744
1745 if (copied_qual_type.getAsOpaquePtr() &&
1746 copied_qual_type->getCanonicalTypeInternal().isNull())
1747 // this shouldn't happen, but we're hardening because the AST importer
1748 // seems to be generating bad types on occasion.
1749 return {};
1750
1751 return m_clang_ast_context->GetType(copied_qual_type);
1752}
1753
1754std::shared_ptr<ClangModulesDeclVendor>
1756 auto persistent_vars = llvm::cast<ClangPersistentVariables>(
1757 m_target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC));
1758 return persistent_vars->GetClangModulesDeclVendor();
1759}
llvm::DenseMap< const FieldDecl *, uint64_t > FieldOffsetMap
bool ExtractBaseOffsets(const ASTRecordLayout &record_layout, DeclFromUser< const CXXRecordDecl > &record, BaseOffsetMap &base_offsets)
static bool FindObjCPropertyAndIvarDeclsWithOrigin(NameSearchContext &context, ClangASTSource &source, DeclFromUser< const ObjCInterfaceDecl > &origin_iface_decl)
llvm::DenseMap< const CXXRecordDecl *, CharUnits > BaseOffsetMap
TD< D2 > DynCast(TD< D1 > source)
static bool ImportOffsetMap(llvm::DenseMap< const D *, O > &destination_map, llvm::DenseMap< const D *, O > &source_map, ClangASTSource &source)
#define lldbassert(x)
Definition: LLDBAssert.h:15
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:342
#define LLDB_LOGV(log,...)
Definition: Log.h:356
DeclFromUser< D > GetOrigin(ClangASTSource &source)
DeclFromParser(D *_decl)
DeclFromUser(D *_decl)
DeclFromParser< D > Import(ClangASTSource &source)
bool IsInvalid() const
bool IsValid() const
TaggedASTDecl(D *_decl)
D * operator->() const
std::shared_ptr< NamespaceMap > NamespaceMapSP
std::pair< lldb::ModuleSP, CompilerDeclContext > NamespaceMapItem
Provider for named objects defined in the debug info for Clang.
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 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.
std::shared_ptr< TypeSystemType > dyn_cast_or_null()
Return a shared_ptr<TypeSystemType> if dyn_cast succeeds.
Definition: CompilerType.h:68
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:234
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:182
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:191
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:205
virtual DeclVendor * GetDeclVendor()
bool GetVerbose() const
Definition: Log.cpp:313
A collection class for Module objects.
Definition: ModuleList.h:82
void 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:560
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:107
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:33
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:49
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:339
uint32_t GetSize() const
Definition: TypeList.cpp:60
lldb::TypeSP GetTypeAtIndex(uint32_t idx)
Definition: TypeList.cpp:66
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)
clang::ASTContext & getASTContext()
Returns the clang::ASTContext instance managed by this TypeSystemClang.
static clang::NamespaceDecl * DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc)
bool GetCompleteDecl(clang::Decl *decl)
static bool DeclsAreEquivalent(clang::Decl *lhs_decl, clang::Decl *rhs_decl)
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
TaggedASTType< 1 > TypeFromUser
Definition: TaggedASTType.h:41
void * opaque_compiler_type_t
Definition: lldb-types.h:86
@ eLanguageTypeC
Non-standardized C, such as K&R.
std::shared_ptr< lldb_private::Type > TypeSP
Definition: lldb-forward.h:436
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:368
std::shared_ptr< lldb_private::TypeSystemClang > TypeSystemClangSP
Definition: lldb-forward.h:445
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:423
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:354
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.