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