ff48e4bea0
This was causing code that opened multiple targets to try and get a path to debugserver from the GDB remote communication class, and it would get the LLDB path and some instances would return empty strings and it would cause debugserver to not be found. <rdar://problem/18756927> llvm-svn: 227935
375 lines
13 KiB
C++
375 lines
13 KiB
C++
//===-- ClangModulesDeclVendor.cpp ------------------------------*- C++ -*-===//
|
||
//
|
||
// The LLVM Compiler Infrastructure
|
||
//
|
||
// This file is distributed under the University of Illinois Open Source
|
||
// License. See LICENSE.TXT for details.
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#include <mutex> // std::once
|
||
|
||
#include "lldb/Expression/ClangModulesDeclVendor.h"
|
||
|
||
#include "lldb/Core/StreamString.h"
|
||
#include "lldb/Host/FileSpec.h"
|
||
#include "lldb/Host/Host.h"
|
||
#include "lldb/Host/HostInfo.h"
|
||
#include "lldb/Target/Target.h"
|
||
|
||
#include "clang/Basic/TargetInfo.h"
|
||
#include "clang/Frontend/CompilerInstance.h"
|
||
#include "clang/Frontend/FrontendActions.h"
|
||
#include "clang/Lex/Preprocessor.h"
|
||
#include "clang/Parse/Parser.h"
|
||
#include "clang/Sema/Lookup.h"
|
||
#include "clang/Serialization/ASTReader.h"
|
||
|
||
|
||
using namespace lldb_private;
|
||
|
||
namespace {
|
||
// Any Clang compiler requires a consumer for diagnostics. This one stores them as strings
|
||
// so we can provide them to the user in case a module failed to load.
|
||
class StoringDiagnosticConsumer : public clang::DiagnosticConsumer
|
||
{
|
||
public:
|
||
StoringDiagnosticConsumer ();
|
||
void
|
||
HandleDiagnostic (clang::DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &info);
|
||
|
||
void
|
||
ClearDiagnostics ();
|
||
|
||
void
|
||
DumpDiagnostics (Stream &error_stream);
|
||
private:
|
||
typedef std::pair<clang::DiagnosticsEngine::Level, std::string> IDAndDiagnostic;
|
||
std::vector<IDAndDiagnostic> m_diagnostics;
|
||
Log * m_log;
|
||
};
|
||
|
||
// The private implementation of our ClangModulesDeclVendor. Contains all the Clang state required
|
||
// to load modules.
|
||
class ClangModulesDeclVendorImpl : public ClangModulesDeclVendor
|
||
{
|
||
public:
|
||
ClangModulesDeclVendorImpl(llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> &diagnostics_engine,
|
||
llvm::IntrusiveRefCntPtr<clang::CompilerInvocation> &compiler_invocation,
|
||
std::unique_ptr<clang::CompilerInstance> &&compiler_instance,
|
||
std::unique_ptr<clang::Parser> &&parser);
|
||
|
||
virtual bool
|
||
AddModule(std::vector<llvm::StringRef> &path,
|
||
Stream &error_stream);
|
||
|
||
virtual uint32_t
|
||
FindDecls (const ConstString &name,
|
||
bool append,
|
||
uint32_t max_matches,
|
||
std::vector <clang::NamedDecl*> &decls);
|
||
|
||
~ClangModulesDeclVendorImpl();
|
||
|
||
private:
|
||
clang::ModuleLoadResult
|
||
DoGetModule(clang::ModuleIdPath path, bool make_visible);
|
||
|
||
llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> m_diagnostics_engine;
|
||
llvm::IntrusiveRefCntPtr<clang::CompilerInvocation> m_compiler_invocation;
|
||
std::unique_ptr<clang::CompilerInstance> m_compiler_instance;
|
||
std::unique_ptr<clang::Parser> m_parser;
|
||
};
|
||
}
|
||
|
||
StoringDiagnosticConsumer::StoringDiagnosticConsumer ()
|
||
{
|
||
m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
|
||
}
|
||
|
||
void
|
||
StoringDiagnosticConsumer::HandleDiagnostic (clang::DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &info)
|
||
{
|
||
llvm::SmallVector<char, 256> diagnostic_string;
|
||
|
||
info.FormatDiagnostic(diagnostic_string);
|
||
|
||
m_diagnostics.push_back(IDAndDiagnostic(DiagLevel, std::string(diagnostic_string.data(), diagnostic_string.size())));
|
||
}
|
||
|
||
void
|
||
StoringDiagnosticConsumer::ClearDiagnostics ()
|
||
{
|
||
m_diagnostics.clear();
|
||
}
|
||
|
||
void
|
||
StoringDiagnosticConsumer::DumpDiagnostics (Stream &error_stream)
|
||
{
|
||
for (IDAndDiagnostic &diag : m_diagnostics)
|
||
{
|
||
switch (diag.first)
|
||
{
|
||
default:
|
||
error_stream.PutCString(diag.second.c_str());
|
||
error_stream.PutChar('\n');
|
||
break;
|
||
case clang::DiagnosticsEngine::Level::Ignored:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
static FileSpec
|
||
GetResourceDir ()
|
||
{
|
||
static FileSpec g_cached_resource_dir;
|
||
|
||
static std::once_flag g_once_flag;
|
||
|
||
std::call_once(g_once_flag, [](){
|
||
HostInfo::GetLLDBPath (lldb::ePathTypeClangDir, g_cached_resource_dir);
|
||
});
|
||
|
||
return g_cached_resource_dir;
|
||
}
|
||
|
||
|
||
ClangModulesDeclVendor::ClangModulesDeclVendor()
|
||
{
|
||
}
|
||
|
||
ClangModulesDeclVendor::~ClangModulesDeclVendor()
|
||
{
|
||
}
|
||
|
||
ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> &diagnostics_engine,
|
||
llvm::IntrusiveRefCntPtr<clang::CompilerInvocation> &compiler_invocation,
|
||
std::unique_ptr<clang::CompilerInstance> &&compiler_instance,
|
||
std::unique_ptr<clang::Parser> &&parser) :
|
||
ClangModulesDeclVendor(),
|
||
m_diagnostics_engine(diagnostics_engine),
|
||
m_compiler_invocation(compiler_invocation),
|
||
m_compiler_instance(std::move(compiler_instance)),
|
||
m_parser(std::move(parser))
|
||
{
|
||
}
|
||
|
||
bool
|
||
ClangModulesDeclVendorImpl::AddModule(std::vector<llvm::StringRef> &path,
|
||
Stream &error_stream)
|
||
{
|
||
// Fail early.
|
||
|
||
if (m_compiler_instance->hadModuleLoaderFatalFailure())
|
||
{
|
||
error_stream.PutCString("error: Couldn't load a module because the module loader is in a fatal state.\n");
|
||
return false;
|
||
}
|
||
|
||
if (!m_compiler_instance->getPreprocessor().getHeaderSearchInfo().lookupModule(path[0]))
|
||
{
|
||
error_stream.Printf("error: Header search couldn't locate module %s\n", path[0].str().c_str());
|
||
return false;
|
||
}
|
||
|
||
llvm::SmallVector<std::pair<clang::IdentifierInfo *, clang::SourceLocation>, 4> clang_path;
|
||
|
||
{
|
||
size_t source_loc_counter = 0;
|
||
clang::SourceManager &source_manager = m_compiler_instance->getASTContext().getSourceManager();
|
||
|
||
for (llvm::StringRef &component : path)
|
||
{
|
||
clang_path.push_back(std::make_pair(&m_compiler_instance->getASTContext().Idents.get(component),
|
||
source_manager.getLocForStartOfFile(source_manager.getMainFileID()).getLocWithOffset(source_loc_counter++)));
|
||
}
|
||
}
|
||
|
||
StoringDiagnosticConsumer *diagnostic_consumer = static_cast<StoringDiagnosticConsumer *>(m_compiler_instance->getDiagnostics().getClient());
|
||
|
||
diagnostic_consumer->ClearDiagnostics();
|
||
|
||
clang::Module *top_level_module = DoGetModule(clang_path.front(), false);
|
||
|
||
if (!top_level_module)
|
||
{
|
||
diagnostic_consumer->DumpDiagnostics(error_stream);
|
||
error_stream.Printf("error: Couldn't load top-level module %s\n", path[0].str().c_str());
|
||
return false;
|
||
}
|
||
|
||
clang::Module *submodule = top_level_module;
|
||
|
||
for (size_t ci = 1; ci < path.size(); ++ci)
|
||
{
|
||
llvm::StringRef &component = path[ci];
|
||
submodule = submodule->findSubmodule(component.str());
|
||
if (!submodule)
|
||
{
|
||
diagnostic_consumer->DumpDiagnostics(error_stream);
|
||
error_stream.Printf("error: Couldn't load submodule %s\n", component.str().c_str());
|
||
return false;
|
||
}
|
||
}
|
||
|
||
clang::Module *requested_module = DoGetModule(clang_path, true);
|
||
|
||
return (requested_module != nullptr);
|
||
}
|
||
|
||
// ClangImporter::lookupValue
|
||
|
||
uint32_t
|
||
ClangModulesDeclVendorImpl::FindDecls (const ConstString &name,
|
||
bool append,
|
||
uint32_t max_matches,
|
||
std::vector <clang::NamedDecl*> &decls)
|
||
{
|
||
if (!append)
|
||
decls.clear();
|
||
|
||
clang::IdentifierInfo &ident = m_compiler_instance->getASTContext().Idents.get(name.GetStringRef());
|
||
|
||
clang::LookupResult lookup_result(m_compiler_instance->getSema(),
|
||
clang::DeclarationName(&ident),
|
||
clang::SourceLocation(),
|
||
clang::Sema::LookupOrdinaryName);
|
||
|
||
m_compiler_instance->getSema().LookupName(lookup_result, m_compiler_instance->getSema().getScopeForContext(m_compiler_instance->getASTContext().getTranslationUnitDecl()));
|
||
|
||
uint32_t num_matches = 0;
|
||
|
||
for (clang::NamedDecl *named_decl : lookup_result)
|
||
{
|
||
if (num_matches >= max_matches)
|
||
return num_matches;
|
||
|
||
decls.push_back(named_decl);
|
||
++num_matches;
|
||
}
|
||
|
||
return num_matches;
|
||
}
|
||
|
||
ClangModulesDeclVendorImpl::~ClangModulesDeclVendorImpl()
|
||
{
|
||
}
|
||
|
||
clang::ModuleLoadResult
|
||
ClangModulesDeclVendorImpl::DoGetModule(clang::ModuleIdPath path,
|
||
bool make_visible)
|
||
{
|
||
clang::Module::NameVisibilityKind visibility = make_visible ? clang::Module::AllVisible : clang::Module::Hidden;
|
||
|
||
const bool is_inclusion_directive = false;
|
||
|
||
return m_compiler_instance->loadModule(path.front().second, path, visibility, is_inclusion_directive);
|
||
}
|
||
|
||
static const char *ModuleImportBufferName = "LLDBModulesMemoryBuffer";
|
||
|
||
lldb_private::ClangModulesDeclVendor *
|
||
ClangModulesDeclVendor::Create(Target &target)
|
||
{
|
||
// FIXME we should insure programmatically that the expression parser's compiler and the modules runtime's
|
||
// compiler are both initialized in the same way – preferably by the same code.
|
||
|
||
if (!target.GetPlatform()->SupportsModules())
|
||
return nullptr;
|
||
|
||
const ArchSpec &arch = target.GetArchitecture();
|
||
|
||
std::vector<std::string> compiler_invocation_arguments =
|
||
{
|
||
"-fmodules",
|
||
"-fcxx-modules",
|
||
"-fsyntax-only",
|
||
"-femit-all-decls",
|
||
"-target", arch.GetTriple().str(),
|
||
"-fmodules-validate-system-headers",
|
||
"-Werror=non-modular-include-in-framework-module"
|
||
};
|
||
|
||
target.GetPlatform()->AddClangModuleCompilationOptions(&target, compiler_invocation_arguments);
|
||
|
||
compiler_invocation_arguments.push_back(ModuleImportBufferName);
|
||
|
||
// Add additional search paths with { "-I", path } or { "-F", path } here.
|
||
|
||
{
|
||
llvm::SmallString<128> DefaultModuleCache;
|
||
const bool erased_on_reboot = false;
|
||
llvm::sys::path::system_temp_directory(erased_on_reboot, DefaultModuleCache);
|
||
llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
|
||
llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
|
||
std::string module_cache_argument("-fmodules-cache-path=");
|
||
module_cache_argument.append(DefaultModuleCache.str().str());
|
||
compiler_invocation_arguments.push_back(module_cache_argument);
|
||
}
|
||
|
||
{
|
||
FileSpec clang_resource_dir = GetResourceDir();
|
||
|
||
if (clang_resource_dir.IsDirectory())
|
||
{
|
||
compiler_invocation_arguments.push_back("-resource-dir");
|
||
compiler_invocation_arguments.push_back(clang_resource_dir.GetPath());
|
||
}
|
||
}
|
||
|
||
llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine = clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions,
|
||
new StoringDiagnosticConsumer);
|
||
|
||
std::vector<const char *> compiler_invocation_argument_cstrs;
|
||
|
||
for (const std::string &arg : compiler_invocation_arguments) {
|
||
compiler_invocation_argument_cstrs.push_back(arg.c_str());
|
||
}
|
||
|
||
llvm::IntrusiveRefCntPtr<clang::CompilerInvocation> invocation(clang::createInvocationFromCommandLine(compiler_invocation_argument_cstrs, diagnostics_engine));
|
||
|
||
if (!invocation)
|
||
return nullptr;
|
||
|
||
std::unique_ptr<llvm::MemoryBuffer> source_buffer = llvm::MemoryBuffer::getMemBuffer("extern int __lldb __attribute__((unavailable));",
|
||
ModuleImportBufferName);
|
||
|
||
invocation->getPreprocessorOpts().addRemappedFile(ModuleImportBufferName, source_buffer.release());
|
||
|
||
std::unique_ptr<clang::CompilerInstance> instance(new clang::CompilerInstance);
|
||
|
||
instance->setDiagnostics(diagnostics_engine.get());
|
||
instance->setInvocation(invocation.get());
|
||
|
||
std::unique_ptr<clang::FrontendAction> action(new clang::SyntaxOnlyAction);
|
||
|
||
instance->setTarget(clang::TargetInfo::CreateTargetInfo(*diagnostics_engine, instance->getInvocation().TargetOpts));
|
||
|
||
if (!instance->hasTarget())
|
||
return nullptr;
|
||
|
||
instance->getTarget().adjust(instance->getLangOpts());
|
||
|
||
if (!action->BeginSourceFile(*instance, instance->getFrontendOpts().Inputs[0]))
|
||
return nullptr;
|
||
|
||
instance->getPreprocessor().enableIncrementalProcessing();
|
||
|
||
instance->createModuleManager();
|
||
|
||
instance->createSema(action->getTranslationUnitKind(), nullptr);
|
||
|
||
const bool skipFunctionBodies = false;
|
||
std::unique_ptr<clang::Parser> parser(new clang::Parser(instance->getPreprocessor(), instance->getSema(), skipFunctionBodies));
|
||
|
||
instance->getPreprocessor().EnterMainSourceFile();
|
||
parser->Initialize();
|
||
|
||
clang::Parser::DeclGroupPtrTy parsed;
|
||
|
||
while (!parser->ParseTopLevelDecl(parsed));
|
||
|
||
return new ClangModulesDeclVendorImpl (diagnostics_engine, invocation, std::move(instance), std::move(parser));
|
||
}
|