maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[clang][deps] Generate '-fmodule-file=' only for direct dependencies 

The `clang-scan-deps` tool currently generates `-fmodule-file=` command-line arguments for the whole transitive closure of modular dependencies. This is not necessary, we only need to provide the direct dependencies on the command line. Information about transitive dependencies is stored within the `.pcm` files of direct dependencies. This makes the command lines shorter, but should be a NFC otherwise (unless there are bugs in the loading mechanism for explicit modules).

Depends on D120465.

Reviewed By: Bigcheese

Differential Revision: https://reviews.llvm.org/D118915
This commit is contained in:
Jan Svoboda 2022-03-12 11:32:47 +01:00
parent a6ef363546
commit 7f6af60746
7 changed files with 17 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
clang/include/clang/Tooling/DependencyScanning/DependencyScanningTool.h
View File

@ -51,12 +51,8 @@ struct FullDependencies {
/// arguments and the "-o" argument. It needs to return
/// a path for where the PCM for the given module is to
/// be located.
/// \param LookupModuleDeps This function is called to collect the full
/// transitive set of dependencies for this
/// compilation.
std::vector<std::string> getCommandLine(
std::function<StringRef(ModuleID)> LookupPCMPath,
std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps) const;
std::vector<std::string>
getCommandLine(std::function<StringRef(ModuleID)> LookupPCMPath) const;
/// Get the full command line, excluding -fmodule-file=" arguments.
std::vector<std::string> getCommandLineWithoutModulePaths() const;

15
clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
View File

@ -113,27 +113,14 @@ struct ModuleDeps {
/// arguments and the "-o" argument. It needs to return
/// a path for where the PCM for the given module is to
/// be located.
/// \param LookupModuleDeps This function is called to collect the full
/// transitive set of dependencies for this
/// compilation.
std::vector<std::string> getCanonicalCommandLine(
std::function<StringRef(ModuleID)> LookupPCMPath,
std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps) const;
std::function<StringRef(ModuleID)> LookupPCMPath) const;
/// Gets the canonical command line suitable for passing to clang, excluding
/// "-fmodule-file=" and "-o" arguments.
std::vector<std::string> getCanonicalCommandLineWithoutModulePaths() const;
};
namespace detail {
/// Collect the paths of PCM for the modules in \c Modules transitively.
void collectPCMPaths(
llvm::ArrayRef<ModuleID> Modules,
std::function<StringRef(ModuleID)> LookupPCMPath,
std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps,
std::vector<std::string> &PCMPaths);
} // namespace detail
class ModuleDepCollector;
/// Callback that records textual includes and direct modular includes/imports

10
clang/lib/Tooling/DependencyScanning/DependencyScanningTool.cpp
View File

