27#include "llvm/ADT/ScopeExit.h"
28#include "llvm/Support/Allocator.h"
29#include "llvm/Support/Error.h"
30#include "llvm/TargetParser/Host.h"
34using namespace tooling;
35using namespace dependencies;
42 DependencyConsumerForwarder(std::unique_ptr<DependencyOutputOptions> Opts,
45 Opts(
std::move(Opts)),
C(
C) {}
48 C.handleDependencyOutputOpts(*Opts);
52 llvm::sys::path::remove_dots(CanonPath,
true);
53 llvm::sys::fs::make_absolute(WorkingDirectory, CanonPath);
54 C.handleFileDependency(CanonPath);
59 StringRef WorkingDirectory;
60 std::unique_ptr<DependencyOutputOptions> Opts;
68 if (LangOpts.Modules) {
71 Diags->
Report(diag::warn_pch_vfsoverlay_mismatch);
73 if (VFSOverlays.empty()) {
74 Diags->
Report(diag::note_pch_vfsoverlay_empty) <<
Type;
76 std::string Files = llvm::join(VFSOverlays,
"\n");
77 Diags->
Report(diag::note_pch_vfsoverlay_files) <<
Type << Files;
94 PrebuiltModuleListener(PrebuiltModuleFilesT &PrebuiltModuleFiles,
99 : PrebuiltModuleFiles(PrebuiltModuleFiles),
100 NewModuleFiles(NewModuleFiles),
101 PrebuiltModuleVFSMap(PrebuiltModuleVFSMap), ExistingHSOpts(HSOpts),
102 ExistingLangOpts(LangOpts), Diags(Diags) {}
107 if (PrebuiltModuleFiles.insert({ModuleName.str(), Filename.str()}).second)
108 NewModuleFiles.push_back(
Filename.str());
117 bool Complain)
override {
119 PrebuiltModuleVFSMap.insert(
120 {CurrentFile, llvm::StringSet<>(VFSOverlayFiles)});
121 return checkHeaderSearchPaths(
122 HSOpts, ExistingHSOpts, Complain ? &Diags :
nullptr, ExistingLangOpts);
126 PrebuiltModuleFilesT &PrebuiltModuleFiles;
132 std::string CurrentFile;
137static bool visitPrebuiltModule(StringRef PrebuiltModuleFilename,
139 PrebuiltModuleFilesT &ModuleFiles,
144 PrebuiltModuleListener Listener(ModuleFiles, Worklist, PrebuiltModuleVFSMap,
148 Listener.visitModuleFile(PrebuiltModuleFilename,
157 while (!Worklist.empty()) {
170static std::string makeObjFileName(StringRef
FileName) {
172 llvm::sys::path::replace_extension(ObjFileName,
"o");
173 return std::string(ObjFileName);
178deduceDepTarget(
const std::string &OutputFile,
180 if (OutputFile !=
"-")
183 if (InputFiles.empty() || !InputFiles.front().isFile())
184 return "clang-scan-deps\\ dependency";
186 return makeObjFileName(InputFiles.front().getFile());
192 DiagOpts.ShowCarets =
false;
203 return llvm::StringSwitch<bool>(Warning)
204 .Cases(
"pch-vfs-diff",
"error=pch-vfs-diff", false)
205 .StartsWith(
"no-error=", false)
220static std::optional<StringRef> getSimpleMacroName(StringRef Macro) {
221 StringRef Name =
Macro.split(
"=").first.ltrim(
" \t");
224 auto FinishName = [&]() -> std::optional<StringRef> {
225 StringRef SimpleName = Name.slice(0, I);
226 if (SimpleName.empty())
231 for (; I != Name.size(); ++I) {
240 if (llvm::isAlnum(Name[I]))
249 using MacroOpt = std::pair<StringRef, std::size_t>;
250 std::vector<MacroOpt> SimpleNames;
251 SimpleNames.reserve(PPOpts.
Macros.size());
252 std::size_t Index = 0;
253 for (
const auto &M : PPOpts.
Macros) {
254 auto SName = getSimpleMacroName(M.first);
258 SimpleNames.emplace_back(*SName, Index);
262 llvm::stable_sort(SimpleNames, [](
const MacroOpt &A,
const MacroOpt &B) {
263 return A.first < B.first;
266 auto NewEnd = std::unique(
267 SimpleNames.rbegin(), SimpleNames.rend(),
268 [](
const MacroOpt &A,
const MacroOpt &B) { return A.first == B.first; });
269 SimpleNames.erase(SimpleNames.begin(), NewEnd.base());
272 decltype(PPOpts.
Macros) NewMacros;
273 NewMacros.reserve(SimpleNames.size());
274 for (std::size_t I = 0, E = SimpleNames.size(); I != E; ++I) {
275 std::size_t OriginalIndex = SimpleNames[I].second;
277 NewMacros.push_back(std::move(PPOpts.
Macros[OriginalIndex]));
279 std::swap(PPOpts.
Macros, NewMacros);
286 DependencyScanningAction(
291 bool EagerLoadModules,
bool DisableFree,
292 std::optional<StringRef> ModuleName = std::nullopt)
293 : WorkingDirectory(WorkingDirectory), Consumer(Consumer),
294 Controller(Controller), DepFS(
std::move(DepFS)), Format(Format),
295 OptimizeArgs(OptimizeArgs), EagerLoadModules(EagerLoadModules),
296 DisableFree(DisableFree), ModuleName(ModuleName) {}
298 bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
300 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
305 OriginalInvocation.getFrontendOpts().DisableFree = DisableFree;
306 if (
any(OptimizeArgs & ScanningOptimizations::Macros))
307 canonicalizeDefines(OriginalInvocation.getPreprocessorOpts());
314 setLastCC1Arguments(std::move(OriginalInvocation));
321 ScanInstanceStorage.emplace(std::move(PCHContainerOps));
332 auto DiagConsumerFinisher =
333 llvm::make_scope_exit([DiagConsumer]() { DiagConsumer->
finish(); });
343 any(OptimizeArgs & ScanningOptimizations::VFS);
359 if (visitPrebuiltModule(
373 if (llvm::ErrorOr<EntryRef> Entry =
374 LocalDepFS->getOrCreateFileSystemEntry(
File.getName()))
375 if (LocalDepFS->ensureDirectiveTokensArePopulated(*Entry))
376 return Entry->getDirectiveTokens();
388 auto Opts = std::make_unique<DependencyOutputOptions>();
392 if (Opts->Targets.empty())
396 Opts->IncludeSystemHeaders =
true;
399 case ScanningOutputFormat::Make:
401 std::make_shared<DependencyConsumerForwarder>(
402 std::move(Opts), WorkingDirectory, Consumer));
404 case ScanningOutputFormat::P1689:
405 case ScanningOutputFormat::Full:
406 MDC = std::make_shared<ModuleDepCollector>(
407 std::move(Opts), ScanInstance, Consumer, Controller,
408 OriginalInvocation, std::move(PrebuiltModuleVFSMap), OptimizeArgs,
409 EagerLoadModules, Format == ScanningOutputFormat::P1689);
428 std::unique_ptr<FrontendAction> Action;
431 Action = std::make_unique<GetDependenciesByModuleNameAction>(*ModuleName);
433 Action = std::make_unique<ReadPCHAndPreprocessAction>();
439 DiagConsumerFinisher.release();
443 setLastCC1Arguments(std::move(OriginalInvocation));
448 bool hasScanned()
const {
return Scanned; }
453 std::vector<std::string> takeLastCC1Arguments() {
454 std::vector<std::string>
Result;
455 std::swap(Result, LastCC1Arguments);
462 MDC->applyDiscoveredDependencies(CI);
463 LastCC1Arguments = CI.getCC1CommandLine();
467 StringRef WorkingDirectory;
473 bool EagerLoadModules;
475 std::optional<StringRef> ModuleName;
476 std::optional<CompilerInstance> ScanInstanceStorage;
477 std::shared_ptr<ModuleDepCollector> MDC;
478 std::vector<std::string> LastCC1Arguments;
479 bool Scanned =
false;
487 : Format(Service.getFormat()), OptimizeArgs(Service.getOptimizeArgs()),
488 EagerLoadModules(Service.shouldEagerLoadModules()) {
489 PCHContainerOps = std::make_shared<PCHContainerOperations>();
491 PCHContainerOps->registerReader(
492 std::make_unique<ObjectFilePCHContainerReader>());
494 PCHContainerOps->registerWriter(std::make_unique<RawPCHContainerWriter>());
510 StringRef WorkingDirectory,
const std::vector<std::string> &CommandLine,
512 std::optional<StringRef> ModuleName) {
513 std::vector<const char *> CLI;
514 for (
const std::string &Arg : CommandLine)
515 CLI.push_back(Arg.c_str());
517 sanitizeDiagOpts(*DiagOpts);
521 std::string DiagnosticOutput;
522 llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);
526 DiagPrinter, ModuleName))
527 return llvm::Error::success();
528 return llvm::make_error<llvm::StringError>(DiagnosticsOS.str(),
529 llvm::inconvertibleErrorCode());
536 Argv.reserve(ArgStrs.size());
537 for (
const std::string &Arg : ArgStrs)
538 Argv.push_back(Arg.c_str());
542 std::unique_ptr<driver::Driver> Driver = std::make_unique<driver::Driver>(
543 Argv[0], llvm::sys::getDefaultTargetTriple(), Diags,
544 "clang LLVM compiler", FS);
545 Driver->setTitle(
"clang_based_tool");
547 llvm::BumpPtrAllocator Alloc;
552 Diags.
Report(diag::err_drv_expand_response_file)
553 << llvm::toString(std::move(E));
557 const std::unique_ptr<driver::Compilation> Compilation(
562 if (Compilation->containsError())
573 std::vector<std::string> CommandLine, DependencyScanningAction &Action,
575 std::shared_ptr<clang::PCHContainerOperations> &PCHContainerOps,
579 std::string Executable = CommandLine[0];
584 if (!Invocation.
run())
587 std::vector<std::string> Args = Action.takeLastCC1Arguments();
593 StringRef WorkingDirectory,
const std::vector<std::string> &CommandLine,
597 BaseFS->setCurrentWorkingDirectory(WorkingDirectory);
599 std::optional<std::vector<std::string>> ModifiedCommandLine;
607 llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(BaseFS);
609 llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
610 InMemoryFS->setCurrentWorkingDirectory(WorkingDirectory);
611 OverlayFS->pushOverlay(InMemoryFS);
612 ModifiedFS = OverlayFS;
616 llvm::sys::fs::createUniquePath(*ModuleName +
"-%%%%%%%%.input",
619 InMemoryFS->addFile(FakeInputPath, 0, llvm::MemoryBuffer::getMemBuffer(
""));
621 ModifiedCommandLine = CommandLine;
622 ModifiedCommandLine->emplace_back(FakeInputPath);
625 const std::vector<std::string> &FinalCommandLine =
626 ModifiedCommandLine ? *ModifiedCommandLine : CommandLine;
627 auto &FinalFS = ModifiedFS ? ModifiedFS : BaseFS;
632 std::vector<const char *> FinalCCommandLine(FinalCommandLine.size(),
nullptr);
633 llvm::transform(FinalCommandLine, FinalCCommandLine.begin(),
634 [](
const std::string &Str) { return Str.c_str(); });
637 sanitizeDiagOpts(*DiagOpts);
645 Diags->setSourceManager(&SrcMgr);
649 bool DisableFree =
true;
650 DependencyScanningAction Action(WorkingDirectory, Consumer, Controller, DepFS,
651 Format, OptimizeArgs, EagerLoadModules,
652 DisableFree, ModuleName);
655 if (FinalCommandLine[1] ==
"-cc1") {
657 PCHContainerOps, *Diags, Consumer);
661 if (StringRef(
Cmd.getCreator().getName()) !=
"clang") {
664 Consumer.handleBuildCommand(
665 {Cmd.getExecutable(),
666 {Cmd.getArguments().begin(), Cmd.getArguments().end()}});
671 std::vector<std::string> Argv;
672 Argv.push_back(
Cmd.getExecutable());
673 Argv.insert(Argv.end(),
Cmd.getArguments().begin(),
674 Cmd.getArguments().end());
681 PCHContainerOps, *Diags, Consumer);
685 if (
Success && !Action.hasScanned())
686 Diags->
Report(diag::err_fe_expected_compiler_job)
687 << llvm::join(FinalCommandLine,
" ");
688 return Success && Action.hasScanned();
static bool forEachDriverJob(ArrayRef< std::string > ArgStrs, DiagnosticsEngine &Diags, FileManager &FM, llvm::function_ref< bool(const driver::Command &Cmd)> Callback)
static bool createAndRunToolInvocation(std::vector< std::string > CommandLine, DependencyScanningAction &Action, FileManager &FM, std::shared_ptr< clang::PCHContainerOperations > &PCHContainerOps, DiagnosticsEngine &Diags, DependencyConsumer &Consumer)
Abstract interface for callback invocations by the ASTReader.
virtual bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts, bool Complain)
Receives the header search paths.
virtual void visitImport(StringRef ModuleName, StringRef Filename)
If needsImportVisitation returns true, this is called for each AST file imported by this AST file.
virtual void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind)
This is called for each AST file loaded.
virtual bool needsImportVisitation() const
Returns true if this ASTReaderListener wants to receive the imports of the AST file via visitImport,...
@ ARR_OutOfDate
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)
Read the control block for the named AST file.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...
FileManager * createFileManager(IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
Create the file manager and replace any existing one with it.
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
void setInvocation(std::shared_ptr< CompilerInvocation > Value)
setInvocation - Replace the current invocation.
FileManager & getFileManager() const
Return the current file manager to the caller.
InMemoryModuleCache & getModuleCache() const
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
FrontendOptions & getFrontendOpts()
bool hasDiagnostics() const
HeaderSearchOptions & getHeaderSearchOpts()
CompilerInvocation & getInvocation()
PreprocessorOptions & getPreprocessorOpts()
bool ExecuteAction(FrontendAction &Act)
ExecuteAction - Execute the provided action against the compiler's CompilerInvocation object.
DiagnosticOptions & getDiagnosticOpts()
LangOptions & getLangOpts()
Helper class for holding the data necessary to invoke the compiler.
DependencyOutputOptions & getDependencyOutputOpts()
ArrayRef< std::string > getDependencies() const
Builds a dependency file when attached to a Preprocessor (for includes) and ASTReader (for module imp...
void finishedMainFile(DiagnosticsEngine &Diags) override
Called when the end of the main file is reached.
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
virtual void finish()
Callback to inform the diagnostic client that processing of all source files has ended.
Options for controlling the compiler diagnostics engine.
std::vector< std::string > Warnings
The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool hasErrorOccurred() const
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
DiagnosticConsumer * getClient()
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
Implements support for file system lookup, file system caching, and directory search management.
llvm::vfs::FileSystem & getVirtualFileSystem() const
llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > getVirtualFileSystemPtr() const
Keeps track of options that affect how file operations are performed.
unsigned ModulesShareFileManager
Whether to share the FileManager when building modules.
std::string OutputFile
The output file, if any.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
bool ModulesCheckRelocated
Perform extra checks when loading PCM files for mutable file systems.
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
bool AllowPCHWithDifferentModulesCachePath
When true, a PCH with modules cache path different to the current compilation will not be rejected.
std::vector< std::pair< std::string, bool > > Macros
std::function< std::optional< ArrayRef< dependency_directives_scan::Directive > >(FileEntryRef)> DependencyDirectivesForFile
Function for getting the dependency preprocessor directives of a file.
This class handles loading and caching of source files into memory.
The base class of the type hierarchy.
Command - An executable path/name and argument vector to execute.
llvm::StringRef getDriverMode(StringRef ProgName, ArrayRef< const char * > Args)
Returns the driver mode option's value, i.e.
llvm::Error expandResponseFiles(SmallVectorImpl< const char * > &Args, bool ClangCLMode, llvm::BumpPtrAllocator &Alloc, llvm::vfs::FileSystem *FS=nullptr)
Expand response files from a clang driver or cc1 invocation.
bool IsClangCL(StringRef DriverMode)
Checks whether the value produced by getDriverMode is for CL mode.
ModuleKind
Specifies the kind of module that has been loaded.
@ MK_ExplicitModule
File is an explicitly-loaded module.
The JSON file list parser is used to communicate input to InstallAPI.
std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)
@ Result
The result type of a method or function.
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
@ Success
Template argument deduction was successful.
int __ovld __cnfn any(char)
Returns 1 if the most significant bit in any component of x is set; otherwise returns 0.