ClangASTImporter.cpp revision 314564 
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/Log.h"
12#include "lldb/Core/Module.h"
13#include "lldb/Symbol/ClangASTContext.h"
14#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
15#include "lldb/Symbol/ClangUtil.h"
16#include "lldb/Utility/LLDBAssert.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
22using namespace lldb_private;
23using namespace clang;
24
25ClangASTMetrics::Counters ClangASTMetrics::global_counters = {0, 0, 0, 0, 0, 0};
26ClangASTMetrics::Counters ClangASTMetrics::local_counters = {0, 0, 0, 0, 0, 0};
27
28void 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
44void 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
55clang::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
66lldb::opaque_compiler_type_t
67ClangASTImporter::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
74CompilerType 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
94clang::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
131class DeclContextOverride {
132private:
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
212public:
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
237lldb::opaque_compiler_type_t
238ClangASTImporter::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
278clang::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
319bool 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
397bool 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
473bool 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
487bool 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
516void ClangASTImporter::InsertRecordDecl(clang::RecordDecl *decl,
517                                        const LayoutInfo &layout) {
518  m_record_decl_to_layout_map.insert(std::make_pair(decl, layout));
519}
520
521void 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
548bool 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
567bool 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
590bool 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
614bool 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
668bool 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
697ClangASTMetadata *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
706ClangASTImporter::DeclOrigin
707ClangASTImporter::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
720void 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
736void 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
743ClangASTImporter::NamespaceMapSP
744ClangASTImporter::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
757void 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
783void 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
793void 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
818ClangASTImporter::MapCompleter::~MapCompleter() { return; }
819
820void 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
830void 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
877void 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
941clang::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
1104clang::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