@ -14,15 +14,11 @@ namespace tooling {
namespace dependencies {
std::vector<std::string> FullDependencies::getCommandLine(
std::function<StringRef(ModuleID)> LookupPCMPath,
std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps) const {
std::function<StringRef(ModuleID)> LookupPCMPath) const {
std::vector<std::string> Ret = getCommandLineWithoutModulePaths();
std::vector<std::string> PCMPaths;
dependencies::detail::collectPCMPaths(ClangModuleDeps, LookupPCMPath,
LookupModuleDeps, PCMPaths);
for (const std::string &PCMPath : PCMPaths)
Ret.push_back("-fmodule-file=" + PCMPath);
for (ModuleID MID : ClangModuleDeps)
Ret.push_back(("-fmodule-file=" + LookupPCMPath(MID)).str());
return Ret;
}

30
clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
View File

@ -87,8 +87,7 @@ serializeCompilerInvocation(const CompilerInvocation &CI) {
}
std::vector<std::string> ModuleDeps::getCanonicalCommandLine(
std::function<StringRef(ModuleID)> LookupPCMPath,
std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps) const {
std::function<StringRef(ModuleID)> LookupPCMPath) const {
CompilerInvocation CI(BuildInvocation);
FrontendOptions &FrontendOpts = CI.getFrontendOpts();
@ -97,9 +96,8 @@ std::vector<std::string> ModuleDeps::getCanonicalCommandLine(
FrontendOpts.Inputs.emplace_back(ClangModuleMapFile, ModuleMapInputKind);
FrontendOpts.OutputFile = std::string(LookupPCMPath(ID));
dependencies::detail::collectPCMPaths(ClangModuleDeps, LookupPCMPath,
LookupModuleDeps,
FrontendOpts.ModuleFiles);
for (ModuleID MID : ClangModuleDeps)
FrontendOpts.ModuleFiles.emplace_back(LookupPCMPath(MID));
return serializeCompilerInvocation(CI);
}
@ -109,28 +107,6 @@ ModuleDeps::getCanonicalCommandLineWithoutModulePaths() const {
return serializeCompilerInvocation(BuildInvocation);
}
void dependencies::detail::collectPCMPaths(
llvm::ArrayRef<ModuleID> Modules,
std::function<StringRef(ModuleID)> LookupPCMPath,
std::function<const ModuleDeps &(ModuleID)> LookupModuleDeps,
std::vector<std::string> &PCMPaths) {
llvm::StringSet<> AlreadyAdded;
std::function<void(llvm::ArrayRef<ModuleID>)> AddArgs =
[&](llvm::ArrayRef<ModuleID> Modules) {
for (const ModuleID &MID : Modules) {
if (!AlreadyAdded.insert(MID.ModuleName + MID.ContextHash).second)
continue;
const ModuleDeps &M = LookupModuleDeps(MID);
// Depth first traversal.
AddArgs(M.ClangModuleDeps);
PCMPaths.push_back(LookupPCMPath(MID).str());
}
};
AddArgs(Modules);
}
void ModuleDepCollectorPP::FileChanged(SourceLocation Loc,
FileChangeReason Reason,
SrcMgr::CharacteristicKind FileType,

2
clang/test/ClangScanDeps/modules-full.cpp
View File

@ -169,9 +169,7 @@
// CHECK: "-fno-implicit-modules"
// CHECK-NEXT: "-fno-implicit-module-maps"
// CHECK-NO-ABS-NOT: "-fmodule-file={{.*}}"
// CHECK-ABS-NEXT: "-fmodule-file=[[PREFIX]]/module-cache{{(_clangcl)?}}/[[HASH_H2_DINCLUDE]]/header2-{{[A-Z0-9]+}}.pcm"
// CHECK-ABS-NEXT: "-fmodule-file=[[PREFIX]]/module-cache{{(_clangcl)?}}/[[HASH_H1_DINCLUDE]]/header1-{{[A-Z0-9]+}}.pcm"
// CHECK-CUSTOM-NEXT: "-fmodule-file=[[PREFIX]]/custom/[[HASH_H2_DINCLUDE]]/header2-{{[A-Z0-9]+}}.pcm"
// CHECK-CUSTOM-NEXT: "-fmodule-file=[[PREFIX]]/custom/[[HASH_H1_DINCLUDE]]/header1-{{[A-Z0-9]+}}.pcm"
// CHECK-NEXT: ],
// CHECK-NEXT: "file-deps": [

1
clang/test/ClangScanDeps/modules-pch.c
View File

@ -97,7 +97,6 @@
// CHECK-PCH: "-fno-implicit-modules",
// CHECK-PCH-NEXT: "-fno-implicit-module-maps",
// CHECK-PCH-NEXT: "-fmodule-file=[[PREFIX]]/build/[[HASH_MOD_COMMON_1]]/ModCommon1-{{.*}}.pcm",
// CHECK-PCH-NEXT: "-fmodule-file=[[PREFIX]]/build/[[HASH_MOD_COMMON_2]]/ModCommon2-{{.*}}.pcm",
// CHECK-PCH-NEXT: "-fmodule-file=[[PREFIX]]/build/[[HASH_MOD_PCH]]/ModPCH-{{.*}}.pcm"
// CHECK-PCH-NEXT: ],
// CHECK-PCH-NEXT: "file-deps": [

24
clang/tools/clang-scan-deps/ClangScanDeps.cpp
View File

@ -298,10 +298,7 @@ public:
ID.CommandLine = GenerateModulesPathArgs
? FD.getCommandLine(
[&](ModuleID MID) { return lookupPCMPath(MID); },
[&](ModuleID MID) -> const ModuleDeps & {
return lookupModuleDeps(MID);
})
[&](ModuleID MID) { return lookupPCMPath(MID); })
: FD.getCommandLineWithoutModulePaths();
Inputs.push_back(std::move(ID));
@ -336,10 +333,7 @@ public:
{"command-line",
GenerateModulesPathArgs
? MD.getCanonicalCommandLine(
[&](ModuleID MID) { return lookupPCMPath(MID); },
[&](ModuleID MID) -> const ModuleDeps & {
return lookupModuleDeps(MID);
})
[&](ModuleID MID) { return lookupPCMPath(MID); })
: MD.getCanonicalCommandLineWithoutModulePaths()},
};
OutModules.push_back(std::move(O));
@ -369,12 +363,16 @@ private:
StringRef lookupPCMPath(ModuleID MID) {
auto PCMPath = PCMPaths.insert({MID, ""});
if (PCMPath.second)
PCMPath.first->second = constructPCMPath(lookupModuleDeps(MID));
PCMPath.first->second = constructPCMPath(MID);
return PCMPath.first->second;
}
/// Construct a path for the explicitly built PCM.
std::string constructPCMPath(const ModuleDeps &MD) const {
std::string constructPCMPath(ModuleID MID) const {
auto MDIt = Modules.find(IndexedModuleID{MID, 0});
assert(MDIt != Modules.end());
const ModuleDeps &MD = MDIt->second;
StringRef Filename = llvm::sys::path::filename(MD.ImplicitModulePCMPath);
SmallString<256> ExplicitPCMPath(
@ -385,12 +383,6 @@ private:
return std::string(ExplicitPCMPath);
}
const ModuleDeps &lookupModuleDeps(ModuleID MID) {
auto I = Modules.find(IndexedModuleID{MID, 0});
assert(I != Modules.end());
return I->second;
};
struct IndexedModuleID {
ModuleID ID;
mutable size_t InputIndex;