clang  10.0.0svn
FileManager.cpp
Go to the documentation of this file.
1 //===--- FileManager.cpp - File System Probing and Caching ----------------===//
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 // This file implements the FileManager interface.
10 //
11 //===----------------------------------------------------------------------===//
12 //
13 // TODO: This should index all interesting directories with dirent calls.
14 // getdirentries ?
15 // opendir/readdir_r/closedir ?
16 //
17 //===----------------------------------------------------------------------===//
18 
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/Statistic.h"
24 #include "llvm/Config/llvm-config.h"
25 #include "llvm/Support/FileSystem.h"
26 #include "llvm/Support/MemoryBuffer.h"
27 #include "llvm/Support/Path.h"
28 #include "llvm/Support/raw_ostream.h"
29 #include <algorithm>
30 #include <cassert>
31 #include <climits>
32 #include <cstdint>
33 #include <cstdlib>
34 #include <string>
35 #include <utility>
36 
37 using namespace clang;
38 
39 #define DEBUG_TYPE "file-search"
40 
41 ALWAYS_ENABLED_STATISTIC(NumDirLookups, "Number of directory lookups.");
42 ALWAYS_ENABLED_STATISTIC(NumFileLookups, "Number of file lookups.");
43 ALWAYS_ENABLED_STATISTIC(NumDirCacheMisses,
44  "Number of directory cache misses.");
45 ALWAYS_ENABLED_STATISTIC(NumFileCacheMisses, "Number of file cache misses.");
46 
47 //===----------------------------------------------------------------------===//
48 // Common logic.
49 //===----------------------------------------------------------------------===//
50 
53  : FS(std::move(FS)), FileSystemOpts(FSO), SeenDirEntries(64),
54  SeenFileEntries(64), NextFileUID(0) {
55  // If the caller doesn't provide a virtual file system, just grab the real
56  // file system.
57  if (!this->FS)
58  this->FS = llvm::vfs::getRealFileSystem();
59 }
60 
61 FileManager::~FileManager() = default;
62 
63 void FileManager::setStatCache(std::unique_ptr<FileSystemStatCache> statCache) {
64  assert(statCache && "No stat cache provided?");
65  StatCache = std::move(statCache);
66 }
67 
68 void FileManager::clearStatCache() { StatCache.reset(); }
69 
70 /// Retrieve the directory that the given file name resides in.
71 /// Filename can point to either a real file or a virtual file.
72 static llvm::ErrorOr<const DirectoryEntry *>
74  bool CacheFailure) {
75  if (Filename.empty())
76  return std::errc::no_such_file_or_directory;
77 
78  if (llvm::sys::path::is_separator(Filename[Filename.size() - 1]))
79  return std::errc::is_a_directory;
80 
81  StringRef DirName = llvm::sys::path::parent_path(Filename);
82  // Use the current directory if file has no path component.
83  if (DirName.empty())
84  DirName = ".";
85 
86  return FileMgr.getDirectory(DirName, CacheFailure);
87 }
88 
89 /// Add all ancestors of the given path (pointing to either a file or
90 /// a directory) as virtual directories.
91 void FileManager::addAncestorsAsVirtualDirs(StringRef Path) {
92  StringRef DirName = llvm::sys::path::parent_path(Path);
93  if (DirName.empty())
94  DirName = ".";
95 
96  auto &NamedDirEnt = *SeenDirEntries.insert(
97  {DirName, std::errc::no_such_file_or_directory}).first;
98 
99  // When caching a virtual directory, we always cache its ancestors
100  // at the same time. Therefore, if DirName is already in the cache,
101  // we don't need to recurse as its ancestors must also already be in
102  // the cache (or it's a known non-virtual directory).
103  if (NamedDirEnt.second)
104  return;
105 
106  // Add the virtual directory to the cache.
107  auto UDE = std::make_unique<DirectoryEntry>();
108  UDE->Name = NamedDirEnt.first();
109  NamedDirEnt.second = *UDE.get();
110  VirtualDirectoryEntries.push_back(std::move(UDE));
111 
112  // Recursively add the other ancestors.
113  addAncestorsAsVirtualDirs(DirName);
114 }
115 
117 FileManager::getDirectoryRef(StringRef DirName, bool CacheFailure) {
118  // stat doesn't like trailing separators except for root directory.
119  // At least, on Win32 MSVCRT, stat() cannot strip trailing '/'.
120  // (though it can strip '\\')
121  if (DirName.size() > 1 &&
122  DirName != llvm::sys::path::root_path(DirName) &&
123  llvm::sys::path::is_separator(DirName.back()))
124  DirName = DirName.substr(0, DirName.size()-1);
125 #ifdef _WIN32
126  // Fixing a problem with "clang C:test.c" on Windows.
127  // Stat("C:") does not recognize "C:" as a valid directory
128  std::string DirNameStr;
129  if (DirName.size() > 1 && DirName.back() == ':' &&
130  DirName.equals_lower(llvm::sys::path::root_name(DirName))) {
131  DirNameStr = DirName.str() + '.';
132  DirName = DirNameStr;
133  }
134 #endif
135 
136  ++NumDirLookups;
137 
138  // See if there was already an entry in the map. Note that the map
139  // contains both virtual and real directories.
140  auto SeenDirInsertResult =
141  SeenDirEntries.insert({DirName, std::errc::no_such_file_or_directory});
142  if (!SeenDirInsertResult.second) {
143  if (SeenDirInsertResult.first->second)
144  return DirectoryEntryRef(&*SeenDirInsertResult.first);
145  return llvm::errorCodeToError(SeenDirInsertResult.first->second.getError());
146  }
147 
148  // We've not seen this before. Fill it in.
149  ++NumDirCacheMisses;
150  auto &NamedDirEnt = *SeenDirInsertResult.first;
151  assert(!NamedDirEnt.second && "should be newly-created");
152 
153  // Get the null-terminated directory name as stored as the key of the
154  // SeenDirEntries map.
155  StringRef InterndDirName = NamedDirEnt.first();
156 
157  // Check to see if the directory exists.
158  llvm::vfs::Status Status;
159  auto statError = getStatValue(InterndDirName, Status, false,
160  nullptr /*directory lookup*/);
161  if (statError) {
162  // There's no real directory at the given path.
163  if (CacheFailure)
164  NamedDirEnt.second = statError;
165  else
166  SeenDirEntries.erase(DirName);
167  return llvm::errorCodeToError(statError);
168  }
169 
170  // It exists. See if we have already opened a directory with the
171  // same inode (this occurs on Unix-like systems when one dir is
172  // symlinked to another, for example) or the same path (on
173  // Windows).
174  DirectoryEntry &UDE = UniqueRealDirs[Status.getUniqueID()];
175 
176  NamedDirEnt.second = UDE;
177  if (UDE.getName().empty()) {
178  // We don't have this directory yet, add it. We use the string
179  // key from the SeenDirEntries map as the string.
180  UDE.Name = InterndDirName;
181  }
182 
183  return DirectoryEntryRef(&NamedDirEnt);
184 }
185 
186 llvm::ErrorOr<const DirectoryEntry *>
187 FileManager::getDirectory(StringRef DirName, bool CacheFailure) {
188  auto Result = getDirectoryRef(DirName, CacheFailure);
189  if (Result)
190  return &Result->getDirEntry();
191  return llvm::errorToErrorCode(Result.takeError());
192 }
193 
194 llvm::ErrorOr<const FileEntry *>
195 FileManager::getFile(StringRef Filename, bool openFile, bool CacheFailure) {
196  auto Result = getFileRef(Filename, openFile, CacheFailure);
197  if (Result)
198  return &Result->getFileEntry();
199  return llvm::errorToErrorCode(Result.takeError());
200 }
201 
203 FileManager::getFileRef(StringRef Filename, bool openFile, bool CacheFailure) {
204  ++NumFileLookups;
205 
206  // See if there is already an entry in the map.
207  auto SeenFileInsertResult =
208  SeenFileEntries.insert({Filename, std::errc::no_such_file_or_directory});
209  if (!SeenFileInsertResult.second) {
210  if (!SeenFileInsertResult.first->second)
211  return llvm::errorCodeToError(
212  SeenFileInsertResult.first->second.getError());
213  // Construct and return and FileEntryRef, unless it's a redirect to another
214  // filename.
215  SeenFileEntryOrRedirect Value = *SeenFileInsertResult.first->second;
216  FileEntry *FE;
217  if (LLVM_LIKELY(FE = Value.dyn_cast<FileEntry *>()))
218  return FileEntryRef(SeenFileInsertResult.first->first(), *FE);
219  return getFileRef(*Value.get<const StringRef *>(), openFile, CacheFailure);
220  }
221 
222  // We've not seen this before. Fill it in.
223  ++NumFileCacheMisses;
224  auto &NamedFileEnt = *SeenFileInsertResult.first;
225  assert(!NamedFileEnt.second && "should be newly-created");
226 
227  // Get the null-terminated file name as stored as the key of the
228  // SeenFileEntries map.
229  StringRef InterndFileName = NamedFileEnt.first();
230 
231  // Look up the directory for the file. When looking up something like
232  // sys/foo.h we'll discover all of the search directories that have a 'sys'
233  // subdirectory. This will let us avoid having to waste time on known-to-fail
234  // searches when we go to find sys/bar.h, because all the search directories
235  // without a 'sys' subdir will get a cached failure result.
236  auto DirInfoOrErr = getDirectoryFromFile(*this, Filename, CacheFailure);
237  if (!DirInfoOrErr) { // Directory doesn't exist, file can't exist.
238  if (CacheFailure)
239  NamedFileEnt.second = DirInfoOrErr.getError();
240  else
241  SeenFileEntries.erase(Filename);
242 
243  return llvm::errorCodeToError(DirInfoOrErr.getError());
244  }
245  const DirectoryEntry *DirInfo = *DirInfoOrErr;
246 
247  // FIXME: Use the directory info to prune this, before doing the stat syscall.
248  // FIXME: This will reduce the # syscalls.
249 
250  // Check to see if the file exists.
251  std::unique_ptr<llvm::vfs::File> F;
252  llvm::vfs::Status Status;
253  auto statError = getStatValue(InterndFileName, Status, true,
254  openFile ? &F : nullptr);
255  if (statError) {
256  // There's no real file at the given path.
257  if (CacheFailure)
258  NamedFileEnt.second = statError;
259  else
260  SeenFileEntries.erase(Filename);
261 
262  return llvm::errorCodeToError(statError);
263  }
264 
265  assert((openFile || !F) && "undesired open file");
266 
267  // It exists. See if we have already opened a file with the same inode.
268  // This occurs when one dir is symlinked to another, for example.
269  FileEntry &UFE = UniqueRealFiles[Status.getUniqueID()];
270 
271  NamedFileEnt.second = &UFE;
272 
273  // If the name returned by getStatValue is different than Filename, re-intern
274  // the name.
275  if (Status.getName() != Filename) {
276  auto &NewNamedFileEnt =
277  *SeenFileEntries.insert({Status.getName(), &UFE}).first;
278  assert((*NewNamedFileEnt.second).get<FileEntry *>() == &UFE &&
279  "filename from getStatValue() refers to wrong file");
280  InterndFileName = NewNamedFileEnt.first().data();
281  // In addition to re-interning the name, construct a redirecting seen file
282  // entry, that will point to the name the filesystem actually wants to use.
283  StringRef *Redirect = new (CanonicalNameStorage) StringRef(InterndFileName);
284  NamedFileEnt.second = Redirect;
285  }
286 
287  if (UFE.isValid()) { // Already have an entry with this inode, return it.
288 
289  // FIXME: this hack ensures that if we look up a file by a virtual path in
290  // the VFS that the getDir() will have the virtual path, even if we found
291  // the file by a 'real' path first. This is required in order to find a
292  // module's structure when its headers/module map are mapped in the VFS.
293  // We should remove this as soon as we can properly support a file having
294  // multiple names.
295  if (DirInfo != UFE.Dir && Status.IsVFSMapped)
296  UFE.Dir = DirInfo;
297 
298  // Always update the name to use the last name by which a file was accessed.
299  // FIXME: Neither this nor always using the first name is correct; we want
300  // to switch towards a design where we return a FileName object that
301  // encapsulates both the name by which the file was accessed and the
302  // corresponding FileEntry.
303  // FIXME: The Name should be removed from FileEntry once all clients
304  // adopt FileEntryRef.
305  UFE.Name = InterndFileName;
306 
307  return FileEntryRef(InterndFileName, UFE);
308  }
309 
310  // Otherwise, we don't have this file yet, add it.
311  UFE.Name = InterndFileName;
312  UFE.Size = Status.getSize();
313  UFE.ModTime = llvm::sys::toTimeT(Status.getLastModificationTime());
314  UFE.Dir = DirInfo;
315  UFE.UID = NextFileUID++;
316  UFE.UniqueID = Status.getUniqueID();
317  UFE.IsNamedPipe = Status.getType() == llvm::sys::fs::file_type::fifo_file;
318  UFE.File = std::move(F);
319  UFE.IsValid = true;
320 
321  if (UFE.File) {
322  if (auto PathName = UFE.File->getName())
323  fillRealPathName(&UFE, *PathName);
324  } else if (!openFile) {
325  // We should still fill the path even if we aren't opening the file.
326  fillRealPathName(&UFE, InterndFileName);
327  }
328  return FileEntryRef(InterndFileName, UFE);
329 }
330 
331 const FileEntry *
332 FileManager::getVirtualFile(StringRef Filename, off_t Size,
333  time_t ModificationTime) {
334  ++NumFileLookups;
335 
336  // See if there is already an entry in the map for an existing file.
337  auto &NamedFileEnt = *SeenFileEntries.insert(
338  {Filename, std::errc::no_such_file_or_directory}).first;
339  if (NamedFileEnt.second) {
340  SeenFileEntryOrRedirect Value = *NamedFileEnt.second;
341  FileEntry *FE;
342  if (LLVM_LIKELY(FE = Value.dyn_cast<FileEntry *>()))
343  return FE;
344  return getVirtualFile(*Value.get<const StringRef *>(), Size,
345  ModificationTime);
346  }
347 
348  // We've not seen this before, or the file is cached as non-existent.
349  ++NumFileCacheMisses;
350  addAncestorsAsVirtualDirs(Filename);
351  FileEntry *UFE = nullptr;
352 
353  // Now that all ancestors of Filename are in the cache, the
354  // following call is guaranteed to find the DirectoryEntry from the
355  // cache.
356  auto DirInfo = getDirectoryFromFile(*this, Filename, /*CacheFailure=*/true);
357  assert(DirInfo &&
358  "The directory of a virtual file should already be in the cache.");
359 
360  // Check to see if the file exists. If so, drop the virtual file
361  llvm::vfs::Status Status;
362  const char *InterndFileName = NamedFileEnt.first().data();
363  if (!getStatValue(InterndFileName, Status, true, nullptr)) {
364  UFE = &UniqueRealFiles[Status.getUniqueID()];
365  Status = llvm::vfs::Status(
366  Status.getName(), Status.getUniqueID(),
367  llvm::sys::toTimePoint(ModificationTime),
368  Status.getUser(), Status.getGroup(), Size,
369  Status.getType(), Status.getPermissions());
370 
371  NamedFileEnt.second = UFE;
372 
373  // If we had already opened this file, close it now so we don't
374  // leak the descriptor. We're not going to use the file
375  // descriptor anyway, since this is a virtual file.
376  if (UFE->File)
377  UFE->closeFile();
378 
379  // If we already have an entry with this inode, return it.
380  if (UFE->isValid())
381  return UFE;
382 
383  UFE->UniqueID = Status.getUniqueID();
384  UFE->IsNamedPipe = Status.getType() == llvm::sys::fs::file_type::fifo_file;
385  fillRealPathName(UFE, Status.getName());
386  } else {
387  VirtualFileEntries.push_back(std::make_unique<FileEntry>());
388  UFE = VirtualFileEntries.back().get();
389  NamedFileEnt.second = UFE;
390  }
391 
392  UFE->Name = InterndFileName;
393  UFE->Size = Size;
394  UFE->ModTime = ModificationTime;
395  UFE->Dir = *DirInfo;
396  UFE->UID = NextFileUID++;
397  UFE->IsValid = true;
398  UFE->File.reset();
399  return UFE;
400 }
401 
403  // Stat of the file and return nullptr if it doesn't exist.
404  llvm::vfs::Status Status;
405  if (getStatValue(VF.getName(), Status, /*isFile=*/true, /*F=*/nullptr))
406  return None;
407 
408  // Fill it in from the stat.
409  BypassFileEntries.push_back(std::make_unique<FileEntry>());
410  const FileEntry &VFE = VF.getFileEntry();
411  FileEntry &BFE = *BypassFileEntries.back();
412  BFE.Name = VFE.getName();
413  BFE.Size = Status.getSize();
414  BFE.Dir = VFE.Dir;
415  BFE.ModTime = llvm::sys::toTimeT(Status.getLastModificationTime());
416  BFE.UID = NextFileUID++;
417  BFE.IsValid = true;
418  return FileEntryRef(VF.getName(), BFE);
419 }
420 
422  StringRef pathRef(path.data(), path.size());
423 
424  if (FileSystemOpts.WorkingDir.empty()
425  || llvm::sys::path::is_absolute(pathRef))
426  return false;
427 
428  SmallString<128> NewPath(FileSystemOpts.WorkingDir);
429  llvm::sys::path::append(NewPath, pathRef);
430  path = NewPath;
431  return true;
432 }
433 
435  bool Changed = FixupRelativePath(Path);
436 
437  if (!llvm::sys::path::is_absolute(StringRef(Path.data(), Path.size()))) {
438  FS->makeAbsolute(Path);
439  Changed = true;
440  }
441 
442  return Changed;
443 }
444 
445 void FileManager::fillRealPathName(FileEntry *UFE, llvm::StringRef FileName) {
446  llvm::SmallString<128> AbsPath(FileName);
447  // This is not the same as `VFS::getRealPath()`, which resolves symlinks
448  // but can be very expensive on real file systems.
449  // FIXME: the semantic of RealPathName is unclear, and the name might be
450  // misleading. We need to clean up the interface here.
451  makeAbsolutePath(AbsPath);
452  llvm::sys::path::remove_dots(AbsPath, /*remove_dot_dot=*/true);
453  UFE->RealPathName = AbsPath.str();
454 }
455 
456 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
457 FileManager::getBufferForFile(const FileEntry *Entry, bool isVolatile) {
458  uint64_t FileSize = Entry->getSize();
459  // If there's a high enough chance that the file have changed since we
460  // got its size, force a stat before opening it.
461  if (isVolatile)
462  FileSize = -1;
463 
464  StringRef Filename = Entry->getName();
465  // If the file is already open, use the open file descriptor.
466  if (Entry->File) {
467  auto Result =
468  Entry->File->getBuffer(Filename, FileSize,
469  /*RequiresNullTerminator=*/true, isVolatile);
470  Entry->closeFile();
471  return Result;
472  }
473 
474  // Otherwise, open the file.
475  return getBufferForFileImpl(Filename, FileSize, isVolatile);
476 }
477 
478 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
479 FileManager::getBufferForFileImpl(StringRef Filename, int64_t FileSize,
480  bool isVolatile) {
481  if (FileSystemOpts.WorkingDir.empty())
482  return FS->getBufferForFile(Filename, FileSize,
483  /*RequiresNullTerminator=*/true, isVolatile);
484 
485  SmallString<128> FilePath(Filename);
486  FixupRelativePath(FilePath);
487  return FS->getBufferForFile(FilePath, FileSize,
488  /*RequiresNullTerminator=*/true, isVolatile);
489 }
490 
491 /// getStatValue - Get the 'stat' information for the specified path,
492 /// using the cache to accelerate it if possible. This returns true
493 /// if the path points to a virtual file or does not exist, or returns
494 /// false if it's an existent real file. If FileDescriptor is NULL,
495 /// do directory look-up instead of file look-up.
496 std::error_code
497 FileManager::getStatValue(StringRef Path, llvm::vfs::Status &Status,
498  bool isFile, std::unique_ptr<llvm::vfs::File> *F) {
499  // FIXME: FileSystemOpts shouldn't be passed in here, all paths should be
500  // absolute!
501  if (FileSystemOpts.WorkingDir.empty())
502  return FileSystemStatCache::get(Path, Status, isFile, F,
503  StatCache.get(), *FS);
504 
505  SmallString<128> FilePath(Path);
506  FixupRelativePath(FilePath);
507 
508  return FileSystemStatCache::get(FilePath.c_str(), Status, isFile, F,
509  StatCache.get(), *FS);
510 }
511 
512 std::error_code
514  llvm::vfs::Status &Result) {
515  SmallString<128> FilePath(Path);
516  FixupRelativePath(FilePath);
517 
518  llvm::ErrorOr<llvm::vfs::Status> S = FS->status(FilePath.c_str());
519  if (!S)
520  return S.getError();
521  Result = *S;
522  return std::error_code();
523 }
524 
526  SmallVectorImpl<const FileEntry *> &UIDToFiles) const {
527  UIDToFiles.clear();
528  UIDToFiles.resize(NextFileUID);
529 
530  // Map file entries
531  for (llvm::StringMap<llvm::ErrorOr<SeenFileEntryOrRedirect>,
532  llvm::BumpPtrAllocator>::const_iterator
533  FE = SeenFileEntries.begin(),
534  FEEnd = SeenFileEntries.end();
535  FE != FEEnd; ++FE)
536  if (llvm::ErrorOr<SeenFileEntryOrRedirect> Entry = FE->getValue()) {
537  if (const auto *FE = (*Entry).dyn_cast<FileEntry *>())
538  UIDToFiles[FE->getUID()] = FE;
539  }
540 
541  // Map virtual file entries
542  for (const auto &VFE : VirtualFileEntries)
543  UIDToFiles[VFE->getUID()] = VFE.get();
544 }
545 
547  // FIXME: use llvm::sys::fs::canonical() when it gets implemented
548  llvm::DenseMap<const DirectoryEntry *, llvm::StringRef>::iterator Known
549  = CanonicalDirNames.find(Dir);
550  if (Known != CanonicalDirNames.end())
551  return Known->second;
552 
553  StringRef CanonicalName(Dir->getName());
554 
555  SmallString<4096> CanonicalNameBuf;
556  if (!FS->getRealPath(Dir->getName(), CanonicalNameBuf))
557  CanonicalName = StringRef(CanonicalNameBuf).copy(CanonicalNameStorage);
558 
559  CanonicalDirNames.insert({Dir, CanonicalName});
560  return CanonicalName;
561 }
562 
564  llvm::errs() << "\n*** File Manager Stats:\n";
565  llvm::errs() << UniqueRealFiles.size() << " real files found, "
566  << UniqueRealDirs.size() << " real dirs found.\n";
567  llvm::errs() << VirtualFileEntries.size() << " virtual files found, "
568  << VirtualDirectoryEntries.size() << " virtual dirs found.\n";
569  llvm::errs() << NumDirLookups << " dir lookups, "
570  << NumDirCacheMisses << " dir cache misses.\n";
571  llvm::errs() << NumFileLookups << " file lookups, "
572  << NumFileCacheMisses << " file cache misses.\n";
573 
574  //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups;
575 }
ALWAYS_ENABLED_STATISTIC(NumDirLookups, "Number of directory lookups.")
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:171
Defines the clang::FileManager interface and associated types.
void GetUniqueIDMapping(SmallVectorImpl< const FileEntry *> &UIDToFiles) const
Produce an array mapping from the unique IDs assigned to each file to the corresponding FileEntry poi...
void closeFile() const
Definition: FileManager.h:119
Defines the FileSystemStatCache interface.
bool makeAbsolutePath(SmallVectorImpl< char > &Path) const
Makes Path absolute taking into account FileSystemOptions and the working directory option...
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager&#39;s...
Definition: FileManager.h:130
const StringRef getName() const
Definition: FileManager.h:136
FileManager(const FileSystemOptions &FileSystemOpts, IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS=nullptr)
Construct a file manager, optionally with a custom VFS.
Definition: FileManager.cpp:51
Definition: Format.h:2392
llvm::ErrorOr< const DirectoryEntry * > getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
llvm::Expected< DirectoryEntryRef > getDirectoryRef(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
StringRef Filename
Definition: Format.cpp:1807
bool FixupRelativePath(SmallVectorImpl< char > &path) const
If path is not absolute and FileSystemOptions set the working directory, the path is modified to be r...
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
static llvm::ErrorOr< const DirectoryEntry * > getDirectoryFromFile(FileManager &FileMgr, StringRef Filename, bool CacheFailure)
Retrieve the directory that the given file name resides in.
Definition: FileManager.cpp:73
The result type of a method or function.
StringRef getName() const
Definition: FileManager.h:102
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:78
std::error_code getNoncachedStatValue(StringRef Path, llvm::vfs::Status &Result)
Get the &#39;stat&#39; information for the given Path.
void PrintStats() const
const FileEntry * getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime)
Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...
StringRef getCanonicalName(const DirectoryEntry *Dir)
Retrieve the canonical name for a given directory.
bool isValid() const
Definition: FileManager.h:104
Dataflow Directional Tag Classes.
void clearStatCache()
Removes the FileSystemStatCache object from the manager.
Definition: FileManager.cpp:68
off_t getSize() const
Definition: FileManager.h:105
A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the Fil...
Definition: FileManager.h:57
llvm::ErrorOr< const FileEntry * > getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:45
void setStatCache(std::unique_ptr< FileSystemStatCache > statCache)
Installs the provided FileSystemStatCache object within the FileManager.
Definition: FileManager.cpp:63
Keeps track of options that affect how file operations are performed.
llvm::Optional< FileEntryRef > getBypassFile(FileEntryRef VFE)
Retrieve a FileEntry that bypasses VFE, which is expected to be a virtual file entry, to access the real file.
static std::error_code get(StringRef Path, llvm::vfs::Status &Status, bool isFile, std::unique_ptr< llvm::vfs::File > *F, FileSystemStatCache *Cache, llvm::vfs::FileSystem &FS)
Get the &#39;stat&#39; information for the specified path, using the cache to accelerate it if possible...
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
StringRef getName() const
Definition: FileManager.h:52
const FileEntry & getFileEntry() const
Definition: FileManager.h:140
llvm::Expected< FileEntryRef > getFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).