/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/ModuleDependencyCollector.cpp
Line | Count | Source (jump to first uncovered line) |
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/ADT/iterator_range.h" |
18 | | #include "llvm/Config/llvm-config.h" |
19 | | #include "llvm/Support/FileSystem.h" |
20 | | #include "llvm/Support/Path.h" |
21 | | #include "llvm/Support/raw_ostream.h" |
22 | | |
23 | | using namespace clang; |
24 | | |
25 | | namespace { |
26 | | /// Private implementations for ModuleDependencyCollector |
27 | | class ModuleDependencyListener : public ASTReaderListener { |
28 | | ModuleDependencyCollector &Collector; |
29 | | public: |
30 | | ModuleDependencyListener(ModuleDependencyCollector &Collector) |
31 | 38 | : Collector(Collector) {} |
32 | 115 | bool needsInputFileVisitation() override { return true; } |
33 | 75 | bool needsSystemInputFileVisitation() override { return true; } |
34 | | bool visitInputFile(StringRef Filename, bool IsSystem, bool IsOverridden, |
35 | 90 | bool IsExplicitModule) override { |
36 | 90 | Collector.addFile(Filename); |
37 | 90 | return true; |
38 | 90 | } |
39 | | }; |
40 | | |
41 | | struct ModuleDependencyPPCallbacks : public PPCallbacks { |
42 | | ModuleDependencyCollector &Collector; |
43 | | SourceManager &SM; |
44 | | ModuleDependencyPPCallbacks(ModuleDependencyCollector &Collector, |
45 | | SourceManager &SM) |
46 | 46 | : Collector(Collector), SM(SM) {} |
47 | | |
48 | | void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, |
49 | | StringRef FileName, bool IsAngled, |
50 | | CharSourceRange FilenameRange, |
51 | | Optional<FileEntryRef> File, StringRef SearchPath, |
52 | | StringRef RelativePath, const Module *Imported, |
53 | 70 | SrcMgr::CharacteristicKind FileType) override { |
54 | 70 | if (!File) |
55 | 0 | return; |
56 | 70 | Collector.addFile(File->getName()); |
57 | 70 | } |
58 | | }; |
59 | | |
60 | | struct ModuleDependencyMMCallbacks : public ModuleMapCallbacks { |
61 | | ModuleDependencyCollector &Collector; |
62 | | ModuleDependencyMMCallbacks(ModuleDependencyCollector &Collector) |
63 | 46 | : Collector(Collector) {} |
64 | | |
65 | 724 | void moduleMapAddHeader(StringRef HeaderPath) override { |
66 | 724 | if (llvm::sys::path::is_absolute(HeaderPath)) |
67 | 718 | Collector.addFile(HeaderPath); |
68 | 724 | } |
69 | | void moduleMapAddUmbrellaHeader(FileManager *FileMgr, |
70 | 21 | const FileEntry *Header) override { |
71 | 21 | StringRef HeaderFilename = Header->getName(); |
72 | 21 | moduleMapAddHeader(HeaderFilename); |
73 | | // The FileManager can find and cache the symbolic link for a framework |
74 | | // header before its real path, this means a module can have some of its |
75 | | // headers to use other paths. Although this is usually not a problem, it's |
76 | | // inconsistent, and not collecting the original path header leads to |
77 | | // umbrella clashes while rebuilding modules in the crash reproducer. For |
78 | | // example: |
79 | | // ApplicationServices.framework/Frameworks/ImageIO.framework/ImageIO.h |
80 | | // instead of: |
81 | | // ImageIO.framework/ImageIO.h |
82 | | // |
83 | | // FIXME: this shouldn't be necessary once we have FileName instances |
84 | | // around instead of FileEntry ones. For now, make sure we collect all |
85 | | // that we need for the reproducer to work correctly. |
86 | 21 | StringRef UmbreallDirFromHeader = |
87 | 21 | llvm::sys::path::parent_path(HeaderFilename); |
88 | 21 | StringRef UmbrellaDir = Header->getDir()->getName(); |
89 | 21 | if (!UmbrellaDir.equals(UmbreallDirFromHeader)) { |
90 | 4 | SmallString<128> AltHeaderFilename; |
91 | 4 | llvm::sys::path::append(AltHeaderFilename, UmbrellaDir, |
92 | 4 | llvm::sys::path::filename(HeaderFilename)); |
93 | 4 | if (FileMgr->getFile(AltHeaderFilename)) |
94 | 4 | moduleMapAddHeader(AltHeaderFilename); |
95 | 4 | } |
96 | 21 | } |
97 | | }; |
98 | | |
99 | | } |
100 | | |
101 | 38 | void ModuleDependencyCollector::attachToASTReader(ASTReader &R) { |
102 | 38 | R.addListener(std::make_unique<ModuleDependencyListener>(*this)); |
103 | 38 | } |
104 | | |
105 | 46 | void ModuleDependencyCollector::attachToPreprocessor(Preprocessor &PP) { |
106 | 46 | PP.addPPCallbacks(std::make_unique<ModuleDependencyPPCallbacks>( |
107 | 46 | *this, PP.getSourceManager())); |
108 | 46 | PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks( |
109 | 46 | std::make_unique<ModuleDependencyMMCallbacks>(*this)); |
110 | 46 | } |
111 | | |
112 | 16 | static bool isCaseSensitivePath(StringRef Path) { |
113 | 16 | SmallString<256> TmpDest = Path, UpperDest, RealDest; |
114 | | // Remove component traversals, links, etc. |
115 | 16 | if (llvm::sys::fs::real_path(Path, TmpDest)) |
116 | 0 | return true; // Current default value in vfs.yaml |
117 | 16 | Path = TmpDest; |
118 | | |
119 | | // Change path to all upper case and ask for its real path, if the latter |
120 | | // exists and is equal to Path, it's not case sensitive. Default to case |
121 | | // sensitive in the absence of realpath, since this is what the VFSWriter |
122 | | // already expects when sensitivity isn't setup. |
123 | 16 | for (auto &C : Path) |
124 | 2.48k | UpperDest.push_back(toUppercase(C)); |
125 | 16 | if (!llvm::sys::fs::real_path(UpperDest, RealDest) && Path.equals(RealDest)0 ) |
126 | 0 | return false; |
127 | 16 | return true; |
128 | 16 | } |
129 | | |
130 | 24 | void ModuleDependencyCollector::writeFileMap() { |
131 | 24 | if (Seen.empty()) |
132 | 8 | return; |
133 | | |
134 | 16 | StringRef VFSDir = getDest(); |
135 | | |
136 | | // Default to use relative overlay directories in the VFS yaml file. This |
137 | | // allows crash reproducer scripts to work across machines. |
138 | 16 | VFSWriter.setOverlayDir(VFSDir); |
139 | | |
140 | | // Explicitly set case sensitivity for the YAML writer. For that, find out |
141 | | // the sensitivity at the path where the headers all collected to. |
142 | 16 | VFSWriter.setCaseSensitivity(isCaseSensitivePath(VFSDir)); |
143 | | |
144 | | // Do not rely on real path names when executing the crash reproducer scripts |
145 | | // since we only want to actually use the files we have on the VFS cache. |
146 | 16 | VFSWriter.setUseExternalNames(false); |
147 | | |
148 | 16 | std::error_code EC; |
149 | 16 | SmallString<256> YAMLPath = VFSDir; |
150 | 16 | llvm::sys::path::append(YAMLPath, "vfs.yaml"); |
151 | 16 | llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::OF_TextWithCRLF); |
152 | 16 | if (EC) { |
153 | 0 | HasErrors = true; |
154 | 0 | return; |
155 | 0 | } |
156 | 16 | VFSWriter.write(OS); |
157 | 16 | } |
158 | | |
159 | | std::error_code ModuleDependencyCollector::copyToRoot(StringRef Src, |
160 | 531 | StringRef Dst) { |
161 | 531 | using namespace llvm::sys; |
162 | 531 | llvm::FileCollector::PathCanonicalizer::PathStorage Paths = |
163 | 531 | Canonicalizer.canonicalize(Src); |
164 | | |
165 | 531 | SmallString<256> CacheDst = getDest(); |
166 | | |
167 | 531 | if (Dst.empty()) { |
168 | | // The common case is to map the virtual path to the same path inside the |
169 | | // cache. |
170 | 530 | path::append(CacheDst, path::relative_path(Paths.CopyFrom)); |
171 | 530 | } else { |
172 | | // When collecting entries from input vfsoverlays, copy the external |
173 | | // contents into the cache but still map from the source. |
174 | 1 | if (!fs::exists(Dst)) |
175 | 0 | return std::error_code(); |
176 | 1 | path::append(CacheDst, Dst); |
177 | 1 | Paths.CopyFrom = Dst; |
178 | 1 | } |
179 | | |
180 | | // Copy the file into place. |
181 | 531 | if (std::error_code EC = fs::create_directories(path::parent_path(CacheDst), |
182 | 531 | /*IgnoreExisting=*/true)) |
183 | 0 | return EC; |
184 | 531 | if (std::error_code EC = fs::copy_file(Paths.CopyFrom, CacheDst)) |
185 | 2 | return EC; |
186 | | |
187 | | // Always map a canonical src path to its real path into the YAML, by doing |
188 | | // this we map different virtual src paths to the same entry in the VFS |
189 | | // overlay, which is a way to emulate symlink inside the VFS; this is also |
190 | | // needed for correctness, not doing that can lead to module redefinition |
191 | | // errors. |
192 | 529 | addFileMapping(Paths.VirtualPath, CacheDst); |
193 | 529 | return std::error_code(); |
194 | 531 | } |
195 | | |
196 | 870 | void ModuleDependencyCollector::addFile(StringRef Filename, StringRef FileDst) { |
197 | 870 | if (insertSeen(Filename)) |
198 | 531 | if (copyToRoot(Filename, FileDst)) |
199 | 2 | HasErrors = true; |
200 | 870 | } |