1 //===-- ClangASTImporter.cpp ------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Symbol/ClangASTImporter.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Symbol/ClangASTContext.h"
13 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
14 #include "lldb/Symbol/ClangUtil.h"
15 #include "lldb/Utility/LLDBAssert.h"
16 #include "lldb/Utility/Log.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "llvm/Support/raw_ostream.h"
21 
22 using namespace lldb_private;
23 using namespace clang;
24 
25 ClangASTMetrics::Counters ClangASTMetrics::global_counters = {0, 0, 0, 0, 0, 0};
26 ClangASTMetrics::Counters ClangASTMetrics::local_counters = {0, 0, 0, 0, 0, 0};
27 
28 void ClangASTMetrics::DumpCounters(Log *log,
29                                    ClangASTMetrics::Counters &counters) {
30   log->Printf("  Number of visible Decl queries by name     : %" PRIu64,
31               counters.m_visible_query_count);
32   log->Printf("  Number of lexical Decl queries             : %" PRIu64,
33               counters.m_lexical_query_count);
34   log->Printf("  Number of imports initiated by LLDB        : %" PRIu64,
35               counters.m_lldb_import_count);
36   log->Printf("  Number of imports conducted by Clang       : %" PRIu64,
37               counters.m_clang_import_count);
38   log->Printf("  Number of Decls completed                  : %" PRIu64,
39               counters.m_decls_completed_count);
40   log->Printf("  Number of records laid out                 : %" PRIu64,
41               counters.m_record_layout_count);
42 }
43 
44 void ClangASTMetrics::DumpCounters(Log *log) {
45   if (!log)
46     return;
47 
48   log->Printf("== ClangASTMetrics output ==");
49   log->Printf("-- Global metrics --");
50   DumpCounters(log, global_counters);
51   log->Printf("-- Local metrics --");
52   DumpCounters(log, local_counters);
53 }
54 
55 clang::QualType ClangASTImporter::CopyType(clang::ASTContext *dst_ast,
56                                            clang::ASTContext *src_ast,
57                                            clang::QualType type) {
58   MinionSP minion_sp(GetMinion(dst_ast, src_ast));
59 
60   if (minion_sp)
61     return minion_sp->Import(type);
62 
63   return QualType();
64 }
65 
66 lldb::opaque_compiler_type_t
67 ClangASTImporter::CopyType(clang::ASTContext *dst_ast,
68                            clang::ASTContext *src_ast,
69                            lldb::opaque_compiler_type_t type) {
70   return CopyType(dst_ast, src_ast, QualType::getFromOpaquePtr(type))
71       .getAsOpaquePtr();
72 }
73 
74 CompilerType ClangASTImporter::CopyType(ClangASTContext &dst_ast,
75                                         const CompilerType &src_type) {
76   clang::ASTContext *dst_clang_ast = dst_ast.getASTContext();
77   if (dst_clang_ast) {
78     ClangASTContext *src_ast =
79         llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
80     if (src_ast) {
81       clang::ASTContext *src_clang_ast = src_ast->getASTContext();
82       if (src_clang_ast) {
83         lldb::opaque_compiler_type_t dst_clang_type = CopyType(
84             dst_clang_ast, src_clang_ast, src_type.GetOpaqueQualType());
85 
86         if (dst_clang_type)
87           return CompilerType(&dst_ast, dst_clang_type);
88       }
89     }
90   }
91   return CompilerType();
92 }
93 
94 clang::Decl *ClangASTImporter::CopyDecl(clang::ASTContext *dst_ast,
95                                         clang::ASTContext *src_ast,
96                                         clang::Decl *decl) {
97   MinionSP minion_sp;
98 
99   minion_sp = GetMinion(dst_ast, src_ast);
100 
101   if (minion_sp) {
102     clang::Decl *result = minion_sp->Import(decl);
103 
104     if (!result) {
105       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
106 
107       if (log) {
108         lldb::user_id_t user_id = LLDB_INVALID_UID;
109         ClangASTMetadata *metadata = GetDeclMetadata(decl);
110         if (metadata)
111           user_id = metadata->GetUserID();
112 
113         if (NamedDecl *named_decl = dyn_cast<NamedDecl>(decl))
114           log->Printf("  [ClangASTImporter] WARNING: Failed to import a %s "
115                       "'%s', metadata 0x%" PRIx64,
116                       decl->getDeclKindName(),
117                       named_decl->getNameAsString().c_str(), user_id);
118         else
119           log->Printf("  [ClangASTImporter] WARNING: Failed to import a %s, "
120                       "metadata 0x%" PRIx64,
121                       decl->getDeclKindName(), user_id);
122       }
123     }
124 
125     return result;
126   }
127 
128   return nullptr;
129 }
130 
131 class DeclContextOverride {
132 private:
133   struct Backup {
134     clang::DeclContext *decl_context;
135     clang::DeclContext *lexical_decl_context;
136   };
137 
138   std::map<clang::Decl *, Backup> m_backups;
139 
140   void OverrideOne(clang::Decl *decl) {
141     if (m_backups.find(decl) != m_backups.end()) {
142       return;
143     }
144 
145     m_backups[decl] = {decl->getDeclContext(), decl->getLexicalDeclContext()};
146 
147     decl->setDeclContext(decl->getASTContext().getTranslationUnitDecl());
148     decl->setLexicalDeclContext(decl->getASTContext().getTranslationUnitDecl());
149   }
150 
151   bool ChainPassesThrough(
152       clang::Decl *decl, clang::DeclContext *base,
153       clang::DeclContext *(clang::Decl::*contextFromDecl)(),
154       clang::DeclContext *(clang::DeclContext::*contextFromContext)()) {
155     for (DeclContext *decl_ctx = (decl->*contextFromDecl)(); decl_ctx;
156          decl_ctx = (decl_ctx->*contextFromContext)()) {
157       if (decl_ctx == base) {
158         return true;
159       }
160     }
161 
162     return false;
163   }
164 
165   clang::Decl *GetEscapedChild(clang::Decl *decl,
166                                clang::DeclContext *base = nullptr) {
167     if (base) {
168       // decl's DeclContext chains must pass through base.
169 
170       if (!ChainPassesThrough(decl, base, &clang::Decl::getDeclContext,
171                               &clang::DeclContext::getParent) ||
172           !ChainPassesThrough(decl, base, &clang::Decl::getLexicalDeclContext,
173                               &clang::DeclContext::getLexicalParent)) {
174         return decl;
175       }
176     } else {
177       base = clang::dyn_cast<clang::DeclContext>(decl);
178 
179       if (!base) {
180         return nullptr;
181       }
182     }
183 
184     if (clang::DeclContext *context =
185             clang::dyn_cast<clang::DeclContext>(decl)) {
186       for (clang::Decl *decl : context->decls()) {
187         if (clang::Decl *escaped_child = GetEscapedChild(decl)) {
188           return escaped_child;
189         }
190       }
191     }
192 
193     return nullptr;
194   }
195 
196   void Override(clang::Decl *decl) {
197     if (clang::Decl *escaped_child = GetEscapedChild(decl)) {
198       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
199 
200       if (log)
201         log->Printf("    [ClangASTImporter] DeclContextOverride couldn't "
202                     "override (%sDecl*)%p - its child (%sDecl*)%p escapes",
203                     decl->getDeclKindName(), static_cast<void *>(decl),
204                     escaped_child->getDeclKindName(),
205                     static_cast<void *>(escaped_child));
206       lldbassert(0 && "Couldn't override!");
207     }
208 
209     OverrideOne(decl);
210   }
211 
212 public:
213   DeclContextOverride() {}
214 
215   void OverrideAllDeclsFromContainingFunction(clang::Decl *decl) {
216     for (DeclContext *decl_context = decl->getLexicalDeclContext();
217          decl_context; decl_context = decl_context->getLexicalParent()) {
218       DeclContext *redecl_context = decl_context->getRedeclContext();
219 
220       if (llvm::isa<FunctionDecl>(redecl_context) &&
221           llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent())) {
222         for (clang::Decl *child_decl : decl_context->decls()) {
223           Override(child_decl);
224         }
225       }
226     }
227   }
228 
229   ~DeclContextOverride() {
230     for (const std::pair<clang::Decl *, Backup> &backup : m_backups) {
231       backup.first->setDeclContext(backup.second.decl_context);
232       backup.first->setLexicalDeclContext(backup.second.lexical_decl_context);
233     }
234   }
235 };
236 
237 lldb::opaque_compiler_type_t
238 ClangASTImporter::DeportType(clang::ASTContext *dst_ctx,
239                              clang::ASTContext *src_ctx,
240                              lldb::opaque_compiler_type_t type) {
241   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
242 
243   if (log)
244     log->Printf("    [ClangASTImporter] DeportType called on (%sType*)0x%llx "
245                 "from (ASTContext*)%p to (ASTContext*)%p",
246                 QualType::getFromOpaquePtr(type)->getTypeClassName(),
247                 (unsigned long long)type, static_cast<void *>(src_ctx),
248                 static_cast<void *>(dst_ctx));
249 
250   MinionSP minion_sp(GetMinion(dst_ctx, src_ctx));
251 
252   if (!minion_sp)
253     return nullptr;
254 
255   std::set<NamedDecl *> decls_to_deport;
256   std::set<NamedDecl *> decls_already_deported;
257 
258   DeclContextOverride decl_context_override;
259 
260   if (const clang::TagType *tag_type =
261           clang::QualType::getFromOpaquePtr(type)->getAs<TagType>()) {
262     decl_context_override.OverrideAllDeclsFromContainingFunction(
263         tag_type->getDecl());
264   }
265 
266   minion_sp->InitDeportWorkQueues(&decls_to_deport, &decls_already_deported);
267 
268   lldb::opaque_compiler_type_t result = CopyType(dst_ctx, src_ctx, type);
269 
270   minion_sp->ExecuteDeportWorkQueues();
271 
272   if (!result)
273     return nullptr;
274 
275   return result;
276 }
277 
278 clang::Decl *ClangASTImporter::DeportDecl(clang::ASTContext *dst_ctx,
279                                           clang::ASTContext *src_ctx,
280                                           clang::Decl *decl) {
281   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
282 
283   if (log)
284     log->Printf("    [ClangASTImporter] DeportDecl called on (%sDecl*)%p from "
285                 "(ASTContext*)%p to (ASTContext*)%p",
286                 decl->getDeclKindName(), static_cast<void *>(decl),
287                 static_cast<void *>(src_ctx), static_cast<void *>(dst_ctx));
288 
289   MinionSP minion_sp(GetMinion(dst_ctx, src_ctx));
290 
291   if (!minion_sp)
292     return nullptr;
293 
294   std::set<NamedDecl *> decls_to_deport;
295   std::set<NamedDecl *> decls_already_deported;
296 
297   DeclContextOverride decl_context_override;
298 
299   decl_context_override.OverrideAllDeclsFromContainingFunction(decl);
300 
301   minion_sp->InitDeportWorkQueues(&decls_to_deport, &decls_already_deported);
302 
303   clang::Decl *result = CopyDecl(dst_ctx, src_ctx, decl);
304 
305   minion_sp->ExecuteDeportWorkQueues();
306 
307   if (!result)
308     return nullptr;
309 
310   if (log)
311     log->Printf(
312         "    [ClangASTImporter] DeportDecl deported (%sDecl*)%p to (%sDecl*)%p",
313         decl->getDeclKindName(), static_cast<void *>(decl),
314         result->getDeclKindName(), static_cast<void *>(result));
315 
316   return result;
317 }
318 
319 bool ClangASTImporter::CanImport(const CompilerType &type) {
320   if (!ClangUtil::IsClangType(type))
321     return false;
322 
323   // TODO: remove external completion BOOL
324   // CompleteAndFetchChildren should get the Decl out and check for the
325 
326   clang::QualType qual_type(
327       ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
328 
329   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
330   switch (type_class) {
331   case clang::Type::Record: {
332     const clang::CXXRecordDecl *cxx_record_decl =
333         qual_type->getAsCXXRecordDecl();
334     if (cxx_record_decl) {
335       if (ResolveDeclOrigin(cxx_record_decl, NULL, NULL))
336         return true;
337     }
338   } break;
339 
340   case clang::Type::Enum: {
341     clang::EnumDecl *enum_decl =
342         llvm::cast<clang::EnumType>(qual_type)->getDecl();
343     if (enum_decl) {
344       if (ResolveDeclOrigin(enum_decl, NULL, NULL))
345         return true;
346     }
347   } break;
348 
349   case clang::Type::ObjCObject:
350   case clang::Type::ObjCInterface: {
351     const clang::ObjCObjectType *objc_class_type =
352         llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
353     if (objc_class_type) {
354       clang::ObjCInterfaceDecl *class_interface_decl =
355           objc_class_type->getInterface();
356       // We currently can't complete objective C types through the newly added
357       // ASTContext
358       // because it only supports TagDecl objects right now...
359       if (class_interface_decl) {
360         if (ResolveDeclOrigin(class_interface_decl, NULL, NULL))
361           return true;
362       }
363     }
364   } break;
365 
366   case clang::Type::Typedef:
367     return CanImport(CompilerType(type.GetTypeSystem(),
368                                   llvm::cast<clang::TypedefType>(qual_type)
369                                       ->getDecl()
370                                       ->getUnderlyingType()
371                                       .getAsOpaquePtr()));
372 
373   case clang::Type::Auto:
374     return CanImport(CompilerType(type.GetTypeSystem(),
375                                   llvm::cast<clang::AutoType>(qual_type)
376                                       ->getDeducedType()
377                                       .getAsOpaquePtr()));
378 
379   case clang::Type::Elaborated:
380     return CanImport(CompilerType(type.GetTypeSystem(),
381                                   llvm::cast<clang::ElaboratedType>(qual_type)
382                                       ->getNamedType()
383                                       .getAsOpaquePtr()));
384 
385   case clang::Type::Paren:
386     return CanImport(CompilerType(
387         type.GetTypeSystem(),
388         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
389 
390   default:
391     break;
392   }
393 
394   return false;
395 }
396 
397 bool ClangASTImporter::Import(const CompilerType &type) {
398   if (!ClangUtil::IsClangType(type))
399     return false;
400   // TODO: remove external completion BOOL
401   // CompleteAndFetchChildren should get the Decl out and check for the
402 
403   clang::QualType qual_type(
404       ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
405 
406   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
407   switch (type_class) {
408   case clang::Type::Record: {
409     const clang::CXXRecordDecl *cxx_record_decl =
410         qual_type->getAsCXXRecordDecl();
411     if (cxx_record_decl) {
412       if (ResolveDeclOrigin(cxx_record_decl, NULL, NULL))
413         return CompleteAndFetchChildren(qual_type);
414     }
415   } break;
416 
417   case clang::Type::Enum: {
418     clang::EnumDecl *enum_decl =
419         llvm::cast<clang::EnumType>(qual_type)->getDecl();
420     if (enum_decl) {
421       if (ResolveDeclOrigin(enum_decl, NULL, NULL))
422         return CompleteAndFetchChildren(qual_type);
423     }
424   } break;
425 
426   case clang::Type::ObjCObject:
427   case clang::Type::ObjCInterface: {
428     const clang::ObjCObjectType *objc_class_type =
429         llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
430     if (objc_class_type) {
431       clang::ObjCInterfaceDecl *class_interface_decl =
432           objc_class_type->getInterface();
433       // We currently can't complete objective C types through the newly added
434       // ASTContext
435       // because it only supports TagDecl objects right now...
436       if (class_interface_decl) {
437         if (ResolveDeclOrigin(class_interface_decl, NULL, NULL))
438           return CompleteAndFetchChildren(qual_type);
439       }
440     }
441   } break;
442 
443   case clang::Type::Typedef:
444     return Import(CompilerType(type.GetTypeSystem(),
445                                llvm::cast<clang::TypedefType>(qual_type)
446                                    ->getDecl()
447                                    ->getUnderlyingType()
448                                    .getAsOpaquePtr()));
449 
450   case clang::Type::Auto:
451     return Import(CompilerType(type.GetTypeSystem(),
452                                llvm::cast<clang::AutoType>(qual_type)
453                                    ->getDeducedType()
454                                    .getAsOpaquePtr()));
455 
456   case clang::Type::Elaborated:
457     return Import(CompilerType(type.GetTypeSystem(),
458                                llvm::cast<clang::ElaboratedType>(qual_type)
459                                    ->getNamedType()
460                                    .getAsOpaquePtr()));
461 
462   case clang::Type::Paren:
463     return Import(CompilerType(
464         type.GetTypeSystem(),
465         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
466 
467   default:
468     break;
469   }
470   return false;
471 }
472 
473 bool ClangASTImporter::CompleteType(const CompilerType &compiler_type) {
474   if (!CanImport(compiler_type))
475     return false;
476 
477   if (Import(compiler_type)) {
478     ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
479     return true;
480   }
481 
482   ClangASTContext::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
483                                          false);
484   return false;
485 }
486 
487 bool ClangASTImporter::LayoutRecordType(
488     const clang::RecordDecl *record_decl, uint64_t &bit_size,
489     uint64_t &alignment,
490     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
491     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
492         &base_offsets,
493     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
494         &vbase_offsets) {
495   RecordDeclToLayoutMap::iterator pos =
496       m_record_decl_to_layout_map.find(record_decl);
497   bool success = false;
498   base_offsets.clear();
499   vbase_offsets.clear();
500   if (pos != m_record_decl_to_layout_map.end()) {
501     bit_size = pos->second.bit_size;
502     alignment = pos->second.alignment;
503     field_offsets.swap(pos->second.field_offsets);
504     base_offsets.swap(pos->second.base_offsets);
505     vbase_offsets.swap(pos->second.vbase_offsets);
506     m_record_decl_to_layout_map.erase(pos);
507     success = true;
508   } else {
509     bit_size = 0;
510     alignment = 0;
511     field_offsets.clear();
512   }
513   return success;
514 }
515 
516 void ClangASTImporter::InsertRecordDecl(clang::RecordDecl *decl,
517                                         const LayoutInfo &layout) {
518   m_record_decl_to_layout_map.insert(std::make_pair(decl, layout));
519 }
520 
521 void ClangASTImporter::CompleteDecl(clang::Decl *decl) {
522   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
523 
524   if (log)
525     log->Printf("    [ClangASTImporter] CompleteDecl called on (%sDecl*)%p",
526                 decl->getDeclKindName(), static_cast<void *>(decl));
527 
528   if (ObjCInterfaceDecl *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl)) {
529     if (!interface_decl->getDefinition()) {
530       interface_decl->startDefinition();
531       CompleteObjCInterfaceDecl(interface_decl);
532     }
533   } else if (ObjCProtocolDecl *protocol_decl =
534                  dyn_cast<ObjCProtocolDecl>(decl)) {
535     if (!protocol_decl->getDefinition())
536       protocol_decl->startDefinition();
537   } else if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl)) {
538     if (!tag_decl->getDefinition() && !tag_decl->isBeingDefined()) {
539       tag_decl->startDefinition();
540       CompleteTagDecl(tag_decl);
541       tag_decl->setCompleteDefinition(true);
542     }
543   } else {
544     assert(0 && "CompleteDecl called on a Decl that can't be completed");
545   }
546 }
547 
548 bool ClangASTImporter::CompleteTagDecl(clang::TagDecl *decl) {
549   ClangASTMetrics::RegisterDeclCompletion();
550 
551   DeclOrigin decl_origin = GetDeclOrigin(decl);
552 
553   if (!decl_origin.Valid())
554     return false;
555 
556   if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
557     return false;
558 
559   MinionSP minion_sp(GetMinion(&decl->getASTContext(), decl_origin.ctx));
560 
561   if (minion_sp)
562     minion_sp->ImportDefinitionTo(decl, decl_origin.decl);
563 
564   return true;
565 }
566 
567 bool ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl,
568                                                  clang::TagDecl *origin_decl) {
569   ClangASTMetrics::RegisterDeclCompletion();
570 
571   clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
572 
573   if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl))
574     return false;
575 
576   MinionSP minion_sp(GetMinion(&decl->getASTContext(), origin_ast_ctx));
577 
578   if (minion_sp)
579     minion_sp->ImportDefinitionTo(decl, origin_decl);
580 
581   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
582 
583   OriginMap &origins = context_md->m_origins;
584 
585   origins[decl] = DeclOrigin(origin_ast_ctx, origin_decl);
586 
587   return true;
588 }
589 
590 bool ClangASTImporter::CompleteObjCInterfaceDecl(
591     clang::ObjCInterfaceDecl *interface_decl) {
592   ClangASTMetrics::RegisterDeclCompletion();
593 
594   DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
595 
596   if (!decl_origin.Valid())
597     return false;
598 
599   if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
600     return false;
601 
602   MinionSP minion_sp(
603       GetMinion(&interface_decl->getASTContext(), decl_origin.ctx));
604 
605   if (minion_sp)
606     minion_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);
607 
608   if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass())
609     RequireCompleteType(clang::QualType(super_class->getTypeForDecl(), 0));
610 
611   return true;
612 }
613 
614 bool ClangASTImporter::CompleteAndFetchChildren(clang::QualType type) {
615   if (!RequireCompleteType(type))
616     return false;
617 
618   if (const TagType *tag_type = type->getAs<TagType>()) {
619     TagDecl *tag_decl = tag_type->getDecl();
620 
621     DeclOrigin decl_origin = GetDeclOrigin(tag_decl);
622 
623     if (!decl_origin.Valid())
624       return false;
625 
626     MinionSP minion_sp(GetMinion(&tag_decl->getASTContext(), decl_origin.ctx));
627 
628     TagDecl *origin_tag_decl = llvm::dyn_cast<TagDecl>(decl_origin.decl);
629 
630     for (Decl *origin_child_decl : origin_tag_decl->decls()) {
631       minion_sp->Import(origin_child_decl);
632     }
633 
634     if (RecordDecl *record_decl = dyn_cast<RecordDecl>(origin_tag_decl)) {
635       record_decl->setHasLoadedFieldsFromExternalStorage(true);
636     }
637 
638     return true;
639   }
640 
641   if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>()) {
642     if (ObjCInterfaceDecl *objc_interface_decl =
643             objc_object_type->getInterface()) {
644       DeclOrigin decl_origin = GetDeclOrigin(objc_interface_decl);
645 
646       if (!decl_origin.Valid())
647         return false;
648 
649       MinionSP minion_sp(
650           GetMinion(&objc_interface_decl->getASTContext(), decl_origin.ctx));
651 
652       ObjCInterfaceDecl *origin_interface_decl =
653           llvm::dyn_cast<ObjCInterfaceDecl>(decl_origin.decl);
654 
655       for (Decl *origin_child_decl : origin_interface_decl->decls()) {
656         minion_sp->Import(origin_child_decl);
657       }
658 
659       return true;
660     } else {
661       return false;
662     }
663   }
664 
665   return true;
666 }
667 
668 bool ClangASTImporter::RequireCompleteType(clang::QualType type) {
669   if (type.isNull())
670     return false;
671 
672   if (const TagType *tag_type = type->getAs<TagType>()) {
673     TagDecl *tag_decl = tag_type->getDecl();
674 
675     if (tag_decl->getDefinition() || tag_decl->isBeingDefined())
676       return true;
677 
678     return CompleteTagDecl(tag_decl);
679   }
680   if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>()) {
681     if (ObjCInterfaceDecl *objc_interface_decl =
682             objc_object_type->getInterface())
683       return CompleteObjCInterfaceDecl(objc_interface_decl);
684     else
685       return false;
686   }
687   if (const ArrayType *array_type = type->getAsArrayTypeUnsafe()) {
688     return RequireCompleteType(array_type->getElementType());
689   }
690   if (const AtomicType *atomic_type = type->getAs<AtomicType>()) {
691     return RequireCompleteType(atomic_type->getPointeeType());
692   }
693 
694   return true;
695 }
696 
697 ClangASTMetadata *ClangASTImporter::GetDeclMetadata(const clang::Decl *decl) {
698   DeclOrigin decl_origin = GetDeclOrigin(decl);
699 
700   if (decl_origin.Valid())
701     return ClangASTContext::GetMetadata(decl_origin.ctx, decl_origin.decl);
702   else
703     return ClangASTContext::GetMetadata(&decl->getASTContext(), decl);
704 }
705 
706 ClangASTImporter::DeclOrigin
707 ClangASTImporter::GetDeclOrigin(const clang::Decl *decl) {
708   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
709 
710   OriginMap &origins = context_md->m_origins;
711 
712   OriginMap::iterator iter = origins.find(decl);
713 
714   if (iter != origins.end())
715     return iter->second;
716   else
717     return DeclOrigin();
718 }
719 
720 void ClangASTImporter::SetDeclOrigin(const clang::Decl *decl,
721                                      clang::Decl *original_decl) {
722   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
723 
724   OriginMap &origins = context_md->m_origins;
725 
726   OriginMap::iterator iter = origins.find(decl);
727 
728   if (iter != origins.end()) {
729     iter->second.decl = original_decl;
730     iter->second.ctx = &original_decl->getASTContext();
731   } else {
732     origins[decl] = DeclOrigin(&original_decl->getASTContext(), original_decl);
733   }
734 }
735 
736 void ClangASTImporter::RegisterNamespaceMap(const clang::NamespaceDecl *decl,
737                                             NamespaceMapSP &namespace_map) {
738   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
739 
740   context_md->m_namespace_maps[decl] = namespace_map;
741 }
742 
743 ClangASTImporter::NamespaceMapSP
744 ClangASTImporter::GetNamespaceMap(const clang::NamespaceDecl *decl) {
745   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
746 
747   NamespaceMetaMap &namespace_maps = context_md->m_namespace_maps;
748 
749   NamespaceMetaMap::iterator iter = namespace_maps.find(decl);
750 
751   if (iter != namespace_maps.end())
752     return iter->second;
753   else
754     return NamespaceMapSP();
755 }
756 
757 void ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl) {
758   assert(decl);
759   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
760 
761   const DeclContext *parent_context = decl->getDeclContext();
762   const NamespaceDecl *parent_namespace =
763       dyn_cast<NamespaceDecl>(parent_context);
764   NamespaceMapSP parent_map;
765 
766   if (parent_namespace)
767     parent_map = GetNamespaceMap(parent_namespace);
768 
769   NamespaceMapSP new_map;
770 
771   new_map.reset(new NamespaceMap);
772 
773   if (context_md->m_map_completer) {
774     std::string namespace_string = decl->getDeclName().getAsString();
775 
776     context_md->m_map_completer->CompleteNamespaceMap(
777         new_map, ConstString(namespace_string.c_str()), parent_map);
778   }
779 
780   context_md->m_namespace_maps[decl] = new_map;
781 }
782 
783 void ClangASTImporter::ForgetDestination(clang::ASTContext *dst_ast) {
784   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
785 
786   if (log)
787     log->Printf("    [ClangASTImporter] Forgetting destination (ASTContext*)%p",
788                 static_cast<void *>(dst_ast));
789 
790   m_metadata_map.erase(dst_ast);
791 }
792 
793 void ClangASTImporter::ForgetSource(clang::ASTContext *dst_ast,
794                                     clang::ASTContext *src_ast) {
795   ASTContextMetadataSP md = MaybeGetContextMetadata(dst_ast);
796 
797   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
798 
799   if (log)
800     log->Printf("    [ClangASTImporter] Forgetting source->dest "
801                 "(ASTContext*)%p->(ASTContext*)%p",
802                 static_cast<void *>(src_ast), static_cast<void *>(dst_ast));
803 
804   if (!md)
805     return;
806 
807   md->m_minions.erase(src_ast);
808 
809   for (OriginMap::iterator iter = md->m_origins.begin();
810        iter != md->m_origins.end();) {
811     if (iter->second.ctx == src_ast)
812       md->m_origins.erase(iter++);
813     else
814       ++iter;
815   }
816 }
817 
818 ClangASTImporter::MapCompleter::~MapCompleter() { return; }
819 
820 void ClangASTImporter::Minion::InitDeportWorkQueues(
821     std::set<clang::NamedDecl *> *decls_to_deport,
822     std::set<clang::NamedDecl *> *decls_already_deported) {
823   assert(!m_decls_to_deport);
824   assert(!m_decls_already_deported);
825 
826   m_decls_to_deport = decls_to_deport;
827   m_decls_already_deported = decls_already_deported;
828 }
829 
830 void ClangASTImporter::Minion::ExecuteDeportWorkQueues() {
831   assert(m_decls_to_deport);
832   assert(m_decls_already_deported);
833 
834   ASTContextMetadataSP to_context_md =
835       m_master.GetContextMetadata(&getToContext());
836 
837   while (!m_decls_to_deport->empty()) {
838     NamedDecl *decl = *m_decls_to_deport->begin();
839 
840     m_decls_already_deported->insert(decl);
841     m_decls_to_deport->erase(decl);
842 
843     DeclOrigin &origin = to_context_md->m_origins[decl];
844     UNUSED_IF_ASSERT_DISABLED(origin);
845 
846     assert(origin.ctx ==
847            m_source_ctx); // otherwise we should never have added this
848                           // because it doesn't need to be deported
849 
850     Decl *original_decl = to_context_md->m_origins[decl].decl;
851 
852     ClangASTContext::GetCompleteDecl(m_source_ctx, original_decl);
853 
854     if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl)) {
855       if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl)) {
856         if (original_tag_decl->isCompleteDefinition()) {
857           ImportDefinitionTo(tag_decl, original_tag_decl);
858           tag_decl->setCompleteDefinition(true);
859         }
860       }
861 
862       tag_decl->setHasExternalLexicalStorage(false);
863       tag_decl->setHasExternalVisibleStorage(false);
864     } else if (ObjCContainerDecl *container_decl =
865                    dyn_cast<ObjCContainerDecl>(decl)) {
866       container_decl->setHasExternalLexicalStorage(false);
867       container_decl->setHasExternalVisibleStorage(false);
868     }
869 
870     to_context_md->m_origins.erase(decl);
871   }
872 
873   m_decls_to_deport = nullptr;
874   m_decls_already_deported = nullptr;
875 }
876 
877 void ClangASTImporter::Minion::ImportDefinitionTo(clang::Decl *to,
878                                                   clang::Decl *from) {
879   ASTImporter::Imported(from, to);
880 
881   /*
882   if (to_objc_interface)
883       to_objc_interface->startDefinition();
884 
885   CXXRecordDecl *to_cxx_record = dyn_cast<CXXRecordDecl>(to);
886 
887   if (to_cxx_record)
888       to_cxx_record->startDefinition();
889   */
890 
891   ImportDefinition(from);
892 
893   if (clang::TagDecl *to_tag = dyn_cast<clang::TagDecl>(to)) {
894     if (clang::TagDecl *from_tag = dyn_cast<clang::TagDecl>(from)) {
895       to_tag->setCompleteDefinition(from_tag->isCompleteDefinition());
896     }
897   }
898 
899   // If we're dealing with an Objective-C class, ensure that the inheritance has
900   // been set up correctly.  The ASTImporter may not do this correctly if the
901   // class was originally sourced from symbols.
902 
903   if (ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to)) {
904     do {
905       ObjCInterfaceDecl *to_superclass = to_objc_interface->getSuperClass();
906 
907       if (to_superclass)
908         break; // we're not going to override it if it's set
909 
910       ObjCInterfaceDecl *from_objc_interface =
911           dyn_cast<ObjCInterfaceDecl>(from);
912 
913       if (!from_objc_interface)
914         break;
915 
916       ObjCInterfaceDecl *from_superclass = from_objc_interface->getSuperClass();
917 
918       if (!from_superclass)
919         break;
920 
921       Decl *imported_from_superclass_decl = Import(from_superclass);
922 
923       if (!imported_from_superclass_decl)
924         break;
925 
926       ObjCInterfaceDecl *imported_from_superclass =
927           dyn_cast<ObjCInterfaceDecl>(imported_from_superclass_decl);
928 
929       if (!imported_from_superclass)
930         break;
931 
932       if (!to_objc_interface->hasDefinition())
933         to_objc_interface->startDefinition();
934 
935       to_objc_interface->setSuperClass(m_source_ctx->getTrivialTypeSourceInfo(
936           m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
937     } while (0);
938   }
939 }
940 
941 clang::Decl *ClangASTImporter::Minion::Imported(clang::Decl *from,
942                                                 clang::Decl *to) {
943   ClangASTMetrics::RegisterClangImport();
944 
945   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
946 
947   lldb::user_id_t user_id = LLDB_INVALID_UID;
948   ClangASTMetadata *metadata = m_master.GetDeclMetadata(from);
949   if (metadata)
950     user_id = metadata->GetUserID();
951 
952   if (log) {
953     if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from)) {
954       std::string name_string;
955       llvm::raw_string_ostream name_stream(name_string);
956       from_named_decl->printName(name_stream);
957       name_stream.flush();
958 
959       log->Printf("    [ClangASTImporter] Imported (%sDecl*)%p, named %s (from "
960                   "(Decl*)%p), metadata 0x%" PRIx64,
961                   from->getDeclKindName(), static_cast<void *>(to),
962                   name_string.c_str(), static_cast<void *>(from), user_id);
963     } else {
964       log->Printf("    [ClangASTImporter] Imported (%sDecl*)%p (from "
965                   "(Decl*)%p), metadata 0x%" PRIx64,
966                   from->getDeclKindName(), static_cast<void *>(to),
967                   static_cast<void *>(from), user_id);
968     }
969   }
970 
971   ASTContextMetadataSP to_context_md =
972       m_master.GetContextMetadata(&to->getASTContext());
973   ASTContextMetadataSP from_context_md =
974       m_master.MaybeGetContextMetadata(m_source_ctx);
975 
976   if (from_context_md) {
977     OriginMap &origins = from_context_md->m_origins;
978 
979     OriginMap::iterator origin_iter = origins.find(from);
980 
981     if (origin_iter != origins.end()) {
982       if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
983           user_id != LLDB_INVALID_UID) {
984         if (origin_iter->second.ctx != &to->getASTContext())
985           to_context_md->m_origins[to] = origin_iter->second;
986       }
987 
988       MinionSP direct_completer =
989           m_master.GetMinion(&to->getASTContext(), origin_iter->second.ctx);
990 
991       if (direct_completer.get() != this)
992         direct_completer->ASTImporter::Imported(origin_iter->second.decl, to);
993 
994       if (log)
995         log->Printf("    [ClangASTImporter] Propagated origin "
996                     "(Decl*)%p/(ASTContext*)%p from (ASTContext*)%p to "
997                     "(ASTContext*)%p",
998                     static_cast<void *>(origin_iter->second.decl),
999                     static_cast<void *>(origin_iter->second.ctx),
1000                     static_cast<void *>(&from->getASTContext()),
1001                     static_cast<void *>(&to->getASTContext()));
1002     } else {
1003       if (m_decls_to_deport && m_decls_already_deported) {
1004         if (isa<TagDecl>(to) || isa<ObjCInterfaceDecl>(to)) {
1005           RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from);
1006           if (from_record_decl == nullptr ||
1007               from_record_decl->isInjectedClassName() == false) {
1008             NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to);
1009 
1010             if (!m_decls_already_deported->count(to_named_decl))
1011               m_decls_to_deport->insert(to_named_decl);
1012           }
1013         }
1014       }
1015 
1016       if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
1017           user_id != LLDB_INVALID_UID) {
1018         to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from);
1019       }
1020 
1021       if (log)
1022         log->Printf("    [ClangASTImporter] Decl has no origin information in "
1023                     "(ASTContext*)%p",
1024                     static_cast<void *>(&from->getASTContext()));
1025     }
1026 
1027     if (clang::NamespaceDecl *to_namespace =
1028             dyn_cast<clang::NamespaceDecl>(to)) {
1029       clang::NamespaceDecl *from_namespace =
1030           dyn_cast<clang::NamespaceDecl>(from);
1031 
1032       NamespaceMetaMap &namespace_maps = from_context_md->m_namespace_maps;
1033 
1034       NamespaceMetaMap::iterator namespace_map_iter =
1035           namespace_maps.find(from_namespace);
1036 
1037       if (namespace_map_iter != namespace_maps.end())
1038         to_context_md->m_namespace_maps[to_namespace] =
1039             namespace_map_iter->second;
1040     }
1041   } else {
1042     to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from);
1043 
1044     if (log)
1045       log->Printf("    [ClangASTImporter] Sourced origin "
1046                   "(Decl*)%p/(ASTContext*)%p into (ASTContext*)%p",
1047                   static_cast<void *>(from), static_cast<void *>(m_source_ctx),
1048                   static_cast<void *>(&to->getASTContext()));
1049   }
1050 
1051   if (TagDecl *from_tag_decl = dyn_cast<TagDecl>(from)) {
1052     TagDecl *to_tag_decl = dyn_cast<TagDecl>(to);
1053 
1054     to_tag_decl->setHasExternalLexicalStorage();
1055     to_tag_decl->setMustBuildLookupTable();
1056 
1057     if (log)
1058       log->Printf(
1059           "    [ClangASTImporter] To is a TagDecl - attributes %s%s [%s->%s]",
1060           (to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
1061           (to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""),
1062           (from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"),
1063           (to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"));
1064   }
1065 
1066   if (isa<NamespaceDecl>(from)) {
1067     NamespaceDecl *to_namespace_decl = dyn_cast<NamespaceDecl>(to);
1068 
1069     m_master.BuildNamespaceMap(to_namespace_decl);
1070 
1071     to_namespace_decl->setHasExternalVisibleStorage();
1072   }
1073 
1074   if (isa<ObjCContainerDecl>(from)) {
1075     ObjCContainerDecl *to_container_decl = dyn_cast<ObjCContainerDecl>(to);
1076 
1077     to_container_decl->setHasExternalLexicalStorage();
1078     to_container_decl->setHasExternalVisibleStorage();
1079 
1080     /*to_interface_decl->setExternallyCompleted();*/
1081 
1082     if (log) {
1083       if (ObjCInterfaceDecl *to_interface_decl =
1084               llvm::dyn_cast<ObjCInterfaceDecl>(to_container_decl)) {
1085         log->Printf(
1086             "    [ClangASTImporter] To is an ObjCInterfaceDecl - attributes "
1087             "%s%s%s",
1088             (to_interface_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
1089             (to_interface_decl->hasExternalVisibleStorage() ? " Visible" : ""),
1090             (to_interface_decl->hasDefinition() ? " HasDefinition" : ""));
1091       } else {
1092         log->Printf(
1093             "    [ClangASTImporter] To is an %sDecl - attributes %s%s",
1094             ((Decl *)to_container_decl)->getDeclKindName(),
1095             (to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
1096             (to_container_decl->hasExternalVisibleStorage() ? " Visible" : ""));
1097       }
1098     }
1099   }
1100 
1101   return clang::ASTImporter::Imported(from, to);
1102 }
1103 
1104 clang::Decl *ClangASTImporter::Minion::GetOriginalDecl(clang::Decl *To) {
1105   ASTContextMetadataSP to_context_md =
1106       m_master.GetContextMetadata(&To->getASTContext());
1107 
1108   if (!to_context_md)
1109     return nullptr;
1110 
1111   OriginMap::iterator iter = to_context_md->m_origins.find(To);
1112 
1113   if (iter == to_context_md->m_origins.end())
1114     return nullptr;
1115 
1116   return const_cast<clang::Decl *>(iter->second.decl);
1117 }
1118