acbf0058e9
Before a Debugger gets a Target, target settings are routed to a global set of settings. Even without this, some part of the LLDB which exist independently of the Debugger object (the Module cache, the Symbol vendors, ...) access directly the global default store for those settings. Of course, if you modify one of those global settings while they are being read, bad things happen. We see this quite a bit with FileSpecList settings. In particular, we see many cases where one debug session changes target.exec-search-paths while another session starts up and it crashes when one of those accesses invalid FileSpecs. This patch addresses the specific FileSpecList issue by adding locking to OptionValueFileSpecList and never returning by reference. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: https://reviews.llvm.org/D60468 llvm-svn: 359028
722 lines
24 KiB
C++
722 lines
24 KiB
C++
//===-- ClangModulesDeclVendor.cpp ------------------------------*- C++ -*-===//
|
||
//
|
||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||
// See https://llvm.org/LICENSE.txt for license information.
|
||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#include <mutex>
|
||
|
||
#include "clang/Basic/TargetInfo.h"
|
||
#include "clang/Frontend/CompilerInstance.h"
|
||
#include "clang/Frontend/FrontendActions.h"
|
||
#include "clang/Lex/Preprocessor.h"
|
||
#include "clang/Lex/PreprocessorOptions.h"
|
||
#include "clang/Parse/Parser.h"
|
||
#include "clang/Sema/Lookup.h"
|
||
#include "clang/Serialization/ASTReader.h"
|
||
#include "llvm/Support/FileSystem.h"
|
||
#include "llvm/Support/Path.h"
|
||
#include "llvm/Support/Threading.h"
|
||
|
||
#include "ClangHost.h"
|
||
#include "ClangModulesDeclVendor.h"
|
||
#include "ModuleDependencyCollector.h"
|
||
|
||
#include "lldb/Core/ModuleList.h"
|
||
#include "lldb/Host/Host.h"
|
||
#include "lldb/Host/HostInfo.h"
|
||
#include "lldb/Symbol/CompileUnit.h"
|
||
#include "lldb/Symbol/SourceModule.h"
|
||
#include "lldb/Target/Target.h"
|
||
#include "lldb/Utility/FileSpec.h"
|
||
#include "lldb/Utility/LLDBAssert.h"
|
||
#include "lldb/Utility/Log.h"
|
||
#include "lldb/Utility/Reproducer.h"
|
||
#include "lldb/Utility/StreamString.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) override;
|
||
|
||
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,
|
||
std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
|
||
std::unique_ptr<clang::CompilerInstance> compiler_instance,
|
||
std::unique_ptr<clang::Parser> parser);
|
||
|
||
~ClangModulesDeclVendorImpl() override = default;
|
||
|
||
bool AddModule(const SourceModule &module, ModuleVector *exported_modules,
|
||
Stream &error_stream) override;
|
||
|
||
bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules,
|
||
Stream &error_stream) override;
|
||
|
||
uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
|
||
std::vector<clang::NamedDecl *> &decls) override;
|
||
|
||
void ForEachMacro(const ModuleVector &modules,
|
||
std::function<bool(const std::string &)> handler) override;
|
||
|
||
clang::ExternalASTMerger::ImporterSource GetImporterSource() override;
|
||
private:
|
||
void
|
||
ReportModuleExportsHelper(std::set<ClangModulesDeclVendor::ModuleID> &exports,
|
||
clang::Module *module);
|
||
|
||
void ReportModuleExports(ModuleVector &exports, clang::Module *module);
|
||
|
||
clang::ModuleLoadResult DoGetModule(clang::ModuleIdPath path,
|
||
bool make_visible);
|
||
|
||
bool m_enabled = false;
|
||
|
||
llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> m_diagnostics_engine;
|
||
std::shared_ptr<clang::CompilerInvocation> m_compiler_invocation;
|
||
std::unique_ptr<clang::CompilerInstance> m_compiler_instance;
|
||
std::unique_ptr<clang::Parser> m_parser;
|
||
size_t m_source_location_index =
|
||
0; // used to give name components fake SourceLocations
|
||
|
||
typedef std::vector<ConstString> ImportedModule;
|
||
typedef std::map<ImportedModule, clang::Module *> ImportedModuleMap;
|
||
typedef std::set<ModuleID> ImportedModuleSet;
|
||
ImportedModuleMap m_imported_modules;
|
||
ImportedModuleSet m_user_imported_modules;
|
||
const clang::ExternalASTMerger::OriginMap m_origin_map;
|
||
};
|
||
} // anonymous namespace
|
||
|
||
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);
|
||
error_stream.PutChar('\n');
|
||
break;
|
||
case clang::DiagnosticsEngine::Level::Ignored:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
ClangModulesDeclVendor::ClangModulesDeclVendor() {}
|
||
|
||
ClangModulesDeclVendor::~ClangModulesDeclVendor() {}
|
||
|
||
ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
|
||
llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
|
||
std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
|
||
std::unique_ptr<clang::CompilerInstance> compiler_instance,
|
||
std::unique_ptr<clang::Parser> parser)
|
||
: m_diagnostics_engine(std::move(diagnostics_engine)),
|
||
m_compiler_invocation(std::move(compiler_invocation)),
|
||
m_compiler_instance(std::move(compiler_instance)),
|
||
m_parser(std::move(parser)), m_origin_map() {}
|
||
|
||
void ClangModulesDeclVendorImpl::ReportModuleExportsHelper(
|
||
std::set<ClangModulesDeclVendor::ModuleID> &exports,
|
||
clang::Module *module) {
|
||
if (exports.count(reinterpret_cast<ClangModulesDeclVendor::ModuleID>(module)))
|
||
return;
|
||
|
||
exports.insert(reinterpret_cast<ClangModulesDeclVendor::ModuleID>(module));
|
||
|
||
llvm::SmallVector<clang::Module *, 2> sub_exports;
|
||
|
||
module->getExportedModules(sub_exports);
|
||
|
||
for (clang::Module *module : sub_exports) {
|
||
ReportModuleExportsHelper(exports, module);
|
||
}
|
||
}
|
||
|
||
void ClangModulesDeclVendorImpl::ReportModuleExports(
|
||
ClangModulesDeclVendor::ModuleVector &exports, clang::Module *module) {
|
||
std::set<ClangModulesDeclVendor::ModuleID> exports_set;
|
||
|
||
ReportModuleExportsHelper(exports_set, module);
|
||
|
||
for (ModuleID module : exports_set) {
|
||
exports.push_back(module);
|
||
}
|
||
}
|
||
|
||
bool ClangModulesDeclVendorImpl::AddModule(const SourceModule &module,
|
||
ModuleVector *exported_modules,
|
||
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;
|
||
}
|
||
|
||
// Check if we've already imported this module.
|
||
|
||
std::vector<ConstString> imported_module;
|
||
|
||
for (ConstString path_component : module.path) {
|
||
imported_module.push_back(path_component);
|
||
}
|
||
|
||
{
|
||
ImportedModuleMap::iterator mi = m_imported_modules.find(imported_module);
|
||
|
||
if (mi != m_imported_modules.end()) {
|
||
if (exported_modules) {
|
||
ReportModuleExports(*exported_modules, mi->second);
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
|
||
clang::HeaderSearch &HS =
|
||
m_compiler_instance->getPreprocessor().getHeaderSearchInfo();
|
||
|
||
if (module.search_path) {
|
||
auto path_begin = llvm::sys::path::begin(module.search_path.GetStringRef());
|
||
auto path_end = llvm::sys::path::end(module.search_path.GetStringRef());
|
||
auto sysroot_begin = llvm::sys::path::begin(module.sysroot.GetStringRef());
|
||
auto sysroot_end = llvm::sys::path::end(module.sysroot.GetStringRef());
|
||
// FIXME: Use C++14 std::equal(it, it, it, it) variant once it's available.
|
||
bool is_system_module = (std::distance(path_begin, path_end) >=
|
||
std::distance(sysroot_begin, sysroot_end)) &&
|
||
std::equal(sysroot_begin, sysroot_end, path_begin);
|
||
// No need to inject search paths to modules in the sysroot.
|
||
if (!is_system_module) {
|
||
auto error = [&]() {
|
||
error_stream.Printf("error: No module map file in %s\n",
|
||
module.search_path.AsCString());
|
||
return false;
|
||
};
|
||
|
||
bool is_system = true;
|
||
bool is_framework = false;
|
||
auto *dir =
|
||
HS.getFileMgr().getDirectory(module.search_path.GetStringRef());
|
||
if (!dir)
|
||
return error();
|
||
auto *file = HS.lookupModuleMapFile(dir, is_framework);
|
||
if (!file)
|
||
return error();
|
||
if (!HS.loadModuleMapFile(file, is_system))
|
||
return error();
|
||
}
|
||
}
|
||
if (!HS.lookupModule(module.path.front().GetStringRef())) {
|
||
error_stream.Printf("error: Header search couldn't locate module %s\n",
|
||
module.path.front().AsCString());
|
||
return false;
|
||
}
|
||
|
||
llvm::SmallVector<std::pair<clang::IdentifierInfo *, clang::SourceLocation>,
|
||
4>
|
||
clang_path;
|
||
|
||
{
|
||
clang::SourceManager &source_manager =
|
||
m_compiler_instance->getASTContext().getSourceManager();
|
||
|
||
for (ConstString path_component : module.path) {
|
||
clang_path.push_back(std::make_pair(
|
||
&m_compiler_instance->getASTContext().Idents.get(
|
||
path_component.GetStringRef()),
|
||
source_manager.getLocForStartOfFile(source_manager.getMainFileID())
|
||
.getLocWithOffset(m_source_location_index++)));
|
||
}
|
||
}
|
||
|
||
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",
|
||
module.path.front().AsCString());
|
||
return false;
|
||
}
|
||
|
||
clang::Module *submodule = top_level_module;
|
||
|
||
for (auto &component : llvm::ArrayRef<ConstString>(module.path).drop_front()) {
|
||
submodule = submodule->findSubmodule(component.GetStringRef());
|
||
if (!submodule) {
|
||
diagnostic_consumer->DumpDiagnostics(error_stream);
|
||
error_stream.Printf("error: Couldn't load submodule %s\n",
|
||
component.GetCString());
|
||
return false;
|
||
}
|
||
}
|
||
|
||
clang::Module *requested_module = DoGetModule(clang_path, true);
|
||
|
||
if (requested_module != nullptr) {
|
||
if (exported_modules) {
|
||
ReportModuleExports(*exported_modules, requested_module);
|
||
}
|
||
|
||
m_imported_modules[imported_module] = requested_module;
|
||
|
||
m_enabled = true;
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool ClangModulesDeclVendor::LanguageSupportsClangModules(
|
||
lldb::LanguageType language) {
|
||
switch (language) {
|
||
default:
|
||
return false;
|
||
case lldb::LanguageType::eLanguageTypeC:
|
||
case lldb::LanguageType::eLanguageTypeC11:
|
||
case lldb::LanguageType::eLanguageTypeC89:
|
||
case lldb::LanguageType::eLanguageTypeC99:
|
||
case lldb::LanguageType::eLanguageTypeC_plus_plus:
|
||
case lldb::LanguageType::eLanguageTypeC_plus_plus_03:
|
||
case lldb::LanguageType::eLanguageTypeC_plus_plus_11:
|
||
case lldb::LanguageType::eLanguageTypeC_plus_plus_14:
|
||
case lldb::LanguageType::eLanguageTypeObjC:
|
||
case lldb::LanguageType::eLanguageTypeObjC_plus_plus:
|
||
return true;
|
||
}
|
||
}
|
||
|
||
bool ClangModulesDeclVendorImpl::AddModulesForCompileUnit(
|
||
CompileUnit &cu, ClangModulesDeclVendor::ModuleVector &exported_modules,
|
||
Stream &error_stream) {
|
||
if (LanguageSupportsClangModules(cu.GetLanguage())) {
|
||
for (auto &imported_module : cu.GetImportedModules())
|
||
if (!AddModule(imported_module, &exported_modules, error_stream))
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// ClangImporter::lookupValue
|
||
|
||
uint32_t
|
||
ClangModulesDeclVendorImpl::FindDecls(ConstString name, bool append,
|
||
uint32_t max_matches,
|
||
std::vector<clang::NamedDecl *> &decls) {
|
||
if (!m_enabled) {
|
||
return 0;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
void ClangModulesDeclVendorImpl::ForEachMacro(
|
||
const ClangModulesDeclVendor::ModuleVector &modules,
|
||
std::function<bool(const std::string &)> handler) {
|
||
if (!m_enabled) {
|
||
return;
|
||
}
|
||
|
||
typedef std::map<ModuleID, ssize_t> ModulePriorityMap;
|
||
ModulePriorityMap module_priorities;
|
||
|
||
ssize_t priority = 0;
|
||
|
||
for (ModuleID module : modules) {
|
||
module_priorities[module] = priority++;
|
||
}
|
||
|
||
if (m_compiler_instance->getPreprocessor().getExternalSource()) {
|
||
m_compiler_instance->getPreprocessor()
|
||
.getExternalSource()
|
||
->ReadDefinedMacros();
|
||
}
|
||
|
||
for (clang::Preprocessor::macro_iterator
|
||
mi = m_compiler_instance->getPreprocessor().macro_begin(),
|
||
me = m_compiler_instance->getPreprocessor().macro_end();
|
||
mi != me; ++mi) {
|
||
const clang::IdentifierInfo *ii = nullptr;
|
||
|
||
{
|
||
if (clang::IdentifierInfoLookup *lookup =
|
||
m_compiler_instance->getPreprocessor()
|
||
.getIdentifierTable()
|
||
.getExternalIdentifierLookup()) {
|
||
lookup->get(mi->first->getName());
|
||
}
|
||
if (!ii) {
|
||
ii = mi->first;
|
||
}
|
||
}
|
||
|
||
ssize_t found_priority = -1;
|
||
clang::MacroInfo *macro_info = nullptr;
|
||
|
||
for (clang::ModuleMacro *module_macro :
|
||
m_compiler_instance->getPreprocessor().getLeafModuleMacros(ii)) {
|
||
clang::Module *module = module_macro->getOwningModule();
|
||
|
||
{
|
||
ModulePriorityMap::iterator pi =
|
||
module_priorities.find(reinterpret_cast<ModuleID>(module));
|
||
|
||
if (pi != module_priorities.end() && pi->second > found_priority) {
|
||
macro_info = module_macro->getMacroInfo();
|
||
found_priority = pi->second;
|
||
}
|
||
}
|
||
|
||
clang::Module *top_level_module = module->getTopLevelModule();
|
||
|
||
if (top_level_module != module) {
|
||
ModulePriorityMap::iterator pi = module_priorities.find(
|
||
reinterpret_cast<ModuleID>(top_level_module));
|
||
|
||
if ((pi != module_priorities.end()) && pi->second > found_priority) {
|
||
macro_info = module_macro->getMacroInfo();
|
||
found_priority = pi->second;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (macro_info) {
|
||
std::string macro_expansion = "#define ";
|
||
macro_expansion.append(mi->first->getName().str());
|
||
|
||
{
|
||
if (macro_info->isFunctionLike()) {
|
||
macro_expansion.append("(");
|
||
|
||
bool first_arg = true;
|
||
|
||
for (auto pi = macro_info->param_begin(),
|
||
pe = macro_info->param_end();
|
||
pi != pe; ++pi) {
|
||
if (!first_arg) {
|
||
macro_expansion.append(", ");
|
||
} else {
|
||
first_arg = false;
|
||
}
|
||
|
||
macro_expansion.append((*pi)->getName().str());
|
||
}
|
||
|
||
if (macro_info->isC99Varargs()) {
|
||
if (first_arg) {
|
||
macro_expansion.append("...");
|
||
} else {
|
||
macro_expansion.append(", ...");
|
||
}
|
||
} else if (macro_info->isGNUVarargs()) {
|
||
macro_expansion.append("...");
|
||
}
|
||
|
||
macro_expansion.append(")");
|
||
}
|
||
|
||
macro_expansion.append(" ");
|
||
|
||
bool first_token = true;
|
||
|
||
for (clang::MacroInfo::tokens_iterator ti = macro_info->tokens_begin(),
|
||
te = macro_info->tokens_end();
|
||
ti != te; ++ti) {
|
||
if (!first_token) {
|
||
macro_expansion.append(" ");
|
||
} else {
|
||
first_token = false;
|
||
}
|
||
|
||
if (ti->isLiteral()) {
|
||
if (const char *literal_data = ti->getLiteralData()) {
|
||
std::string token_str(literal_data, ti->getLength());
|
||
macro_expansion.append(token_str);
|
||
} else {
|
||
bool invalid = false;
|
||
const char *literal_source =
|
||
m_compiler_instance->getSourceManager().getCharacterData(
|
||
ti->getLocation(), &invalid);
|
||
|
||
if (invalid) {
|
||
lldbassert(0 && "Unhandled token kind");
|
||
macro_expansion.append("<unknown literal value>");
|
||
} else {
|
||
macro_expansion.append(
|
||
std::string(literal_source, ti->getLength()));
|
||
}
|
||
}
|
||
} else if (const char *punctuator_spelling =
|
||
clang::tok::getPunctuatorSpelling(ti->getKind())) {
|
||
macro_expansion.append(punctuator_spelling);
|
||
} else if (const char *keyword_spelling =
|
||
clang::tok::getKeywordSpelling(ti->getKind())) {
|
||
macro_expansion.append(keyword_spelling);
|
||
} else {
|
||
switch (ti->getKind()) {
|
||
case clang::tok::TokenKind::identifier:
|
||
macro_expansion.append(ti->getIdentifierInfo()->getName().str());
|
||
break;
|
||
case clang::tok::TokenKind::raw_identifier:
|
||
macro_expansion.append(ti->getRawIdentifier().str());
|
||
break;
|
||
default:
|
||
macro_expansion.append(ti->getName());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (handler(macro_expansion)) {
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
clang::ExternalASTMerger::ImporterSource
|
||
ClangModulesDeclVendorImpl::GetImporterSource() {
|
||
return {m_compiler_instance->getASTContext(),
|
||
m_compiler_instance->getFileManager(), m_origin_map};
|
||
}
|
||
|
||
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 = {
|
||
"clang",
|
||
"-fmodules",
|
||
"-fimplicit-module-maps",
|
||
"-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> path;
|
||
auto props = ModuleList::GetGlobalModuleListProperties();
|
||
props.GetClangModulesCachePath().GetPath(path);
|
||
std::string module_cache_argument("-fmodules-cache-path=");
|
||
module_cache_argument.append(path.str());
|
||
compiler_invocation_arguments.push_back(module_cache_argument);
|
||
}
|
||
|
||
FileSpecList module_search_paths = target.GetClangModuleSearchPaths();
|
||
|
||
for (size_t spi = 0, spe = module_search_paths.GetSize(); spi < spe; ++spi) {
|
||
const FileSpec &search_path = module_search_paths.GetFileSpecAtIndex(spi);
|
||
|
||
std::string search_path_argument = "-I";
|
||
search_path_argument.append(search_path.GetPath());
|
||
|
||
compiler_invocation_arguments.push_back(search_path_argument);
|
||
}
|
||
|
||
{
|
||
FileSpec clang_resource_dir = GetClangResourceDir();
|
||
|
||
if (FileSystem::Instance().IsDirectory(clang_resource_dir.GetPath())) {
|
||
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);
|
||
|
||
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
|
||
if (log)
|
||
log->PutString("ClangModulesDeclVendor::Create()");
|
||
std::vector<const char *> compiler_invocation_argument_cstrs;
|
||
compiler_invocation_argument_cstrs.reserve(
|
||
compiler_invocation_arguments.size());
|
||
for (const std::string &arg : compiler_invocation_arguments) {
|
||
compiler_invocation_argument_cstrs.push_back(arg.c_str());
|
||
if (log) {
|
||
log->PutString("\n ");
|
||
log->PutString(arg);
|
||
}
|
||
}
|
||
if (log)
|
||
log->PutString("\n");
|
||
|
||
std::shared_ptr<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);
|
||
|
||
// When capturing a reproducer, hook up the file collector with clang to
|
||
// collector modules and headers.
|
||
if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
|
||
repro::FileProvider &fp = g->GetOrCreate<repro::FileProvider>();
|
||
instance->setModuleDepCollector(
|
||
std::make_shared<ModuleDependencyCollectorAdaptor>(
|
||
fp.GetFileCollector()));
|
||
clang::DependencyOutputOptions &opts = instance->getDependencyOutputOpts();
|
||
opts.IncludeSystemHeaders = true;
|
||
opts.IncludeModuleFiles = true;
|
||
}
|
||
|
||
// Make sure clang uses the same VFS as LLDB.
|
||
instance->createFileManager(FileSystem::Instance().GetVirtualFileSystem());
|
||
instance->setDiagnostics(diagnostics_engine.get());
|
||
instance->setInvocation(invocation);
|
||
|
||
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(std::move(diagnostics_engine),
|
||
std::move(invocation),
|
||
std::move(instance), std::move(parser));
|
||
}
|