clang 8.0.0

ModuleDependencyCollector.cpp
Go to the documentation of this file.
1 //===--- ModuleDependencyCollector.cpp - Collect module dependencies ------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Collect the dependencies of a set of modules.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Basic/CharInfo.h"
15 #include "clang/Frontend/Utils.h"
16 #include "clang/Lex/Preprocessor.h"
17 #include "clang/Serialization/ASTReader.h"
18 #include "llvm/ADT/iterator_range.h"
19 #include "llvm/Config/llvm-config.h"
20 #include "llvm/Support/FileSystem.h"
21 #include "llvm/Support/Path.h"
22 #include "llvm/Support/raw_ostream.h"
23
24 using namespace clang;
25
26 namespace {
27 /// Private implementations for ModuleDependencyCollector
28 class ModuleDependencyListener : public ASTReaderListener {
29 ModuleDependencyCollector &Collector;
30 public:
31 ModuleDependencyListener(ModuleDependencyCollector &Collector)
32 : Collector(Collector) {}
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 Collector.addFile(Filename);
38 return true;
39 }
40 };
41
42 struct ModuleDependencyPPCallbacks : public PPCallbacks {
43 ModuleDependencyCollector &Collector;
44 SourceManager &SM;
45 ModuleDependencyPPCallbacks(ModuleDependencyCollector &Collector,
46 SourceManager &SM)
47 : Collector(Collector), SM(SM) {}
48
49 void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
50 StringRef FileName, bool IsAngled,
51 CharSourceRange FilenameRange, const FileEntry *File,
52 StringRef SearchPath, StringRef RelativePath,
53 const Module *Imported,
54 SrcMgr::CharacteristicKind FileType) override {
55 if (!File)
56 return;
57 Collector.addFile(File->getName());
58 }
59 };
60
61 struct ModuleDependencyMMCallbacks : public ModuleMapCallbacks {
62 ModuleDependencyCollector &Collector;
63 ModuleDependencyMMCallbacks(ModuleDependencyCollector &Collector)
64 : Collector(Collector) {}
65
66 void moduleMapAddHeader(StringRef HeaderPath) override {
67 if (llvm::sys::path::is_absolute(HeaderPath))
68 Collector.addFile(HeaderPath);
69 }
70 void moduleMapAddUmbrellaHeader(FileManager *FileMgr,
71 const FileEntry *Header) override {
72 StringRef HeaderFilename = Header->getName();
73 moduleMapAddHeader(HeaderFilename);
74 // The FileManager can find and cache the symbolic link for a framework
75 // header before its real path, this means a module can have some of its
76 // headers to use other paths. Although this is usually not a problem, it's
77 // inconsistent, and not collecting the original path header leads to
78 // umbrella clashes while rebuilding modules in the crash reproducer. For
79 // example:
80 // ApplicationServices.framework/Frameworks/ImageIO.framework/ImageIO.h
81 // instead of:
82 // ImageIO.framework/ImageIO.h
83 //
84 // FIXME: this shouldn't be necessary once we have FileName instances
85 // around instead of FileEntry ones. For now, make sure we collect all
86 // that we need for the reproducer to work correctly.
87 StringRef UmbreallDirFromHeader =
88 llvm::sys::path::parent_path(HeaderFilename);
89 StringRef UmbrellaDir = Header->getDir()->getName();
90 if (!UmbrellaDir.equals(UmbreallDirFromHeader)) {
91 SmallString<128> AltHeaderFilename;
92 llvm::sys::path::append(AltHeaderFilename, UmbrellaDir,
93 llvm::sys::path::filename(HeaderFilename));
94 if (FileMgr->getFile(AltHeaderFilename))
95 moduleMapAddHeader(AltHeaderFilename);
96 }
97 }
98 };
99
100 }
101
102 // TODO: move this to Support/Path.h and check for HAVE_REALPATH?
103 static bool real_path(StringRef SrcPath, SmallVectorImpl<char> &RealPath) {
104 #ifdef LLVM_ON_UNIX
105 char CanonicalPath[PATH_MAX];
106
107 // TODO: emit a warning in case this fails...?
108 if (!realpath(SrcPath.str().c_str(), CanonicalPath))
109 return false;
110
111 SmallString<256> RPath(CanonicalPath);
112 RealPath.swap(RPath);
113 return true;
114 #else
115 // FIXME: Add support for systems without realpath.
116 return false;
117 #endif
118 }
119
120 void ModuleDependencyCollector::attachToASTReader(ASTReader &R) {
121 R.addListener(llvm::make_unique<ModuleDependencyListener>(*this));
122 }
123
124 void ModuleDependencyCollector::attachToPreprocessor(Preprocessor &PP) {
125 PP.addPPCallbacks(llvm::make_unique<ModuleDependencyPPCallbacks>(
126 *this, PP.getSourceManager()));
127 PP.getHeaderSearchInfo().getModuleMap().addModuleMapCallbacks(
128 llvm::make_unique<ModuleDependencyMMCallbacks>(*this));
129 }
130
131 static bool isCaseSensitivePath(StringRef Path) {
132 SmallString<256> TmpDest = Path, UpperDest, RealDest;
133 // Remove component traversals, links, etc.
134 if (!real_path(Path, TmpDest))
135 return true; // Current default value in vfs.yaml
136 Path = TmpDest;
137
138 // Change path to all upper case and ask for its real path, if the latter
139 // exists and is equal to Path, it's not case sensitive. Default to case
140 // sensitive in the absence of realpath, since this is what the VFSWriter
141 // already expects when sensitivity isn't setup.
142 for (auto &C : Path)
143 UpperDest.push_back(toUppercase(C));
144 if (real_path(UpperDest, RealDest) && Path.equals(RealDest))
145 return false;
146 return true;
147 }
148
149 void ModuleDependencyCollector::writeFileMap() {
150 if (Seen.empty())
151 return;
152
153 StringRef VFSDir = getDest();
154
155 // Default to use relative overlay directories in the VFS yaml file. This
156 // allows crash reproducer scripts to work across machines.
157 VFSWriter.setOverlayDir(VFSDir);
158
159 // Explicitly set case sensitivity for the YAML writer. For that, find out
160 // the sensitivity at the path where the headers all collected to.
161 VFSWriter.setCaseSensitivity(isCaseSensitivePath(VFSDir));
162
163 // Do not rely on real path names when executing the crash reproducer scripts
164 // since we only want to actually use the files we have on the VFS cache.
165 VFSWriter.setUseExternalNames(false);
166
167 std::error_code EC;
168 SmallString<256> YAMLPath = VFSDir;
169 llvm::sys::path::append(YAMLPath, "vfs.yaml");
170 llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::F_Text);
171 if (EC) {
172 HasErrors = true;
173 return;
174 }
175 VFSWriter.write(OS);
176 }
177
178 bool ModuleDependencyCollector::getRealPath(StringRef SrcPath,
179 SmallVectorImpl<char> &Result) {
180 using namespace llvm::sys;
181 SmallString<256> RealPath;
182 StringRef FileName = path::filename(SrcPath);
183 std::string Dir = path::parent_path(SrcPath).str();
184 auto DirWithSymLink = SymLinkMap.find(Dir);
185
186 // Use real_path to fix any symbolic link component present in a path.
187 // Computing the real path is expensive, cache the search through the
188 // parent path directory.
189 if (DirWithSymLink == SymLinkMap.end()) {
190 if (!real_path(Dir, RealPath))
191 return false;
192 SymLinkMap[Dir] = RealPath.str();
193 } else {
194 RealPath = DirWithSymLink->second;
195 }
196
197 path::append(RealPath, FileName);
198 Result.swap(RealPath);
199 return true;
200 }
201
202 std::error_code ModuleDependencyCollector::copyToRoot(StringRef Src,
203 StringRef Dst) {
204 using namespace llvm::sys;
205
206 // We need an absolute src path to append to the root.
207 SmallString<256> AbsoluteSrc = Src;
208 fs::make_absolute(AbsoluteSrc);
209 // Canonicalize src to a native path to avoid mixed separator styles.
210 path::native(AbsoluteSrc);
211 // Remove redundant leading "./" pieces and consecutive separators.
212 AbsoluteSrc = path::remove_leading_dotslash(AbsoluteSrc);
213
214 // Canonicalize the source path by removing "..", "." components.
215 SmallString<256> VirtualPath = AbsoluteSrc;
216 path::remove_dots(VirtualPath, /*remove_dot_dot=*/true);
217
218 // If a ".." component is present after a symlink component, remove_dots may
219 // lead to the wrong real destination path. Let the source be canonicalized
220 // like that but make sure we always use the real path for the destination.
221 SmallString<256> CopyFrom;
222 if (!getRealPath(AbsoluteSrc, CopyFrom))
223 CopyFrom = VirtualPath;
224 SmallString<256> CacheDst = getDest();
225
226 if (Dst.empty()) {
227 // The common case is to map the virtual path to the same path inside the
228 // cache.
229 path::append(CacheDst, path::relative_path(CopyFrom));
230 } else {
231 // When collecting entries from input vfsoverlays, copy the external
232 // contents into the cache but still map from the source.
233 if (!fs::exists(Dst))
234 return std::error_code();
235 path::append(CacheDst, Dst);
236 CopyFrom = Dst;
237 }
238
239 // Copy the file into place.
240 if (std::error_code EC = fs::create_directories(path::parent_path(CacheDst),
241 /*IgnoreExisting=*/true))
242 return EC;
243 if (std::error_code EC = fs::copy_file(CopyFrom, CacheDst))
244 return EC;
245
246 // Always map a canonical src path to its real path into the YAML, by doing
247 // this we map different virtual src paths to the same entry in the VFS
248 // overlay, which is a way to emulate symlink inside the VFS; this is also
249 // needed for correctness, not doing that can lead to module redefinition
250 // errors.
251 addFileMapping(VirtualPath, CacheDst);
252 return std::error_code();
253 }
254
255 void ModuleDependencyCollector::addFile(StringRef Filename, StringRef FileDst) {
256 if (insertSeen(Filename))
257 if (copyToRoot(Filename, FileDst))
258 HasErrors = true;
259 }
clang::FileManager
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:121
clang::ModuleDependencyCollector::attachToASTReader
void attachToASTReader(ASTReader &R) override
Definition: ModuleDependencyCollector.cpp:120
ASTReader.h
sys
clang::SrcMgr::CharacteristicKind
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
clang::HeaderSearch::getModuleMap
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:655
clang::PPCallbacks
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:36
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
clang::Module
Describes a module or submodule.
Definition: Module.h:65
llvm::SmallVectorImpl
Definition: LLVM.h:37
clang::Preprocessor::getHeaderSearchInfo
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:821
clang::ModuleDependencyCollector::attachToPreprocessor
void attachToPreprocessor(Preprocessor &PP) override
Definition: ModuleDependencyCollector.cpp:124
clang::ModuleMap::addModuleMapCallbacks
void addModuleMapCallbacks(std::unique_ptr< ModuleMapCallbacks > Callback)
Add a module map callback.
Definition: ModuleMap.h:414
Utils.h
llvm::SmallString
Definition: LLVM.h:35
clang::FileManager::getFile
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
Definition: FileManager.cpp:183
CharInfo.h
Filename
StringRef Filename
Definition: Format.cpp:1629
clang::CharSourceRange
Represents a character-granular source range.
Definition: SourceLocation.h:236
Preprocessor.h
Defines the clang::Preprocessor interface.
clang::ModuleMapCallbacks
A mechanism to observe the actions of the module map parser as it reads module map files...
Definition: ModuleMap.h:47
clang::InclusionDirective
Record the location of an inclusion directive, such as an #include or #import statement.
Definition: PreprocessingRecord.h:209
clang::ModuleDependencyCollector
Collects the dependencies for imported modules into a directory.
Definition: Utils.h:133
clang::ObjCSubstitutionContext::Result
The result type of a method or function.
SM
const SourceManager & SM
Definition: Format.cpp:1490
clang::Preprocessor::getSourceManager
SourceManager & getSourceManager() const
Definition: Preprocessor.h:819
clang::FileEntry::getDir
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:95
clang::ModuleDependencyCollector::writeFileMap
void writeFileMap()
Definition: ModuleDependencyCollector.cpp:149
clang::ASTReader::addListener
void addListener(std::unique_ptr< ASTReaderListener > L)
Add an AST callback listener.
Definition: ASTReader.h:1582
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::FileEntry::getName
StringRef getName() const
Definition: FileManager.h:85
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:60
clang::ModuleDependencyCollector::addFile
void addFile(StringRef Filename, StringRef FileDst={})
Definition: ModuleDependencyCollector.cpp:255
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
isCaseSensitivePath
static bool isCaseSensitivePath(StringRef Path)
Definition: ModuleDependencyCollector.cpp:131
clang::ASTReader
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:355
clang::ASTReaderListener
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:127
clang::AttrSyntax::C
clang::toUppercase
LLVM_READONLY char toUppercase(char c)
Converts the given ASCII character to its uppercase equivalent.
Definition: CharInfo.h:174
clang::Preprocessor::addPPCallbacks
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:908
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:582
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125
clang::DirectoryEntry::getName
StringRef getName() const
Definition: FileManager.h:52
real_path
static bool real_path(StringRef SrcPath, SmallVectorImpl< char > &RealPath)
Definition: ModuleDependencyCollector.cpp:103