99558cc424
Create a new "lldb_private::CompilerDeclContext" class that will replace all direct uses of "clang::DeclContext" when used in compiler agnostic code, yet still allow for conversion to clang::DeclContext subclasses by clang specific code. This completes the abstraction of type parsing by removing all "clang::" references from the SymbolFileDWARF. The new "lldb_private::CompilerDeclContext" class abstracts decl contexts found in compiler type systems so they can be used in internal API calls. The TypeSystem is required to support CompilerDeclContexts with new pure virtual functions that start with "DeclContext" in the member function names. Converted all code that used lldb_private::ClangNamespaceDecl over to use the new CompilerDeclContext class and removed the ClangNamespaceDecl.cpp and ClangNamespaceDecl.h files.
Removed direct use of clang APIs from SBType and now use the abstract type systems to correctly explore types.
Bulk renames for things that used to return a ClangASTType which is now CompilerType:
"Type::GetClangFullType()" to "Type::GetFullCompilerType()"
"Type::GetClangLayoutType()" to "Type::GetLayoutCompilerType()"
"Type::GetClangForwardType()" to "Type::GetForwardCompilerType()"
"Value::GetClangType()" to "Value::GetCompilerType()"
"Value::SetClangType (const CompilerType &)" to "Value::SetCompilerType (const CompilerType &)"
"ValueObject::GetClangType ()" to "ValueObject::GetCompilerType()"
many more renames that are similar.
llvm-svn: 245905
886 lines
28 KiB
C++
886 lines
28 KiB
C++
//===-- ClangASTImporter.cpp ------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/DeclCXX.h"
|
|
#include "clang/AST/DeclObjC.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Symbol/ClangASTContext.h"
|
|
#include "lldb/Symbol/ClangASTImporter.h"
|
|
#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
|
|
#include "lldb/Utility/LLDBAssert.h"
|
|
|
|
using namespace lldb_private;
|
|
using namespace clang;
|
|
|
|
ClangASTMetrics::Counters ClangASTMetrics::global_counters = { 0, 0, 0, 0, 0, 0 };
|
|
ClangASTMetrics::Counters ClangASTMetrics::local_counters = { 0, 0, 0, 0, 0, 0 };
|
|
|
|
void ClangASTMetrics::DumpCounters (Log *log, ClangASTMetrics::Counters &counters)
|
|
{
|
|
log->Printf(" Number of visible Decl queries by name : %" PRIu64, counters.m_visible_query_count);
|
|
log->Printf(" Number of lexical Decl queries : %" PRIu64, counters.m_lexical_query_count);
|
|
log->Printf(" Number of imports initiated by LLDB : %" PRIu64, counters.m_lldb_import_count);
|
|
log->Printf(" Number of imports conducted by Clang : %" PRIu64, counters.m_clang_import_count);
|
|
log->Printf(" Number of Decls completed : %" PRIu64, counters.m_decls_completed_count);
|
|
log->Printf(" Number of records laid out : %" PRIu64, counters.m_record_layout_count);
|
|
}
|
|
|
|
void ClangASTMetrics::DumpCounters (Log *log)
|
|
{
|
|
if (!log)
|
|
return;
|
|
|
|
log->Printf("== ClangASTMetrics output ==");
|
|
log->Printf("-- Global metrics --");
|
|
DumpCounters (log, global_counters);
|
|
log->Printf("-- Local metrics --");
|
|
DumpCounters (log, local_counters);
|
|
}
|
|
|
|
clang::QualType
|
|
ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
|
|
clang::ASTContext *src_ast,
|
|
clang::QualType type)
|
|
{
|
|
MinionSP minion_sp (GetMinion(dst_ast, src_ast));
|
|
|
|
if (minion_sp)
|
|
return minion_sp->Import(type);
|
|
|
|
return QualType();
|
|
}
|
|
|
|
lldb::clang_type_t
|
|
ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
|
|
clang::ASTContext *src_ast,
|
|
lldb::clang_type_t type)
|
|
{
|
|
return CopyType (dst_ast, src_ast, QualType::getFromOpaquePtr(type)).getAsOpaquePtr();
|
|
}
|
|
|
|
clang::Decl *
|
|
ClangASTImporter::CopyDecl (clang::ASTContext *dst_ast,
|
|
clang::ASTContext *src_ast,
|
|
clang::Decl *decl)
|
|
{
|
|
MinionSP minion_sp;
|
|
|
|
minion_sp = GetMinion(dst_ast, src_ast);
|
|
|
|
if (minion_sp)
|
|
{
|
|
clang::Decl *result = minion_sp->Import(decl);
|
|
|
|
if (!result)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
|
|
if (log)
|
|
{
|
|
lldb::user_id_t user_id = LLDB_INVALID_UID;
|
|
ClangASTMetadata *metadata = GetDeclMetadata(decl);
|
|
if (metadata)
|
|
user_id = metadata->GetUserID();
|
|
|
|
if (NamedDecl *named_decl = dyn_cast<NamedDecl>(decl))
|
|
log->Printf(" [ClangASTImporter] WARNING: Failed to import a %s '%s', metadata 0x%" PRIx64,
|
|
decl->getDeclKindName(),
|
|
named_decl->getNameAsString().c_str(),
|
|
user_id);
|
|
else
|
|
log->Printf(" [ClangASTImporter] WARNING: Failed to import a %s, metadata 0x%" PRIx64,
|
|
decl->getDeclKindName(),
|
|
user_id);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
class DeclContextOverride
|
|
{
|
|
private:
|
|
struct Backup
|
|
{
|
|
clang::DeclContext *decl_context;
|
|
clang::DeclContext *lexical_decl_context;
|
|
};
|
|
|
|
std::map<clang::Decl *, Backup> m_backups;
|
|
|
|
void OverrideOne(clang::Decl *decl)
|
|
{
|
|
if (m_backups.find(decl) != m_backups.end())
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_backups[decl] = { decl->getDeclContext(), decl->getLexicalDeclContext() };
|
|
|
|
decl->setDeclContext(decl->getASTContext().getTranslationUnitDecl());
|
|
decl->setLexicalDeclContext(decl->getASTContext().getTranslationUnitDecl());
|
|
}
|
|
|
|
bool ChainPassesThrough(clang::Decl *decl,
|
|
clang::DeclContext *base,
|
|
clang::DeclContext *(clang::Decl::*contextFromDecl)(),
|
|
clang::DeclContext *(clang::DeclContext::*contextFromContext)())
|
|
{
|
|
for (DeclContext *decl_ctx = (decl->*contextFromDecl)();
|
|
decl_ctx;
|
|
decl_ctx = (decl_ctx->*contextFromContext)())
|
|
{
|
|
if (decl_ctx == base)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
clang::Decl *GetEscapedChild(clang::Decl *decl, clang::DeclContext *base = nullptr)
|
|
{
|
|
if (base)
|
|
{
|
|
// decl's DeclContext chains must pass through base.
|
|
|
|
if (!ChainPassesThrough(decl, base, &clang::Decl::getDeclContext, &clang::DeclContext::getParent) ||
|
|
!ChainPassesThrough(decl, base, &clang::Decl::getLexicalDeclContext, &clang::DeclContext::getLexicalParent))
|
|
{
|
|
return decl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
base = clang::dyn_cast<clang::DeclContext>(decl);
|
|
|
|
if (!base)
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
if (clang::DeclContext *context = clang::dyn_cast<clang::DeclContext>(decl))
|
|
{
|
|
for (clang::Decl *decl : context->decls())
|
|
{
|
|
if (clang::Decl *escaped_child = GetEscapedChild(decl))
|
|
{
|
|
return escaped_child;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void Override(clang::Decl *decl)
|
|
{
|
|
if (clang::Decl *escaped_child = GetEscapedChild(decl))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] DeclContextOverride couldn't override (%sDecl*)%p - its child (%sDecl*)%p escapes",
|
|
decl->getDeclKindName(), static_cast<void*>(decl),
|
|
escaped_child->getDeclKindName(), static_cast<void*>(escaped_child));
|
|
lldbassert(0 && "Couldn't override!");
|
|
}
|
|
|
|
OverrideOne(decl);
|
|
}
|
|
|
|
public:
|
|
DeclContextOverride()
|
|
{
|
|
}
|
|
|
|
void OverrideAllDeclsFromContainingFunction(clang::Decl *decl)
|
|
{
|
|
for (DeclContext *decl_context = decl->getLexicalDeclContext();
|
|
decl_context;
|
|
decl_context = decl_context->getLexicalParent())
|
|
{
|
|
DeclContext *redecl_context = decl_context->getRedeclContext();
|
|
|
|
if (llvm::isa<FunctionDecl>(redecl_context) &&
|
|
llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent()))
|
|
{
|
|
for (clang::Decl *child_decl : decl_context->decls())
|
|
{
|
|
Override(child_decl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
~DeclContextOverride()
|
|
{
|
|
for (const std::pair<clang::Decl *, Backup> &backup : m_backups)
|
|
{
|
|
backup.first->setDeclContext(backup.second.decl_context);
|
|
backup.first->setLexicalDeclContext(backup.second.lexical_decl_context);
|
|
}
|
|
}
|
|
};
|
|
|
|
lldb::clang_type_t
|
|
ClangASTImporter::DeportType (clang::ASTContext *dst_ctx,
|
|
clang::ASTContext *src_ctx,
|
|
lldb::clang_type_t type)
|
|
{
|
|
MinionSP minion_sp (GetMinion (dst_ctx, src_ctx));
|
|
|
|
if (!minion_sp)
|
|
return nullptr;
|
|
|
|
std::set<NamedDecl *> decls_to_deport;
|
|
std::set<NamedDecl *> decls_already_deported;
|
|
|
|
DeclContextOverride decl_context_override;
|
|
|
|
if (const clang::TagType *tag_type = clang::QualType::getFromOpaquePtr(type)->getAs<TagType>())
|
|
{
|
|
decl_context_override.OverrideAllDeclsFromContainingFunction(tag_type->getDecl());
|
|
}
|
|
|
|
minion_sp->InitDeportWorkQueues(&decls_to_deport,
|
|
&decls_already_deported);
|
|
|
|
lldb::clang_type_t result = CopyType(dst_ctx, src_ctx, type);
|
|
|
|
minion_sp->ExecuteDeportWorkQueues();
|
|
|
|
if (!result)
|
|
return nullptr;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
clang::Decl *
|
|
ClangASTImporter::DeportDecl (clang::ASTContext *dst_ctx,
|
|
clang::ASTContext *src_ctx,
|
|
clang::Decl *decl)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] DeportDecl called on (%sDecl*)%p from (ASTContext*)%p to (ASTContex*)%p",
|
|
decl->getDeclKindName(), static_cast<void*>(decl),
|
|
static_cast<void*>(src_ctx),
|
|
static_cast<void*>(dst_ctx));
|
|
|
|
MinionSP minion_sp (GetMinion (dst_ctx, src_ctx));
|
|
|
|
if (!minion_sp)
|
|
return nullptr;
|
|
|
|
std::set<NamedDecl *> decls_to_deport;
|
|
std::set<NamedDecl *> decls_already_deported;
|
|
|
|
DeclContextOverride decl_context_override;
|
|
|
|
decl_context_override.OverrideAllDeclsFromContainingFunction(decl);
|
|
|
|
minion_sp->InitDeportWorkQueues(&decls_to_deport,
|
|
&decls_already_deported);
|
|
|
|
clang::Decl *result = CopyDecl(dst_ctx, src_ctx, decl);
|
|
|
|
minion_sp->ExecuteDeportWorkQueues();
|
|
|
|
if (!result)
|
|
return nullptr;
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] DeportDecl deported (%sDecl*)%p to (%sDecl*)%p",
|
|
decl->getDeclKindName(), static_cast<void*>(decl),
|
|
result->getDeclKindName(), static_cast<void*>(result));
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::CompleteDecl (clang::Decl *decl)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] CompleteDecl called on (%sDecl*)%p",
|
|
decl->getDeclKindName(), static_cast<void*>(decl));
|
|
|
|
if (ObjCInterfaceDecl *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl))
|
|
{
|
|
if (!interface_decl->getDefinition())
|
|
{
|
|
interface_decl->startDefinition();
|
|
CompleteObjCInterfaceDecl(interface_decl);
|
|
}
|
|
}
|
|
else if (ObjCProtocolDecl *protocol_decl = dyn_cast<ObjCProtocolDecl>(decl))
|
|
{
|
|
if (!protocol_decl->getDefinition())
|
|
protocol_decl->startDefinition();
|
|
}
|
|
else if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl))
|
|
{
|
|
if (!tag_decl->getDefinition() && !tag_decl->isBeingDefined())
|
|
{
|
|
tag_decl->startDefinition();
|
|
CompleteTagDecl(tag_decl);
|
|
tag_decl->setCompleteDefinition(true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assert (0 && "CompleteDecl called on a Decl that can't be completed");
|
|
}
|
|
}
|
|
|
|
bool
|
|
ClangASTImporter::CompleteTagDecl (clang::TagDecl *decl)
|
|
{
|
|
ClangASTMetrics::RegisterDeclCompletion();
|
|
|
|
DeclOrigin decl_origin = GetDeclOrigin(decl);
|
|
|
|
if (!decl_origin.Valid())
|
|
return false;
|
|
|
|
if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
|
|
return false;
|
|
|
|
MinionSP minion_sp (GetMinion(&decl->getASTContext(), decl_origin.ctx));
|
|
|
|
if (minion_sp)
|
|
minion_sp->ImportDefinitionTo(decl, decl_origin.decl);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl, clang::TagDecl *origin_decl)
|
|
{
|
|
ClangASTMetrics::RegisterDeclCompletion();
|
|
|
|
clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
|
|
|
|
if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl))
|
|
return false;
|
|
|
|
MinionSP minion_sp (GetMinion(&decl->getASTContext(), origin_ast_ctx));
|
|
|
|
if (minion_sp)
|
|
minion_sp->ImportDefinitionTo(decl, origin_decl);
|
|
|
|
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
|
|
|
|
OriginMap &origins = context_md->m_origins;
|
|
|
|
origins[decl] = DeclOrigin(origin_ast_ctx, origin_decl);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ClangASTImporter::CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl)
|
|
{
|
|
ClangASTMetrics::RegisterDeclCompletion();
|
|
|
|
DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
|
|
|
|
if (!decl_origin.Valid())
|
|
return false;
|
|
|
|
if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
|
|
return false;
|
|
|
|
MinionSP minion_sp (GetMinion(&interface_decl->getASTContext(), decl_origin.ctx));
|
|
|
|
if (minion_sp)
|
|
minion_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);
|
|
|
|
if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass())
|
|
RequireCompleteType(clang::QualType(super_class->getTypeForDecl(), 0));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ClangASTImporter::RequireCompleteType (clang::QualType type)
|
|
{
|
|
if (type.isNull())
|
|
return false;
|
|
|
|
if (const TagType *tag_type = type->getAs<TagType>())
|
|
{
|
|
TagDecl *tag_decl = tag_type->getDecl();
|
|
|
|
if (tag_decl->getDefinition() || tag_decl->isBeingDefined())
|
|
return true;
|
|
|
|
return CompleteTagDecl(tag_decl);
|
|
}
|
|
if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>())
|
|
{
|
|
if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface())
|
|
return CompleteObjCInterfaceDecl(objc_interface_decl);
|
|
else
|
|
return false;
|
|
}
|
|
if (const ArrayType *array_type = type->getAsArrayTypeUnsafe())
|
|
{
|
|
return RequireCompleteType(array_type->getElementType());
|
|
}
|
|
if (const AtomicType *atomic_type = type->getAs<AtomicType>())
|
|
{
|
|
return RequireCompleteType(atomic_type->getPointeeType());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ClangASTMetadata *
|
|
ClangASTImporter::GetDeclMetadata (const clang::Decl *decl)
|
|
{
|
|
DeclOrigin decl_origin = GetDeclOrigin(decl);
|
|
|
|
if (decl_origin.Valid())
|
|
return ClangASTContext::GetMetadata(decl_origin.ctx, decl_origin.decl);
|
|
else
|
|
return ClangASTContext::GetMetadata(&decl->getASTContext(), decl);
|
|
}
|
|
|
|
ClangASTImporter::DeclOrigin
|
|
ClangASTImporter::GetDeclOrigin(const clang::Decl *decl)
|
|
{
|
|
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
|
|
|
|
OriginMap &origins = context_md->m_origins;
|
|
|
|
OriginMap::iterator iter = origins.find(decl);
|
|
|
|
if (iter != origins.end())
|
|
return iter->second;
|
|
else
|
|
return DeclOrigin();
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::SetDeclOrigin (const clang::Decl *decl, clang::Decl *original_decl)
|
|
{
|
|
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
|
|
|
|
OriginMap &origins = context_md->m_origins;
|
|
|
|
OriginMap::iterator iter = origins.find(decl);
|
|
|
|
if (iter != origins.end())
|
|
{
|
|
iter->second.decl = original_decl;
|
|
iter->second.ctx = &original_decl->getASTContext();
|
|
}
|
|
else
|
|
{
|
|
origins[decl] = DeclOrigin(&original_decl->getASTContext(), original_decl);
|
|
}
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::RegisterNamespaceMap(const clang::NamespaceDecl *decl,
|
|
NamespaceMapSP &namespace_map)
|
|
{
|
|
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
|
|
|
|
context_md->m_namespace_maps[decl] = namespace_map;
|
|
}
|
|
|
|
ClangASTImporter::NamespaceMapSP
|
|
ClangASTImporter::GetNamespaceMap(const clang::NamespaceDecl *decl)
|
|
{
|
|
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
|
|
|
|
NamespaceMetaMap &namespace_maps = context_md->m_namespace_maps;
|
|
|
|
NamespaceMetaMap::iterator iter = namespace_maps.find(decl);
|
|
|
|
if (iter != namespace_maps.end())
|
|
return iter->second;
|
|
else
|
|
return NamespaceMapSP();
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl)
|
|
{
|
|
assert (decl);
|
|
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
|
|
|
|
const DeclContext *parent_context = decl->getDeclContext();
|
|
const NamespaceDecl *parent_namespace = dyn_cast<NamespaceDecl>(parent_context);
|
|
NamespaceMapSP parent_map;
|
|
|
|
if (parent_namespace)
|
|
parent_map = GetNamespaceMap(parent_namespace);
|
|
|
|
NamespaceMapSP new_map;
|
|
|
|
new_map.reset(new NamespaceMap);
|
|
|
|
if (context_md->m_map_completer)
|
|
{
|
|
std::string namespace_string = decl->getDeclName().getAsString();
|
|
|
|
context_md->m_map_completer->CompleteNamespaceMap (new_map, ConstString(namespace_string.c_str()), parent_map);
|
|
}
|
|
|
|
context_md->m_namespace_maps[decl] = new_map;
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::ForgetDestination (clang::ASTContext *dst_ast)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] Forgetting destination (ASTContext*)%p",
|
|
static_cast<void*>(dst_ast));
|
|
|
|
m_metadata_map.erase(dst_ast);
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::ForgetSource (clang::ASTContext *dst_ast, clang::ASTContext *src_ast)
|
|
{
|
|
ASTContextMetadataSP md = MaybeGetContextMetadata (dst_ast);
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] Forgetting source->dest (ASTContext*)%p->(ASTContext*)%p",
|
|
static_cast<void*>(src_ast), static_cast<void*>(dst_ast));
|
|
|
|
if (!md)
|
|
return;
|
|
|
|
md->m_minions.erase(src_ast);
|
|
|
|
for (OriginMap::iterator iter = md->m_origins.begin();
|
|
iter != md->m_origins.end();
|
|
)
|
|
{
|
|
if (iter->second.ctx == src_ast)
|
|
md->m_origins.erase(iter++);
|
|
else
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
ClangASTImporter::MapCompleter::~MapCompleter ()
|
|
{
|
|
return;
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::Minion::InitDeportWorkQueues (std::set<clang::NamedDecl *> *decls_to_deport,
|
|
std::set<clang::NamedDecl *> *decls_already_deported)
|
|
{
|
|
assert(!m_decls_to_deport); // TODO make debug only
|
|
assert(!m_decls_already_deported);
|
|
|
|
m_decls_to_deport = decls_to_deport;
|
|
m_decls_already_deported = decls_already_deported;
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::Minion::ExecuteDeportWorkQueues ()
|
|
{
|
|
assert(m_decls_to_deport); // TODO make debug only
|
|
assert(m_decls_already_deported);
|
|
|
|
ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&getToContext());
|
|
|
|
while (!m_decls_to_deport->empty())
|
|
{
|
|
NamedDecl *decl = *m_decls_to_deport->begin();
|
|
|
|
m_decls_already_deported->insert(decl);
|
|
m_decls_to_deport->erase(decl);
|
|
|
|
DeclOrigin &origin = to_context_md->m_origins[decl];
|
|
UNUSED_IF_ASSERT_DISABLED(origin);
|
|
|
|
assert (origin.ctx == m_source_ctx); // otherwise we should never have added this
|
|
// because it doesn't need to be deported
|
|
|
|
Decl *original_decl = to_context_md->m_origins[decl].decl;
|
|
|
|
ClangASTContext::GetCompleteDecl (m_source_ctx, original_decl);
|
|
|
|
if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl))
|
|
{
|
|
if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl))
|
|
if (original_tag_decl->isCompleteDefinition())
|
|
ImportDefinitionTo(tag_decl, original_tag_decl);
|
|
|
|
tag_decl->setHasExternalLexicalStorage(false);
|
|
tag_decl->setHasExternalVisibleStorage(false);
|
|
}
|
|
else if (ObjCInterfaceDecl *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl))
|
|
{
|
|
interface_decl->setHasExternalLexicalStorage(false);
|
|
interface_decl->setHasExternalVisibleStorage(false);
|
|
}
|
|
|
|
to_context_md->m_origins.erase(decl);
|
|
}
|
|
|
|
m_decls_to_deport = nullptr;
|
|
m_decls_already_deported = nullptr;
|
|
}
|
|
|
|
void
|
|
ClangASTImporter::Minion::ImportDefinitionTo (clang::Decl *to, clang::Decl *from)
|
|
{
|
|
ASTImporter::Imported(from, to);
|
|
|
|
ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to);
|
|
|
|
/*
|
|
if (to_objc_interface)
|
|
to_objc_interface->startDefinition();
|
|
|
|
CXXRecordDecl *to_cxx_record = dyn_cast<CXXRecordDecl>(to);
|
|
|
|
if (to_cxx_record)
|
|
to_cxx_record->startDefinition();
|
|
*/
|
|
|
|
ImportDefinition(from);
|
|
|
|
// If we're dealing with an Objective-C class, ensure that the inheritance has
|
|
// been set up correctly. The ASTImporter may not do this correctly if the
|
|
// class was originally sourced from symbols.
|
|
|
|
if (to_objc_interface)
|
|
{
|
|
do
|
|
{
|
|
ObjCInterfaceDecl *to_superclass = to_objc_interface->getSuperClass();
|
|
|
|
if (to_superclass)
|
|
break; // we're not going to override it if it's set
|
|
|
|
ObjCInterfaceDecl *from_objc_interface = dyn_cast<ObjCInterfaceDecl>(from);
|
|
|
|
if (!from_objc_interface)
|
|
break;
|
|
|
|
ObjCInterfaceDecl *from_superclass = from_objc_interface->getSuperClass();
|
|
|
|
if (!from_superclass)
|
|
break;
|
|
|
|
Decl *imported_from_superclass_decl = Import(from_superclass);
|
|
|
|
if (!imported_from_superclass_decl)
|
|
break;
|
|
|
|
ObjCInterfaceDecl *imported_from_superclass = dyn_cast<ObjCInterfaceDecl>(imported_from_superclass_decl);
|
|
|
|
if (!imported_from_superclass)
|
|
break;
|
|
|
|
if (!to_objc_interface->hasDefinition())
|
|
to_objc_interface->startDefinition();
|
|
|
|
to_objc_interface->setSuperClass(
|
|
m_source_ctx->getTrivialTypeSourceInfo(m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
|
|
}
|
|
while (0);
|
|
}
|
|
}
|
|
|
|
clang::Decl *
|
|
ClangASTImporter::Minion::Imported (clang::Decl *from, clang::Decl *to)
|
|
{
|
|
ClangASTMetrics::RegisterClangImport();
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
|
|
|
|
lldb::user_id_t user_id = LLDB_INVALID_UID;
|
|
ClangASTMetadata *metadata = m_master.GetDeclMetadata(from);
|
|
if (metadata)
|
|
user_id = metadata->GetUserID();
|
|
|
|
if (log)
|
|
{
|
|
if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from))
|
|
{
|
|
std::string name_string;
|
|
llvm::raw_string_ostream name_stream(name_string);
|
|
from_named_decl->printName(name_stream);
|
|
name_stream.flush();
|
|
|
|
log->Printf(" [ClangASTImporter] Imported (%sDecl*)%p, named %s (from (Decl*)%p), metadata 0x%" PRIx64,
|
|
from->getDeclKindName(), static_cast<void*>(to),
|
|
name_string.c_str(), static_cast<void*>(from),
|
|
user_id);
|
|
}
|
|
else
|
|
{
|
|
log->Printf(" [ClangASTImporter] Imported (%sDecl*)%p (from (Decl*)%p), metadata 0x%" PRIx64,
|
|
from->getDeclKindName(), static_cast<void*>(to),
|
|
static_cast<void*>(from), user_id);
|
|
}
|
|
}
|
|
|
|
ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&to->getASTContext());
|
|
ASTContextMetadataSP from_context_md = m_master.MaybeGetContextMetadata(m_source_ctx);
|
|
|
|
if (from_context_md)
|
|
{
|
|
OriginMap &origins = from_context_md->m_origins;
|
|
|
|
OriginMap::iterator origin_iter = origins.find(from);
|
|
|
|
if (origin_iter != origins.end())
|
|
{
|
|
if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
|
|
user_id != LLDB_INVALID_UID)
|
|
{
|
|
if (origin_iter->second.ctx != &to->getASTContext())
|
|
to_context_md->m_origins[to] = origin_iter->second;
|
|
}
|
|
|
|
MinionSP direct_completer = m_master.GetMinion(&to->getASTContext(), origin_iter->second.ctx);
|
|
|
|
if (direct_completer.get() != this)
|
|
direct_completer->ASTImporter::Imported(origin_iter->second.decl, to);
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] Propagated origin (Decl*)%p/(ASTContext*)%p from (ASTContext*)%p to (ASTContext*)%p",
|
|
static_cast<void*>(origin_iter->second.decl),
|
|
static_cast<void*>(origin_iter->second.ctx),
|
|
static_cast<void*>(&from->getASTContext()),
|
|
static_cast<void*>(&to->getASTContext()));
|
|
}
|
|
else
|
|
{
|
|
if (m_decls_to_deport && m_decls_already_deported)
|
|
{
|
|
if (isa<TagDecl>(to) || isa<ObjCInterfaceDecl>(to))
|
|
{
|
|
NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to);
|
|
|
|
if (!m_decls_already_deported->count(to_named_decl))
|
|
m_decls_to_deport->insert(to_named_decl);
|
|
}
|
|
}
|
|
|
|
if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
|
|
user_id != LLDB_INVALID_UID)
|
|
{
|
|
to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from);
|
|
}
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] Decl has no origin information in (ASTContext*)%p",
|
|
static_cast<void*>(&from->getASTContext()));
|
|
}
|
|
|
|
if (clang::NamespaceDecl *to_namespace = dyn_cast<clang::NamespaceDecl>(to))
|
|
{
|
|
clang::NamespaceDecl *from_namespace = dyn_cast<clang::NamespaceDecl>(from);
|
|
|
|
NamespaceMetaMap &namespace_maps = from_context_md->m_namespace_maps;
|
|
|
|
NamespaceMetaMap::iterator namespace_map_iter = namespace_maps.find(from_namespace);
|
|
|
|
if (namespace_map_iter != namespace_maps.end())
|
|
to_context_md->m_namespace_maps[to_namespace] = namespace_map_iter->second;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
to_context_md->m_origins[to] = DeclOrigin (m_source_ctx, from);
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] Sourced origin (Decl*)%p/(ASTContext*)%p into (ASTContext*)%p",
|
|
static_cast<void*>(from),
|
|
static_cast<void*>(m_source_ctx),
|
|
static_cast<void*>(&to->getASTContext()));
|
|
}
|
|
|
|
if (TagDecl *from_tag_decl = dyn_cast<TagDecl>(from))
|
|
{
|
|
TagDecl *to_tag_decl = dyn_cast<TagDecl>(to);
|
|
|
|
to_tag_decl->setHasExternalLexicalStorage();
|
|
to_tag_decl->setMustBuildLookupTable();
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] To is a TagDecl - attributes %s%s [%s->%s]",
|
|
(to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
|
|
(to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""),
|
|
(from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"),
|
|
(to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"));
|
|
}
|
|
|
|
if (isa<NamespaceDecl>(from))
|
|
{
|
|
NamespaceDecl *to_namespace_decl = dyn_cast<NamespaceDecl>(to);
|
|
|
|
m_master.BuildNamespaceMap(to_namespace_decl);
|
|
|
|
to_namespace_decl->setHasExternalVisibleStorage();
|
|
}
|
|
|
|
if (isa<ObjCInterfaceDecl>(from))
|
|
{
|
|
ObjCInterfaceDecl *to_interface_decl = dyn_cast<ObjCInterfaceDecl>(to);
|
|
|
|
to_interface_decl->setHasExternalLexicalStorage();
|
|
to_interface_decl->setHasExternalVisibleStorage();
|
|
|
|
/*to_interface_decl->setExternallyCompleted();*/
|
|
|
|
if (log)
|
|
log->Printf(" [ClangASTImporter] To is an ObjCInterfaceDecl - attributes %s%s%s",
|
|
(to_interface_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
|
|
(to_interface_decl->hasExternalVisibleStorage() ? " Visible" : ""),
|
|
(to_interface_decl->hasDefinition() ? " HasDefinition" : ""));
|
|
}
|
|
|
|
return clang::ASTImporter::Imported(from, to);
|
|
}
|
|
|
|
clang::Decl *ClangASTImporter::Minion::GetOriginalDecl (clang::Decl *To)
|
|
{
|
|
ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&To->getASTContext());
|
|
|
|
if (!to_context_md)
|
|
return nullptr;
|
|
|
|
OriginMap::iterator iter = to_context_md->m_origins.find(To);
|
|
|
|
if (iter == to_context_md->m_origins.end())
|
|
return nullptr;
|
|
|
|
return const_cast<clang::Decl*>(iter->second.decl);
|
|
}
|