shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity
llvm-project/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp
Michael Buch 74e34eff3f
[lldb][ClangModulesDeclVendor] Don't stop loading Clang modules if an individual import failed (#166940) 
Depends on:
* https://github.com/llvm/llvm-project/pull/166917

When loading all Clang modules for a CU, we stop on first error. This
means benign module loading errors may stop us from importing actually
useful modules. There's no good reason to bail on the first one. The
pathological case would be if we try to load a large number of Clang
modules
but all fail to load for the same reason. That could happen, but in
practice I've always seen only a handful of modules failing to load out
of a large number. Particularly system modules are useful and usually
don't fail to load. Whereas project-specific Clang modules are more
likely to fail because the build system moves the modulemap/sources
around.

This patch accumulates all module loading errors and doesn't stop when
an error is encountered.
2025-11-07 23:11:48 +00:00

798 lines
28 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

//===-- ClangModulesDeclVendor.cpp ----------------------------------------===//
//
// 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 "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticFrontend.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Frontend/TextDiagnosticPrinter.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/ADT/StringRef.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Threading.h"
#include "ClangHost.h"
#include "ClangModulesDeclVendor.h"
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Core/Progress.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/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include <memory>
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);
void BeginSourceFile(const clang::LangOptions &LangOpts,
const clang::Preprocessor *PP = nullptr) override;
void EndSourceFile() override;
private:
bool HandleModuleRemark(const clang::Diagnostic &info);
void SetCurrentModuleProgress(std::string module_name);
typedef std::pair<clang::DiagnosticsEngine::Level, std::string>
IDAndDiagnostic;
std::vector<IDAndDiagnostic> m_diagnostics;
std::unique_ptr<clang::DiagnosticOptions> m_diag_opts;
/// The DiagnosticPrinter used for creating the full diagnostic messages
/// that are stored in m_diagnostics.
std::unique_ptr<clang::TextDiagnosticPrinter> m_diag_printer;
/// Output stream of m_diag_printer.
std::unique_ptr<llvm::raw_string_ostream> m_os;
/// Output string filled by m_os. Will be reused for different diagnostics.
std::string m_output;
/// A Progress with explicitly managed lifetime.
std::unique_ptr<Progress> m_current_progress_up;
std::vector<std::string> m_module_build_stack;
};
/// The private implementation of our ClangModulesDeclVendor. Contains all the
/// Clang state required to load modules.
class ClangModulesDeclVendorImpl : public ClangModulesDeclVendor {
public:
ClangModulesDeclVendorImpl(
std::unique_ptr<clang::DiagnosticOptions> diagnostic_options,
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;
llvm::Error AddModule(const SourceModule &module,
ModuleVector *exported_modules) override;
llvm::Error AddModulesForCompileUnit(CompileUnit &cu,
ModuleVector &exported_modules) override;
uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
std::vector<CompilerDecl> &decls) override;
void ForEachMacro(
const ModuleVector &modules,
std::function<bool(llvm::StringRef, llvm::StringRef)> handler) override;
private:
typedef llvm::DenseSet<ModuleID> ExportedModuleSet;
void ReportModuleExportsHelper(ExportedModuleSet &exports,
clang::Module *module);
void ReportModuleExports(ModuleVector &exports, clang::Module *module);
clang::ModuleLoadResult DoGetModule(clang::ModuleIdPath path,
bool make_visible);
bool m_enabled = false;
std::unique_ptr<clang::DiagnosticOptions> m_diagnostic_options;
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 llvm::DenseSet<ModuleID> ImportedModuleSet;
ImportedModuleMap m_imported_modules;
ImportedModuleSet m_user_imported_modules;
// We assume that every ASTContext has an TypeSystemClang, so we also store
// a custom TypeSystemClang for our internal ASTContext.
std::shared_ptr<TypeSystemClang> m_ast_context;
};
} // anonymous namespace
StoringDiagnosticConsumer::StoringDiagnosticConsumer() {
m_diag_opts = std::make_unique<clang::DiagnosticOptions>();
m_os = std::make_unique<llvm::raw_string_ostream>(m_output);
m_diag_printer =
std::make_unique<clang::TextDiagnosticPrinter>(*m_os, *m_diag_opts);
}
void StoringDiagnosticConsumer::HandleDiagnostic(
clang::DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &info) {
if (HandleModuleRemark(info))
return;
// Print the diagnostic to m_output.
m_output.clear();
m_diag_printer->HandleDiagnostic(DiagLevel, info);
// Store the diagnostic for later.
m_diagnostics.push_back(IDAndDiagnostic(DiagLevel, m_output));
}
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;
}
}
}
void StoringDiagnosticConsumer::BeginSourceFile(
const clang::LangOptions &LangOpts, const clang::Preprocessor *PP) {
m_diag_printer->BeginSourceFile(LangOpts, PP);
}
void StoringDiagnosticConsumer::EndSourceFile() {
m_current_progress_up = nullptr;
m_diag_printer->EndSourceFile();
}
bool StoringDiagnosticConsumer::HandleModuleRemark(
const clang::Diagnostic &info) {
Log *log = GetLog(LLDBLog::Types | LLDBLog::Expressions);
switch (info.getID()) {
case clang::diag::remark_module_build: {
const auto &module_name = info.getArgStdStr(0);
SetCurrentModuleProgress(module_name);
m_module_build_stack.push_back(module_name);
const auto &module_path = info.getArgStdStr(1);
LLDB_LOG(log, "Building Clang module {0} as {1}", module_name, module_path);
return true;
}
case clang::diag::remark_module_build_done: {
// The current module is done.
m_module_build_stack.pop_back();
if (m_module_build_stack.empty()) {
m_current_progress_up = nullptr;
} else {
// When the just completed module began building, a module that depends on
// it ("module A") was effectively paused. Update the progress to re-show
// "module A" as continuing to be built.
const auto &resumed_module_name = m_module_build_stack.back();
SetCurrentModuleProgress(resumed_module_name);
}
const auto &module_name = info.getArgStdStr(0);
LLDB_LOG(log, "Finished building Clang module {0}", module_name);
return true;
}
default:
return false;
}
}
void StoringDiagnosticConsumer::SetCurrentModuleProgress(
std::string module_name) {
if (!m_current_progress_up)
m_current_progress_up =
std::make_unique<Progress>("Building Clang modules");
m_current_progress_up->Increment(1, std::move(module_name));
}
ClangModulesDeclVendor::ClangModulesDeclVendor()
: DeclVendor(eClangModuleDeclVendor) {}
ClangModulesDeclVendor::~ClangModulesDeclVendor() = default;
ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
std::unique_ptr<clang::DiagnosticOptions> diagnostic_options,
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_diagnostic_options(std::move(diagnostic_options)),
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)) {
// Initialize our TypeSystemClang.
m_ast_context =
std::make_shared<TypeSystemClang>("ClangModulesDeclVendor ASTContext",
m_compiler_instance->getASTContext());
}
void ClangModulesDeclVendorImpl::ReportModuleExportsHelper(
ExportedModuleSet &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) {
ExportedModuleSet exports_set;
ReportModuleExportsHelper(exports_set, module);
for (ModuleID module : exports_set)
exports.push_back(module);
}
llvm::Error
ClangModulesDeclVendorImpl::AddModule(const SourceModule &module,
ModuleVector *exported_modules) {
// Fail early.
if (m_compiler_instance->hadModuleLoaderFatalFailure())
return llvm::createStringError(
"couldn't load a module because the module loader is in a fatal state");
// 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 llvm::Error::success();
}
}
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) {
bool is_system = true;
bool is_framework = false;
auto dir = HS.getFileMgr().getOptionalDirectoryRef(
module.search_path.GetStringRef());
if (!dir)
return llvm::createStringError(
"couldn't find module search path directory %s",
module.search_path.GetCString());
auto file = HS.lookupModuleMapFile(*dir, is_framework);
if (!file)
return llvm::createStringError("couldn't find modulemap file in %s",
module.search_path.GetCString());
if (HS.parseAndLoadModuleMapFile(*file, is_system))
return llvm::createStringError(
"failed to parse and load modulemap file in %s",
module.search_path.GetCString());
}
}
if (!HS.lookupModule(module.path.front().GetStringRef()))
return llvm::createStringError("header search couldn't locate module '%s'",
module.path.front().AsCString());
llvm::SmallVector<clang::IdentifierLoc, 4> clang_path;
{
clang::SourceManager &source_manager =
m_compiler_instance->getASTContext().getSourceManager();
for (ConstString path_component : module.path) {
clang_path.emplace_back(
source_manager.getLocForStartOfFile(source_manager.getMainFileID())
.getLocWithOffset(m_source_location_index++),
&m_compiler_instance->getASTContext().Idents.get(
path_component.GetStringRef()));
}
}
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) {
lldb_private::StreamString error_stream;
diagnostic_consumer->DumpDiagnostics(error_stream);
return llvm::createStringError(llvm::formatv(
"couldn't load top-level module {0}:\n{1}",
module.path.front().GetStringRef(), error_stream.GetString()));
}
clang::Module *submodule = top_level_module;
for (auto &component : llvm::ArrayRef<ConstString>(module.path).drop_front()) {
clang::Module *found = submodule->findSubmodule(component.GetStringRef());
if (!found) {
lldb_private::StreamString error_stream;
diagnostic_consumer->DumpDiagnostics(error_stream);
return llvm::createStringError(llvm::formatv(
"couldn't load submodule '{0}' of module '{1}':\n{2}",
component.GetStringRef(), submodule->getFullModuleName(),
error_stream.GetString()));
}
submodule = found;
}
// If we didn't make the submodule visible here, Clang wouldn't allow LLDB to
// pick any of the decls in the submodules during C++ name lookup.
if (submodule)
m_compiler_instance->makeModuleVisible(
submodule, clang::Module::NameVisibilityKind::AllVisible,
/*ImportLoc=*/{});
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 llvm::Error::success();
}
return llvm::createStringError(
llvm::formatv("unknown error while loading module {0}\n",
module.path.front().GetStringRef()));
}
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;
}
}
llvm::Error ClangModulesDeclVendorImpl::AddModulesForCompileUnit(
CompileUnit &cu, ClangModulesDeclVendor::ModuleVector &exported_modules) {
if (!LanguageSupportsClangModules(cu.GetLanguage()))
return llvm::Error::success();
llvm::Error errors = llvm::Error::success();
for (auto &imported_module : cu.GetImportedModules())
if (auto err = AddModule(imported_module, &exported_modules))
errors = llvm::joinErrors(std::move(errors), std::move(err));
return errors;
}
// ClangImporter::lookupValue
uint32_t
ClangModulesDeclVendorImpl::FindDecls(ConstString name, bool append,
uint32_t max_matches,
std::vector<CompilerDecl> &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(m_ast_context->GetCompilerDecl(named_decl));
++num_matches;
}
return num_matches;
}
void ClangModulesDeclVendorImpl::ForEachMacro(
const ClangModulesDeclVendor::ModuleVector &modules,
std::function<bool(llvm::StringRef, llvm::StringRef)> 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 ";
llvm::StringRef macro_identifier = mi->first->getName();
macro_expansion.append(macro_identifier.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::const_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_identifier, 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().getLoc(), 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 = {
"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",
"-Xclang=-fincremental-extensions",
"-Rmodule-build"};
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;
const auto &props = ModuleList::GetGlobalModuleListProperties();
props.GetClangModulesCachePath().GetPath(path);
std::string module_cache_argument("-fmodules-cache-path=");
module_cache_argument.append(std::string(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());
}
}
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());
auto diag_options_up =
clang::CreateAndPopulateDiagOpts(compiler_invocation_argument_cstrs);
llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine =
clang::CompilerInstance::createDiagnostics(
*FileSystem::Instance().GetVirtualFileSystem(), *diag_options_up,
new StoringDiagnosticConsumer);
Log *log = GetLog(LLDBLog::Expressions);
LLDB_LOG(log, "ClangModulesDeclVendor's compiler flags {0:$[ ]}",
llvm::make_range(compiler_invocation_arguments.begin(),
compiler_invocation_arguments.end()));
clang::CreateInvocationOptions CIOpts;
CIOpts.Diags = diagnostics_engine;
std::shared_ptr<clang::CompilerInvocation> invocation =
clang::createInvocation(compiler_invocation_argument_cstrs,
std::move(CIOpts));
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());
auto instance = std::make_unique<clang::CompilerInstance>(invocation);
// Make sure clang uses the same VFS as LLDB.
instance->setVirtualFileSystem(FileSystem::Instance().GetVirtualFileSystem());
instance->createFileManager();
instance->setDiagnostics(diagnostics_engine);
std::unique_ptr<clang::FrontendAction> action(new clang::SyntaxOnlyAction);
instance->setTarget(clang::TargetInfo::CreateTargetInfo(
*diagnostics_engine, instance->getInvocation().getTargetOpts()));
if (!instance->hasTarget())
return nullptr;
instance->getTarget().adjust(*diagnostics_engine, instance->getLangOpts(),
/*AuxTarget=*/nullptr);
if (!action->BeginSourceFile(*instance,
instance->getFrontendOpts().Inputs[0]))
return nullptr;
instance->createASTReader();
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;
auto ImportState = clang::Sema::ModuleImportState::NotACXX20Module;
while (!parser->ParseTopLevelDecl(parsed, ImportState))
;
return new ClangModulesDeclVendorImpl(
std::move(diag_options_up), std::move(diagnostics_engine),
std::move(invocation), std::move(instance), std::move(parser));
}
Reference in New Issue View Git Blame Copy Permalink