clang  8.0.0svn
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"
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;
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 
121  R.addListener(llvm::make_unique<ModuleDependencyListener>(*this));
122 }
123 
125  PP.addPPCallbacks(llvm::make_unique<ModuleDependencyPPCallbacks>(
126  *this, PP.getSourceManager()));
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 
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  // Do not ignore non existent contents otherwise we might skip something
160  // that should have been collected here.
161  VFSWriter.setIgnoreNonExistentContents(false);
162 
163  // Explicitly set case sensitivity for the YAML writer. For that, find out
164  // the sensitivity at the path where the headers all collected to.
165  VFSWriter.setCaseSensitivity(isCaseSensitivePath(VFSDir));
166 
167  // Do not rely on real path names when executing the crash reproducer scripts
168  // since we only want to actually use the files we have on the VFS cache.
169  VFSWriter.setUseExternalNames(false);
170 
171  std::error_code EC;
172  SmallString<256> YAMLPath = VFSDir;
173  llvm::sys::path::append(YAMLPath, "vfs.yaml");
174  llvm::raw_fd_ostream OS(YAMLPath, EC, llvm::sys::fs::F_Text);
175  if (EC) {
176  HasErrors = true;
177  return;
178  }
179  VFSWriter.write(OS);
180 }
181 
182 bool ModuleDependencyCollector::getRealPath(StringRef SrcPath,
184  using namespace llvm::sys;
185  SmallString<256> RealPath;
186  StringRef FileName = path::filename(SrcPath);
187  std::string Dir = path::parent_path(SrcPath).str();
188  auto DirWithSymLink = SymLinkMap.find(Dir);
189 
190  // Use real_path to fix any symbolic link component present in a path.
191  // Computing the real path is expensive, cache the search through the
192  // parent path directory.
193  if (DirWithSymLink == SymLinkMap.end()) {
194  if (!real_path(Dir, RealPath))
195  return false;
196  SymLinkMap[Dir] = RealPath.str();
197  } else {
198  RealPath = DirWithSymLink->second;
199  }
200 
201  path::append(RealPath, FileName);
202  Result.swap(RealPath);
203  return true;
204 }
205 
206 std::error_code ModuleDependencyCollector::copyToRoot(StringRef Src,
207  StringRef Dst) {
208  using namespace llvm::sys;
209 
210  // We need an absolute src path to append to the root.
211  SmallString<256> AbsoluteSrc = Src;
212  fs::make_absolute(AbsoluteSrc);
213  // Canonicalize src to a native path to avoid mixed separator styles.
214  path::native(AbsoluteSrc);
215  // Remove redundant leading "./" pieces and consecutive separators.
216  AbsoluteSrc = path::remove_leading_dotslash(AbsoluteSrc);
217 
218  // Canonicalize the source path by removing "..", "." components.
219  SmallString<256> VirtualPath = AbsoluteSrc;
220  path::remove_dots(VirtualPath, /*remove_dot_dot=*/true);
221 
222  // If a ".." component is present after a symlink component, remove_dots may
223  // lead to the wrong real destination path. Let the source be canonicalized
224  // like that but make sure we always use the real path for the destination.
225  SmallString<256> CopyFrom;
226  if (!getRealPath(AbsoluteSrc, CopyFrom))
227  CopyFrom = VirtualPath;
228  SmallString<256> CacheDst = getDest();
229 
230  if (Dst.empty()) {
231  // The common case is to map the virtual path to the same path inside the
232  // cache.
233  path::append(CacheDst, path::relative_path(CopyFrom));
234  } else {
235  // When collecting entries from input vfsoverlays, copy the external
236  // contents into the cache but still map from the source.
237  if (!fs::exists(Dst))
238  return std::error_code();
239  path::append(CacheDst, Dst);
240  CopyFrom = Dst;
241  }
242 
243  // Copy the file into place.
244  if (std::error_code EC = fs::create_directories(path::parent_path(CacheDst),
245  /*IgnoreExisting=*/true))
246  return EC;
247  if (std::error_code EC = fs::copy_file(CopyFrom, CacheDst))
248  return EC;
249 
250  // Always map a canonical src path to its real path into the YAML, by doing
251  // this we map different virtual src paths to the same entry in the VFS
252  // overlay, which is a way to emulate symlink inside the VFS; this is also
253  // needed for correctness, not doing that can lead to module redefinition
254  // errors.
255  addFileMapping(VirtualPath, CacheDst);
256  return std::error_code();
257 }
258 
259 void ModuleDependencyCollector::addFile(StringRef Filename, StringRef FileDst) {
260  if (insertSeen(Filename))
261  if (copyToRoot(Filename, FileDst))
262  HasErrors = true;
263 }
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
void attachToASTReader(ASTReader &R) override
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:657
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:36
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
Describes a module or submodule.
Definition: Module.h:65
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:830
void attachToPreprocessor(Preprocessor &PP) override
void addModuleMapCallbacks(std::unique_ptr< ModuleMapCallbacks > Callback)
Add a module map callback.
Definition: ModuleMap.h:412
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
StringRef Filename
Definition: Format.cpp:1605
Represents a character-granular source range.
Defines the clang::Preprocessor interface.
A mechanism to observe the actions of the module map parser as it reads module map files...
Definition: ModuleMap.h:47
Record the location of an inclusion directive, such as an #include or #import statement.
Collects the dependencies for imported modules into a directory.
Definition: Utils.h:133
The result type of a method or function.
const SourceManager & SM
Definition: Format.cpp:1475
SourceManager & getSourceManager() const
Definition: Preprocessor.h:828
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:94
void addListener(std::unique_ptr< ASTReaderListener > L)
Add an AST callback listener.
Definition: ASTReader.h:1581
Encodes a location in the source.
StringRef getName() const
Definition: FileManager.h:84
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
void addFile(StringRef Filename, StringRef FileDst={})
Dataflow Directional Tag Classes.
static bool isCaseSensitivePath(StringRef Path)
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:126
LLVM_READONLY char toUppercase(char c)
Converts the given ASCII character to its uppercase equivalent.
Definition: CharInfo.h:174
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:921
This class handles loading and caching of source files into memory.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
StringRef getName() const
Definition: FileManager.h:51
static bool real_path(StringRef SrcPath, SmallVectorImpl< char > &RealPath)