Expand Up
@@ -6,6 +6,7 @@
//
// ===----------------------------------------------------------------------===//
#include " clang/Driver/Compilation.h"
#include " clang/Driver/Driver.h"
#include " clang/Frontend/CompilerInstance.h"
#include " clang/Tooling/CommonOptionsParser.h"
Expand All
@@ -17,6 +18,7 @@
#include " llvm/ADT/Twine.h"
#include " llvm/Support/CommandLine.h"
#include " llvm/Support/FileUtilities.h"
#include " llvm/Support/Host.h"
#include " llvm/Support/InitLLVM.h"
#include " llvm/Support/JSON.h"
#include " llvm/Support/Program.h"
Expand Down
Expand Up
@@ -131,12 +133,15 @@ static llvm::cl::opt<ScanningMode> ScanMode(
static llvm::cl::opt<ScanningOutputFormat> Format (
" format" " The output format for the dependencies"
llvm::cl::values(clEnumValN(ScanningOutputFormat::Make, " make"
" Makefile compatible dep file"
clEnumValN(ScanningOutputFormat::Full, " experimental-full"
" Full dependency graph suitable"
" for explicitly building modules. This format "
" is experimental and will change."
llvm::cl::values(
clEnumValN (ScanningOutputFormat::Make, " make"
" Makefile compatible dep file"
clEnumValN(ScanningOutputFormat::P1689, " p1689"
" Generate standard c++ modules dependency P1689 format"
clEnumValN(ScanningOutputFormat::Full, " experimental-full"
" Full dependency graph suitable"
" for explicitly building modules. This format "
" is experimental and will change."
llvm::cl::init(ScanningOutputFormat::Make),
llvm::cl::cat(DependencyScannerCategory));
Expand Down
Expand Up
@@ -165,9 +170,14 @@ llvm::cl::opt<unsigned>
llvm::cl::opt<std::string>
CompilationDB (" compilation-database"
llvm::cl::desc (" Compilation database" Required ,
llvm::cl::desc (" Compilation database" Optional ,
llvm::cl::cat(DependencyScannerCategory));
llvm::cl::opt<std::string> P1689TargettedCommand (
llvm::cl::Positional, llvm::cl::ZeroOrMore,
llvm::cl::desc (" The command line flags for the target of which "
" the dependencies are to be computed."
llvm::cl::opt<std::string> ModuleName (
" module-name"
llvm::cl::desc (" the module of which the dependencies are to be computed"
Expand Down
Expand Up
@@ -402,6 +412,92 @@ static bool handleFullDependencyToolResult(
return false ;
}
class P1689Deps {
public:
void printDependencies (raw_ostream &OS) {
addSourcePathsToRequires ();
// Sort the modules by name to get a deterministic order.
llvm::sort (Rules, [](const P1689Rule &A, const P1689Rule &B) {
return A.PrimaryOutput < B.PrimaryOutput ;
});
using namespace llvm ::json;
Array OutputRules;
for (const P1689Rule &R : Rules) {
Object O{{" primary-output" PrimaryOutput }};
if (R.Provides ) {
Array Provides;
Object Provided{{" logical-name" Provides ->ModuleName },
{" source-path" Provides ->SourcePath },
{" is-interface" Provides ->IsStdCXXModuleInterface }};
Provides.push_back (std::move (Provided));
O.insert ({" provides" std::move (Provides)});
}
Array Requires;
for (const P1689ModuleInfo &Info : R.Requires ) {
Object RequiredInfo{{" logical-name" ModuleName }};
if (!Info.SourcePath .empty ())
RequiredInfo.insert ({" source-path" SourcePath });
Requires.push_back (std::move (RequiredInfo));
}
if (!Requires.empty ())
O.insert ({" requires" std::move (Requires)});
OutputRules.push_back (std::move (O));
}
Object Output{
{" version" 1 }, {" revision" 0 }, {" rules" std::move (OutputRules)}};
OS << llvm::formatv (" {0:2}\n " Value (std::move (Output)));
}
void addRules (P1689Rule &Rule) {
std::unique_lock<std::mutex> LockGuard (Lock);
Rules.push_back (Rule);
}
private:
void addSourcePathsToRequires () {
llvm::DenseMap<StringRef, StringRef> ModuleSourceMapper;
for (const P1689Rule &R : Rules)
if (R.Provides && !R.Provides ->SourcePath .empty ())
ModuleSourceMapper[R.Provides ->ModuleName ] = R.Provides ->SourcePath ;
for (P1689Rule &R : Rules) {
for (P1689ModuleInfo &Info : R.Requires ) {
auto Iter = ModuleSourceMapper.find (Info.ModuleName );
if (Iter != ModuleSourceMapper.end ())
Info.SourcePath = Iter->second ;
}
}
}
std::mutex Lock;
std::vector<P1689Rule> Rules;
};
static bool
handleP1689DependencyToolResult (const std::string &Input,
llvm::Expected<P1689Rule> &MaybeRule,
P1689Deps &PD, SharedStream &Errs) {
if (!MaybeRule) {
llvm::handleAllErrors (
MaybeRule.takeError (), [&Input, &Errs](llvm::StringError &Err) {
Errs.applyLocked ([&](raw_ostream &OS) {
OS << " Error while scanning dependencies for " " :\n "
OS << Err.getMessage ();
});
});
return true ;
}
PD.addRules (*MaybeRule);
return false ;
}
// / Construct a path for the explicitly built PCM.
static std::string constructPCMPath (ModuleID MID, StringRef OutputDir) {
SmallString<256 > ExplicitPCMPath (OutputDir);
Expand Down
Expand Up
@@ -438,19 +534,109 @@ static std::string getModuleCachePath(ArrayRef<std::string> Args) {
return std::string (Path);
}
int main (int argc, const char **argv) {
// getCompilationDataBase - If -compilation-database is set, load the
// compilation database from the specified file. Otherwise if the we're
// generating P1689 format, trying to generate the compilation database
// form specified command line after the positional parameter "--".
static std::unique_ptr<tooling::CompilationDatabase>
getCompilationDataBase (int argc, const char **argv, std::string &ErrorMessage) {
llvm::InitLLVM X (argc, argv);
llvm::cl::HideUnrelatedOptions (DependencyScannerCategory);
if (!llvm::cl::ParseCommandLineOptions (argc, argv))
return 1 ;
return nullptr ;
if (!CompilationDB.empty ())
return tooling::JSONCompilationDatabase::loadFromFile (
CompilationDB, ErrorMessage,
tooling::JSONCommandLineSyntax::AutoDetect);
if (Format != ScanningOutputFormat::P1689) {
llvm::errs () << " the --compilation-database option: must be specified at "
" least once!"
return nullptr ;
}
// Trying to get the input file, the output file and the command line options
// from the positional parameter "--".
const char **DoubleDash = std::find (argv, argv + argc, StringRef (" --"
if (DoubleDash == argv + argc) {
llvm::errs () << " The command line arguments is required after '--' in "
" P1689 per file mode."
return nullptr ;
}
std::vector<const char *> CommandLine (DoubleDash + 1 , argv + argc);
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
CompilerInstance::createDiagnostics (new DiagnosticOptions);
driver::Driver TheDriver (CommandLine[0 ], llvm::sys::getDefaultTargetTriple (),
*Diags);
std::unique_ptr<driver::Compilation> C (
TheDriver.BuildCompilation (CommandLine));
if (!C)
return nullptr ;
auto Cmd = C->getJobs ().begin ();
auto CI = std::make_unique<CompilerInvocation>();
CompilerInvocation::CreateFromArgs (*CI, Cmd->getArguments (), *Diags,
CommandLine[0 ]);
if (!CI)
return nullptr ;
FrontendOptions &FEOpts = CI->getFrontendOpts ();
if (FEOpts.Inputs .size () != 1 ) {
llvm::errs () << " Only one input file is allowed in P1689 per file mode."
return nullptr ;
}
// There might be multiple jobs for a compilation. Extract the specified
// output filename from the last job.
auto LastCmd = C->getJobs ().end ();
LastCmd--;
if (LastCmd->getOutputFilenames ().size () != 1 ) {
llvm::errs () << " The command line should provide exactly one output file "
" in P1689 per file mode.\n "
}
StringRef OutputFile = LastCmd->getOutputFilenames ().front ();
class InplaceCompilationDatabase : public tooling ::CompilationDatabase {
public:
InplaceCompilationDatabase (StringRef InputFile, StringRef OutputFile,
ArrayRef<const char *> CommandLine)
: Command(" ."
for (auto *C : CommandLine)
Command.CommandLine .push_back (C);
}
std::vector<tooling::CompileCommand>
getCompileCommands (StringRef FilePath) const override {
if (FilePath != Command.Filename )
return {};
return {Command};
}
std::vector<std::string> getAllFiles () const override {
return {Command.Filename };
}
std::vector<tooling::CompileCommand>
getAllCompileCommands () const override {
return {Command};
}
private:
tooling::CompileCommand Command;
};
return std::make_unique<InplaceCompilationDatabase>(
FEOpts.Inputs [0 ].getFile (), OutputFile, CommandLine);
}
int main (int argc, const char **argv) {
std::string ErrorMessage;
std::unique_ptr<tooling::JSONCompilationDatabase> Compilations =
tooling::JSONCompilationDatabase::loadFromFile (
CompilationDB, ErrorMessage,
tooling::JSONCommandLineSyntax::AutoDetect);
std::unique_ptr<tooling::CompilationDatabase> Compilations =
getCompilationDataBase (argc, argv, ErrorMessage);
if (!Compilations) {
llvm::errs () << " error: " << ErrorMessage << " \n "
llvm::errs () << ErrorMessage << " \n "
return 1 ;
}
Expand Down
Expand Up
@@ -537,6 +723,7 @@ int main(int argc, const char **argv) {
std::atomic<bool > HadErrors (false );
FullDeps FD;
P1689Deps PD;
std::mutex Lock;
size_t Index = 0 ;
Expand All
@@ -545,7 +732,7 @@ int main(int argc, const char **argv) {
<< " files using " getThreadCount () << " workers\n "
}
for (unsigned I = 0 ; I < Pool.getThreadCount (); ++I) {
Pool.async ([I, &Lock, &Index, &Inputs, &HadErrors, &FD, &WorkerTools,
Pool.async ([I, &Lock, &Index, &Inputs, &HadErrors, &FD, &PD, & WorkerTools,
&DependencyOS, &Errs]() {
llvm::StringSet<> AlreadySeenModules;
while (true ) {
Expand Down
Expand Up
@@ -581,6 +768,47 @@ int main(int argc, const char **argv) {
if (handleMakeDependencyToolResult (Filename, MaybeFile, DependencyOS,
Errs))
HadErrors = true ;
} else if (Format == ScanningOutputFormat::P1689) {
// It is useful to generate the make-format dependency output during
// the scanning for P1689. Otherwise the users need to scan again for
// it. We will generate the make-format dependency output if we find
// `-MF` in the command lines.
std::string MakeformatOutputPath;
std::string MakeformatOutput;
auto MaybeRule = WorkerTools[I]->getP1689ModuleDependencyFile (
*Input, CWD, MakeformatOutput, MakeformatOutputPath);
HadErrors =
handleP1689DependencyToolResult (Filename, MaybeRule, PD, Errs);
if (!MakeformatOutputPath.empty () && !MakeformatOutput.empty () &&
!HadErrors) {
static std::mutex Lock;
// With compilation database, we may open different files
// concurrently or we may write the same file concurrently. So we
// use a map here to allow multiple compile commands to write to the
// same file. Also we need a lock here to avoid data race.
static llvm::StringMap<llvm::raw_fd_ostream> OSs;
std::unique_lock<std::mutex> LockGuard (Lock);
auto OSIter = OSs.find (MakeformatOutputPath);
if (OSIter == OSs.end ()) {
std::error_code EC;
OSIter = OSs.try_emplace (MakeformatOutputPath,
MakeformatOutputPath, EC)
.first ;
if (EC)
llvm::errs ()
<< " Failed to open P1689 make format output file \" "
<< MakeformatOutputPath << " \" for " message ()
<< " \n "
}
SharedStream MakeformatOS (OSIter->second );
llvm::Expected<std::string> MaybeOutput (MakeformatOutput);
HadErrors = handleMakeDependencyToolResult (Filename, MaybeOutput,
MakeformatOS, Errs);
}
} else if (DeprecatedDriverCommand) {
auto MaybeFullDeps =
WorkerTools[I]->getFullDependenciesLegacyDriverCommand (
Expand All
@@ -604,6 +832,8 @@ int main(int argc, const char **argv) {
if (Format == ScanningOutputFormat::Full)
FD.printFullOutput (llvm::outs ());
else if (Format == ScanningOutputFormat::P1689)
PD.printDependencies (llvm::outs ());
return HadErrors;
}