1//===--- ModuleDependencyCollector.cpp - Collect module dependencies ------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Collect the dependencies of a set of modules.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/Basic/CharInfo.h"
14#include "clang/Frontend/Utils.h"
15#include "clang/Lex/Preprocessor.h"
16#include "clang/Serialization/ASTReader.h"
17#include "llvm/Config/llvm-config.h"
18#include "llvm/Support/FileSystem.h"
19#include "llvm/Support/Path.h"
20#include "llvm/Support/raw_ostream.h"
21
22using namespace clang;
23
24namespace {
25/// Private implementations for ModuleDependencyCollector
26class ModuleDependencyListener : public ASTReaderListener {
27 ModuleDependencyCollector &Collector;
28 FileManager &FileMgr;
29public:
30 ModuleDependencyListener(ModuleDependencyCollector &Collector,
31 FileManager &FileMgr)
32 : Collector(Collector), FileMgr(FileMgr) {}
33 bool needsInputFileVisitation() override { return true; }
34 bool needsSystemInputFileVisitation() override { return true; }
35 bool visitInputFile(StringRef Filename, bool IsSystem, bool IsOverridden,
36 bool IsExplicitModule) override {
37 // Run this through the FileManager in order to respect 'use-external-name'
38 // in case we have a VFS overlay.
39 if (auto FE = FileMgr.getOptionalFileRef(Filename))
40 Filename = FE->getName();
41 Collector.addFile(Filename);
42 return true;
43 }
44};
45
46struct ModuleDependencyPPCallbacks : public PPCallbacks {
47 ModuleDependencyCollector &Collector;
48 SourceManager &SM;
49 ModuleDependencyPPCallbacks(ModuleDependencyCollector &Collector,
50 SourceManager &SM)
51 : Collector(Collector), SM(SM) {}
52
53 void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
54 StringRef FileName, bool IsAngled,
55 CharSourceRange FilenameRange,
56 OptionalFileEntryRef File, StringRef SearchPath,
57 StringRef RelativePath, const Module *SuggestedModule,
58 bool ModuleImported,
59 SrcMgr::CharacteristicKind FileType) override {
60 if (!File)
61 return;
62 Collector.addFile(Filename: File->getName());
63 }
64};
65
66struct ModuleDependencyMMCallbacks : public ModuleMapCallbacks {
67 ModuleDependencyCollector &Collector;
68 ModuleDependencyMMCallbacks(ModuleDependencyCollector &Collector)
69 : Collector(Collector) {}
70
71 void moduleMapAddHeader(StringRef HeaderPath) override {
72 if (llvm::sys::path::is_absolute(path: HeaderPath))
73 Collector.addFile(Filename: HeaderPath);
74 }
75 void moduleMapAddUmbrellaHeader(FileEntryRef Header) override {
76 moduleMapAddHeader(HeaderPath: Header.getNameAsRequested());
77 }
78};
79
80} // namespace
81
82void ModuleDependencyCollector::attachToASTReader(ASTReader &R) {
83 R.addListener(
84 L: std::make_unique<ModuleDependencyListener>(args&: *this, args&: R.getFileManager()));
85}
86
87void ModuleDependencyCollector::attachToPreprocessor(Preprocessor &PP) {
88 PP.addPPCallbacks(C: std::make_unique<ModuleDependencyPPCallbacks>(
89 args&: *this, args&: PP.getSourceManager()));
90 PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks(
91 Callback: std::make_unique<ModuleDependencyMMCallbacks>(args&: *this));
92}
93
94static bool isCaseSensitivePath(StringRef Path) {
95 SmallString<256> TmpDest = Path, UpperDest, RealDest;
96 // Remove component traversals, links, etc.
97 if (llvm::sys::fs::real_path(path: Path, output&: TmpDest))
98 return true; // Current default value in vfs.yaml
99 Path = TmpDest;
100
101 // Change path to all upper case and ask for its real path, if the latter
102 // exists and is equal to Path, it's not case sensitive. Default to case
103 // sensitive in the absence of realpath, since this is what the VFSWriter
104 // already expects when sensitivity isn't setup.
105 for (auto &C : Path)
106 UpperDest.push_back(Elt: toUppercase(c: C));
107 if (!llvm::sys::fs::real_path(path: UpperDest, output&: RealDest) && Path == RealDest)
108 return false;
109 return true;
110}
111
112void ModuleDependencyCollector::writeFileMap() {
113 if (Seen.empty())
114 return;
115
116 StringRef VFSDir = getDest();
117
118 // Default to use relative overlay directories in the VFS yaml file. This
119 // allows crash reproducer scripts to work across machines.
120 VFSWriter.setOverlayDir(VFSDir);
121
122 // Explicitly set case sensitivity for the YAML writer. For that, find out
123 // the sensitivity at the path where the headers all collected to.
124 VFSWriter.setCaseSensitivity(isCaseSensitivePath(Path: VFSDir));
125
126 // Do not rely on real path names when executing the crash reproducer scripts
127 // since we only want to actually use the files we have on the VFS cache.
128 VFSWriter.setUseExternalNames(false);
129
130 std::error_code EC;
131 SmallString<256> YAMLPath = VFSDir;
132 llvm::sys::path::append(path&: YAMLPath, a: "vfs.yaml");
133 llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::OF_TextWithCRLF);
134 if (EC) {
135 HasErrors = true;
136 return;
137 }
138 VFSWriter.write(OS);
139}
140
141std::error_code ModuleDependencyCollector::copyToRoot(StringRef Src,
142 StringRef Dst) {
143 using namespace llvm::sys;
144 llvm::FileCollector::PathCanonicalizer::PathStorage Paths =
145 Canonicalizer.canonicalize(SrcPath: Src);
146
147 SmallString<256> CacheDst = getDest();
148
149 if (Dst.empty()) {
150 // The common case is to map the virtual path to the same path inside the
151 // cache.
152 path::append(path&: CacheDst, a: path::relative_path(path: Paths.CopyFrom));
153 } else {
154 // When collecting entries from input vfsoverlays, copy the external
155 // contents into the cache but still map from the source.
156 if (!fs::exists(Path: Dst))
157 return std::error_code();
158 path::append(path&: CacheDst, a: Dst);
159 Paths.CopyFrom = Dst;
160 }
161
162 // Copy the file into place.
163 if (std::error_code EC = fs::create_directories(path: path::parent_path(path: CacheDst),
164 /*IgnoreExisting=*/true))
165 return EC;
166 if (std::error_code EC = fs::copy_file(From: Paths.CopyFrom, To: CacheDst))
167 return EC;
168
169 // Always map a canonical src path to its real path into the YAML, by doing
170 // this we map different virtual src paths to the same entry in the VFS
171 // overlay, which is a way to emulate symlink inside the VFS; this is also
172 // needed for correctness, not doing that can lead to module redefinition
173 // errors.
174 addFileMapping(VPath: Paths.VirtualPath, RPath: CacheDst);
175 return std::error_code();
176}
177
178void ModuleDependencyCollector::addFile(StringRef Filename, StringRef FileDst) {
179 if (insertSeen(Filename))
180 if (copyToRoot(Src: Filename, Dst: FileDst))
181 HasErrors = true;
182}
183