LLVM  14.0.0git
VirtualFileSystem.h
Go to the documentation of this file.
1 //===- VirtualFileSystem.h - Virtual File System Layer ----------*- C++ -*-===//
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 /// \file
10 /// Defines the virtual file system interface vfs::FileSystem.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_SUPPORT_VIRTUALFILESYSTEM_H
15 #define LLVM_SUPPORT_VIRTUALFILESYSTEM_H
16 
18 #include "llvm/ADT/None.h"
19 #include "llvm/ADT/Optional.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/Support/Chrono.h"
23 #include "llvm/Support/ErrorOr.h"
25 #include "llvm/Support/Path.h"
26 #include "llvm/Support/SourceMgr.h"
27 #include <cassert>
28 #include <cstdint>
29 #include <ctime>
30 #include <memory>
31 #include <stack>
32 #include <string>
33 #include <system_error>
34 #include <utility>
35 #include <vector>
36 
37 namespace llvm {
38 
39 class MemoryBuffer;
40 class MemoryBufferRef;
41 class Twine;
42 
43 namespace vfs {
44 
45 /// The result of a \p status operation.
46 class Status {
47  std::string Name;
50  uint32_t User;
51  uint32_t Group;
52  uint64_t Size;
55 
56 public:
57  // FIXME: remove when files support multiple names
58  bool IsVFSMapped = false;
59 
60  Status() = default;
62  Status(const Twine &Name, llvm::sys::fs::UniqueID UID,
65  llvm::sys::fs::perms Perms);
66 
67  /// Get a copy of a Status with a different name.
68  static Status copyWithNewName(const Status &In, const Twine &NewName);
70  const Twine &NewName);
71 
72  /// Returns the name that should be used for this file or directory.
73  StringRef getName() const { return Name; }
74 
75  /// @name Status interface from llvm::sys::fs
76  /// @{
78  llvm::sys::fs::perms getPermissions() const { return Perms; }
80  llvm::sys::fs::UniqueID getUniqueID() const { return UID; }
81  uint32_t getUser() const { return User; }
82  uint32_t getGroup() const { return Group; }
83  uint64_t getSize() const { return Size; }
84  /// @}
85  /// @name Status queries
86  /// These are static queries in llvm::sys::fs.
87  /// @{
88  bool equivalent(const Status &Other) const;
89  bool isDirectory() const;
90  bool isRegularFile() const;
91  bool isOther() const;
92  bool isSymlink() const;
93  bool isStatusKnown() const;
94  bool exists() const;
95  /// @}
96 };
97 
98 /// Represents an open file.
99 class File {
100 public:
101  /// Destroy the file after closing it (if open).
102  /// Sub-classes should generally call close() inside their destructors. We
103  /// cannot do that from the base class, since close is virtual.
104  virtual ~File();
105 
106  /// Get the status of the file.
107  virtual llvm::ErrorOr<Status> status() = 0;
108 
109  /// Get the name of the file
111  if (auto Status = status())
112  return Status->getName().str();
113  else
114  return Status.getError();
115  }
116 
117  /// Get the contents of the file as a \p MemoryBuffer.
119  getBuffer(const Twine &Name, int64_t FileSize = -1,
120  bool RequiresNullTerminator = true, bool IsVolatile = false) = 0;
121 
122  /// Closes the file.
123  virtual std::error_code close() = 0;
124 };
125 
126 /// A member of a directory, yielded by a directory_iterator.
127 /// Only information available on most platforms is included.
129  std::string Path;
131 
132 public:
133  directory_entry() = default;
135  : Path(std::move(Path)), Type(Type) {}
136 
137  llvm::StringRef path() const { return Path; }
138  llvm::sys::fs::file_type type() const { return Type; }
139 };
140 
141 namespace detail {
142 
143 /// An interface for virtual file systems to provide an iterator over the
144 /// (non-recursive) contents of a directory.
145 struct DirIterImpl {
146  virtual ~DirIterImpl();
147 
148  /// Sets \c CurrentEntry to the next entry in the directory on success,
149  /// to directory_entry() at end, or returns a system-defined \c error_code.
150  virtual std::error_code increment() = 0;
151 
153 };
154 
155 } // namespace detail
156 
157 /// An input iterator over the entries in a virtual path, similar to
158 /// llvm::sys::fs::directory_iterator.
160  std::shared_ptr<detail::DirIterImpl> Impl; // Input iterator semantics on copy
161 
162 public:
163  directory_iterator(std::shared_ptr<detail::DirIterImpl> I)
164  : Impl(std::move(I)) {
165  assert(Impl.get() != nullptr && "requires non-null implementation");
166  if (Impl->CurrentEntry.path().empty())
167  Impl.reset(); // Normalize the end iterator to Impl == nullptr.
168  }
169 
170  /// Construct an 'end' iterator.
171  directory_iterator() = default;
172 
173  /// Equivalent to operator++, with an error code.
174  directory_iterator &increment(std::error_code &EC) {
175  assert(Impl && "attempting to increment past end");
176  EC = Impl->increment();
177  if (Impl->CurrentEntry.path().empty())
178  Impl.reset(); // Normalize the end iterator to Impl == nullptr.
179  return *this;
180  }
181 
182  const directory_entry &operator*() const { return Impl->CurrentEntry; }
183  const directory_entry *operator->() const { return &Impl->CurrentEntry; }
184 
185  bool operator==(const directory_iterator &RHS) const {
186  if (Impl && RHS.Impl)
187  return Impl->CurrentEntry.path() == RHS.Impl->CurrentEntry.path();
188  return !Impl && !RHS.Impl;
189  }
190  bool operator!=(const directory_iterator &RHS) const {
191  return !(*this == RHS);
192  }
193 };
194 
195 class FileSystem;
196 
197 namespace detail {
198 
199 /// Keeps state for the recursive_directory_iterator.
201  std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
202  bool HasNoPushRequest = false;
203 };
204 
205 } // end namespace detail
206 
207 /// An input iterator over the recursive contents of a virtual path,
208 /// similar to llvm::sys::fs::recursive_directory_iterator.
210  FileSystem *FS;
211  std::shared_ptr<detail::RecDirIterState>
212  State; // Input iterator semantics on copy.
213 
214 public:
216  std::error_code &EC);
217 
218  /// Construct an 'end' iterator.
219  recursive_directory_iterator() = default;
220 
221  /// Equivalent to operator++, with an error code.
222  recursive_directory_iterator &increment(std::error_code &EC);
223 
224  const directory_entry &operator*() const { return *State->Stack.top(); }
225  const directory_entry *operator->() const { return &*State->Stack.top(); }
226 
227  bool operator==(const recursive_directory_iterator &Other) const {
228  return State == Other.State; // identity
229  }
230  bool operator!=(const recursive_directory_iterator &RHS) const {
231  return !(*this == RHS);
232  }
233 
234  /// Gets the current level. Starting path is at level 0.
235  int level() const {
236  assert(!State->Stack.empty() &&
237  "Cannot get level without any iteration state");
238  return State->Stack.size() - 1;
239  }
240 
241  void no_push() { State->HasNoPushRequest = true; }
242 };
243 
244 /// The virtual file system interface.
245 class FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> {
246 public:
247  virtual ~FileSystem();
248 
249  /// Get the status of the entry at \p Path, if one exists.
250  virtual llvm::ErrorOr<Status> status(const Twine &Path) = 0;
251 
252  /// Get a \p File object for the file at \p Path, if one exists.
254  openFileForRead(const Twine &Path) = 0;
255 
256  /// This is a convenience method that opens a file, gets its content and then
257  /// closes the file.
259  getBufferForFile(const Twine &Name, int64_t FileSize = -1,
260  bool RequiresNullTerminator = true, bool IsVolatile = false);
261 
262  /// Get a directory_iterator for \p Dir.
263  /// \note The 'end' iterator is directory_iterator().
264  virtual directory_iterator dir_begin(const Twine &Dir,
265  std::error_code &EC) = 0;
266 
267  /// Set the working directory. This will affect all following operations on
268  /// this file system and may propagate down for nested file systems.
269  virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) = 0;
270 
271  /// Get the working directory of this file system.
273 
274  /// Gets real path of \p Path e.g. collapse all . and .. patterns, resolve
275  /// symlinks. For real file system, this uses `llvm::sys::fs::real_path`.
276  /// This returns errc::operation_not_permitted if not implemented by subclass.
277  virtual std::error_code getRealPath(const Twine &Path,
278  SmallVectorImpl<char> &Output) const;
279 
280  /// Check whether a file exists. Provided for convenience.
281  bool exists(const Twine &Path);
282 
283  /// Is the file mounted on a local filesystem?
284  virtual std::error_code isLocal(const Twine &Path, bool &Result);
285 
286  /// Make \a Path an absolute path.
287  ///
288  /// Makes \a Path absolute using the current directory if it is not already.
289  /// An empty \a Path will result in the current directory.
290  ///
291  /// /absolute/path => /absolute/path
292  /// relative/../path => <current-directory>/relative/../path
293  ///
294  /// \param Path A path that is modified to be an absolute path.
295  /// \returns success if \a path has been made absolute, otherwise a
296  /// platform-specific error_code.
297  virtual std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const;
298 };
299 
300 /// Gets an \p vfs::FileSystem for the 'real' file system, as seen by
301 /// the operating system.
302 /// The working directory is linked to the process's working directory.
303 /// (This is usually thread-hostile).
305 
306 /// Create an \p vfs::FileSystem for the 'real' file system, as seen by
307 /// the operating system.
308 /// It has its own working directory, independent of (but initially equal to)
309 /// that of the process.
310 std::unique_ptr<FileSystem> createPhysicalFileSystem();
311 
312 /// A file system that allows overlaying one \p AbstractFileSystem on top
313 /// of another.
314 ///
315 /// Consists of a stack of >=1 \p FileSystem objects, which are treated as being
316 /// one merged file system. When there is a directory that exists in more than
317 /// one file system, the \p OverlayFileSystem contains a directory containing
318 /// the union of their contents. The attributes (permissions, etc.) of the
319 /// top-most (most recently added) directory are used. When there is a file
320 /// that exists in more than one file system, the file in the top-most file
321 /// system overrides the other(s).
324 
325  /// The stack of file systems, implemented as a list in order of
326  /// their addition.
327  FileSystemList FSList;
328 
329 public:
331 
332  /// Pushes a file system on top of the stack.
334 
335  llvm::ErrorOr<Status> status(const Twine &Path) override;
337  openFileForRead(const Twine &Path) override;
338  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
340  std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
341  std::error_code isLocal(const Twine &Path, bool &Result) override;
342  std::error_code getRealPath(const Twine &Path,
343  SmallVectorImpl<char> &Output) const override;
344 
345  using iterator = FileSystemList::reverse_iterator;
346  using const_iterator = FileSystemList::const_reverse_iterator;
349 
350  /// Get an iterator pointing to the most recently added file system.
351  iterator overlays_begin() { return FSList.rbegin(); }
352  const_iterator overlays_begin() const { return FSList.rbegin(); }
353 
354  /// Get an iterator pointing one-past the least recently added file system.
355  iterator overlays_end() { return FSList.rend(); }
356  const_iterator overlays_end() const { return FSList.rend(); }
357 
358  /// Get an iterator pointing to the least recently added file system.
359  reverse_iterator overlays_rbegin() { return FSList.begin(); }
360  const_reverse_iterator overlays_rbegin() const { return FSList.begin(); }
361 
362  /// Get an iterator pointing one-past the most recently added file system.
363  reverse_iterator overlays_rend() { return FSList.end(); }
364  const_reverse_iterator overlays_rend() const { return FSList.end(); }
365 };
366 
367 /// By default, this delegates all calls to the underlying file system. This
368 /// is useful when derived file systems want to override some calls and still
369 /// proxy other calls.
370 class ProxyFileSystem : public FileSystem {
371 public:
373  : FS(std::move(FS)) {}
374 
375  llvm::ErrorOr<Status> status(const Twine &Path) override {
376  return FS->status(Path);
377  }
379  openFileForRead(const Twine &Path) override {
380  return FS->openFileForRead(Path);
381  }
382  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override {
383  return FS->dir_begin(Dir, EC);
384  }
386  return FS->getCurrentWorkingDirectory();
387  }
388  std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
389  return FS->setCurrentWorkingDirectory(Path);
390  }
391  std::error_code getRealPath(const Twine &Path,
392  SmallVectorImpl<char> &Output) const override {
393  return FS->getRealPath(Path, Output);
394  }
395  std::error_code isLocal(const Twine &Path, bool &Result) override {
396  return FS->isLocal(Path, Result);
397  }
398 
399 protected:
400  FileSystem &getUnderlyingFS() { return *FS; }
401 
402 private:
404 
405  virtual void anchor();
406 };
407 
408 namespace detail {
409 
410 class InMemoryDirectory;
411 class InMemoryFile;
412 
413 } // namespace detail
414 
415 /// An in-memory file system.
417  std::unique_ptr<detail::InMemoryDirectory> Root;
418  std::string WorkingDirectory;
419  bool UseNormalizedPaths = true;
420 
421  /// If HardLinkTarget is non-null, a hardlink is created to the To path which
422  /// must be a file. If it is null then it adds the file as the public addFile.
423  bool addFile(const Twine &Path, time_t ModificationTime,
424  std::unique_ptr<llvm::MemoryBuffer> Buffer,
428  const detail::InMemoryFile *HardLinkTarget);
429 
430 public:
431  explicit InMemoryFileSystem(bool UseNormalizedPaths = true);
432  ~InMemoryFileSystem() override;
433 
434  /// Add a file containing a buffer or a directory to the VFS with a
435  /// path. The VFS owns the buffer. If present, User, Group, Type
436  /// and Perms apply to the newly-created file or directory.
437  /// \return true if the file or directory was successfully added,
438  /// false if the file or directory already exists in the file system with
439  /// different contents.
440  bool addFile(const Twine &Path, time_t ModificationTime,
441  std::unique_ptr<llvm::MemoryBuffer> Buffer,
445 
446  /// Add a hard link to a file.
447  /// Here hard links are not intended to be fully equivalent to the classical
448  /// filesystem. Both the hard link and the file share the same buffer and
449  /// status (and thus have the same UniqueID). Because of this there is no way
450  /// to distinguish between the link and the file after the link has been
451  /// added.
452  ///
453  /// The To path must be an existing file or a hardlink. The From file must not
454  /// have been added before. The To Path must not be a directory. The From Node
455  /// is added as a hard link which points to the resolved file of To Node.
456  /// \return true if the above condition is satisfied and hardlink was
457  /// successfully created, false otherwise.
458  bool addHardLink(const Twine &From, const Twine &To);
459 
460  /// Add a buffer to the VFS with a path. The VFS does not own the buffer.
461  /// If present, User, Group, Type and Perms apply to the newly-created file
462  /// or directory.
463  /// \return true if the file or directory was successfully added,
464  /// false if the file or directory already exists in the file system with
465  /// different contents.
466  bool addFileNoOwn(const Twine &Path, time_t ModificationTime,
467  const llvm::MemoryBufferRef &Buffer,
469  Optional<uint32_t> Group = None,
472 
473  std::string toString() const;
474 
475  /// Return true if this file system normalizes . and .. in paths.
476  bool useNormalizedPaths() const { return UseNormalizedPaths; }
477 
478  llvm::ErrorOr<Status> status(const Twine &Path) override;
480  openFileForRead(const Twine &Path) override;
481  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
482 
484  return WorkingDirectory;
485  }
486  /// Canonicalizes \p Path by combining with the current working
487  /// directory and normalizing the path (e.g. remove dots). If the current
488  /// working directory is not set, this returns errc::operation_not_permitted.
489  ///
490  /// This doesn't resolve symlinks as they are not supported in in-memory file
491  /// system.
492  std::error_code getRealPath(const Twine &Path,
493  SmallVectorImpl<char> &Output) const override;
494  std::error_code isLocal(const Twine &Path, bool &Result) override;
495  std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
496 };
497 
498 /// Get a globally unique ID for a virtual file or directory.
500 
501 /// Gets a \p FileSystem for a virtual file system described in YAML
502 /// format.
503 std::unique_ptr<FileSystem>
504 getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer,
506  StringRef YAMLFilePath, void *DiagContext = nullptr,
508 
509 struct YAMLVFSEntry {
510  template <typename T1, typename T2>
511  YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory = false)
512  : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)),
514  std::string VPath;
515  std::string RPath;
516  bool IsDirectory = false;
517 };
518 
521 
522 /// A virtual file system parsed from a YAML file.
523 ///
524 /// Currently, this class allows creating virtual files and directories. Virtual
525 /// files map to existing external files in \c ExternalFS, and virtual
526 /// directories may either map to existing directories in \c ExternalFS or list
527 /// their contents in the form of other virtual directories and/or files.
528 ///
529 /// The basic structure of the parsed file is:
530 /// \verbatim
531 /// {
532 /// 'version': <version number>,
533 /// <optional configuration>
534 /// 'roots': [
535 /// <directory entries>
536 /// ]
537 /// }
538 /// \endverbatim
539 ///
540 /// All configuration options are optional.
541 /// 'case-sensitive': <boolean, default=(true for Posix, false for Windows)>
542 /// 'use-external-names': <boolean, default=true>
543 /// 'overlay-relative': <boolean, default=false>
544 /// 'fallthrough': <boolean, default=true>
545 ///
546 /// Virtual directories that list their contents are represented as
547 /// \verbatim
548 /// {
549 /// 'type': 'directory',
550 /// 'name': <string>,
551 /// 'contents': [ <file or directory entries> ]
552 /// }
553 /// \endverbatim
554 ///
555 /// The default attributes for such virtual directories are:
556 /// \verbatim
557 /// MTime = now() when created
558 /// Perms = 0777
559 /// User = Group = 0
560 /// Size = 0
561 /// UniqueID = unspecified unique value
562 /// \endverbatim
563 ///
564 /// When a path prefix matches such a directory, the next component in the path
565 /// is matched against the entries in the 'contents' array.
566 ///
567 /// Re-mapped directories, on the other hand, are represented as
568 /// /// \verbatim
569 /// {
570 /// 'type': 'directory-remap',
571 /// 'name': <string>,
572 /// 'use-external-name': <boolean>, # Optional
573 /// 'external-contents': <path to external directory>
574 /// }
575 /// \endverbatim
576 ///
577 /// and inherit their attributes from the external directory. When a path
578 /// prefix matches such an entry, the unmatched components are appended to the
579 /// 'external-contents' path, and the resulting path is looked up in the
580 /// external file system instead.
581 ///
582 /// Re-mapped files are represented as
583 /// \verbatim
584 /// {
585 /// 'type': 'file',
586 /// 'name': <string>,
587 /// 'use-external-name': <boolean>, # Optional
588 /// 'external-contents': <path to external file>
589 /// }
590 /// \endverbatim
591 ///
592 /// Their attributes and file contents are determined by looking up the file at
593 /// their 'external-contents' path in the external file system.
594 ///
595 /// For 'file', 'directory' and 'directory-remap' entries the 'name' field may
596 /// contain multiple path components (e.g. /path/to/file). However, any
597 /// directory in such a path that contains more than one child must be uniquely
598 /// represented by a 'directory' entry.
599 ///
600 /// When the 'use-external-name' field is set, calls to \a vfs::File::status()
601 /// give the external (remapped) filesystem name instead of the name the file
602 /// was accessed by. This is an intentional leak through the \a
603 /// RedirectingFileSystem abstraction layer. It enables clients to discover
604 /// (and use) the external file location when communicating with users or tools
605 /// that don't use the same VFS overlay.
606 ///
607 /// FIXME: 'use-external-name' causes behaviour that's inconsistent with how
608 /// "real" filesystems behave. Maybe there should be a separate channel for
609 /// this information.
611 public:
614 
615  /// A single file or directory in the VFS.
616  class Entry {
617  EntryKind Kind;
618  std::string Name;
619 
620  public:
621  Entry(EntryKind K, StringRef Name) : Kind(K), Name(Name) {}
622  virtual ~Entry() = default;
623 
624  StringRef getName() const { return Name; }
625  EntryKind getKind() const { return Kind; }
626  };
627 
628  /// A directory in the vfs with explicitly specified contents.
629  class DirectoryEntry : public Entry {
630  std::vector<std::unique_ptr<Entry>> Contents;
631  Status S;
632 
633  public:
634  /// Constructs a directory entry with explicitly specified contents.
635  DirectoryEntry(StringRef Name, std::vector<std::unique_ptr<Entry>> Contents,
636  Status S)
637  : Entry(EK_Directory, Name), Contents(std::move(Contents)),
638  S(std::move(S)) {}
639 
640  /// Constructs an empty directory entry.
642  : Entry(EK_Directory, Name), S(std::move(S)) {}
643 
644  Status getStatus() { return S; }
645 
646  void addContent(std::unique_ptr<Entry> Content) {
647  Contents.push_back(std::move(Content));
648  }
649 
650  Entry *getLastContent() const { return Contents.back().get(); }
651 
652  using iterator = decltype(Contents)::iterator;
653 
654  iterator contents_begin() { return Contents.begin(); }
655  iterator contents_end() { return Contents.end(); }
656 
657  static bool classof(const Entry *E) { return E->getKind() == EK_Directory; }
658  };
659 
660  /// A file or directory in the vfs that is mapped to a file or directory in
661  /// the external filesystem.
662  class RemapEntry : public Entry {
663  std::string ExternalContentsPath;
664  NameKind UseName;
665 
666  protected:
667  RemapEntry(EntryKind K, StringRef Name, StringRef ExternalContentsPath,
668  NameKind UseName)
669  : Entry(K, Name), ExternalContentsPath(ExternalContentsPath),
670  UseName(UseName) {}
671 
672  public:
673  StringRef getExternalContentsPath() const { return ExternalContentsPath; }
674 
675  /// Whether to use the external path as the name for this file or directory.
676  bool useExternalName(bool GlobalUseExternalName) const {
677  return UseName == NK_NotSet ? GlobalUseExternalName
678  : (UseName == NK_External);
679  }
680 
681  NameKind getUseName() const { return UseName; }
682 
683  static bool classof(const Entry *E) {
684  switch (E->getKind()) {
685  case EK_DirectoryRemap:
687  case EK_File:
688  return true;
689  case EK_Directory:
690  return false;
691  }
692  llvm_unreachable("invalid entry kind");
693  }
694  };
695 
696  /// A directory in the vfs that maps to a directory in the external file
697  /// system.
699  public:
700  DirectoryRemapEntry(StringRef Name, StringRef ExternalContentsPath,
701  NameKind UseName)
702  : RemapEntry(EK_DirectoryRemap, Name, ExternalContentsPath, UseName) {}
703 
704  static bool classof(const Entry *E) {
705  return E->getKind() == EK_DirectoryRemap;
706  }
707  };
708 
709  /// A file in the vfs that maps to a file in the external file system.
710  class FileEntry : public RemapEntry {
711  public:
712  FileEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
713  : RemapEntry(EK_File, Name, ExternalContentsPath, UseName) {}
714 
715  static bool classof(const Entry *E) { return E->getKind() == EK_File; }
716  };
717 
718  /// Represents the result of a path lookup into the RedirectingFileSystem.
719  struct LookupResult {
720  /// The entry the looked-up path corresponds to.
722 
723  private:
724  /// When the found Entry is a DirectoryRemapEntry, stores the path in the
725  /// external file system that the looked-up path in the virtual file system
726  // corresponds to.
727  Optional<std::string> ExternalRedirect;
728 
729  public:
732 
733  /// If the found Entry maps the the input path to a path in the external
734  /// file system (i.e. it is a FileEntry or DirectoryRemapEntry), returns
735  /// that path.
737  if (isa<DirectoryRemapEntry>(E))
738  return StringRef(*ExternalRedirect);
739  if (auto *FE = dyn_cast<FileEntry>(E))
740  return FE->getExternalContentsPath();
741  return None;
742  }
743  };
744 
745 private:
748 
749  bool shouldUseExternalFS() const { return IsFallthrough; }
750 
751  /// Canonicalize path by removing ".", "..", "./", components. This is
752  /// a VFS request, do not bother about symlinks in the path components
753  /// but canonicalize in order to perform the correct entry search.
754  std::error_code makeCanonical(SmallVectorImpl<char> &Path) const;
755 
756  /// Whether to fall back to the external file system when an operation fails
757  /// with the given error code on a path associated with the provided Entry.
758  bool shouldFallBackToExternalFS(std::error_code EC, Entry *E = nullptr) const;
759 
760  // In a RedirectingFileSystem, keys can be specified in Posix or Windows
761  // style (or even a mixture of both), so this comparison helper allows
762  // slashes (representing a root) to match backslashes (and vice versa). Note
763  // that, other than the root, path components should not contain slashes or
764  // backslashes.
765  bool pathComponentMatches(llvm::StringRef lhs, llvm::StringRef rhs) const {
766  if ((CaseSensitive ? lhs.equals(rhs) : lhs.equals_insensitive(rhs)))
767  return true;
768  return (lhs == "/" && rhs == "\\") || (lhs == "\\" && rhs == "/");
769  }
770 
771  /// The root(s) of the virtual file system.
772  std::vector<std::unique_ptr<Entry>> Roots;
773 
774  /// The current working directory of the file system.
775  std::string WorkingDirectory;
776 
777  /// The file system to use for external references.
779 
780  /// If IsRelativeOverlay is set, this represents the directory
781  /// path that should be prefixed to each 'external-contents' entry
782  /// when reading from YAML files.
783  std::string ExternalContentsPrefixDir;
784 
785  /// @name Configuration
786  /// @{
787 
788  /// Whether to perform case-sensitive comparisons.
789  ///
790  /// Currently, case-insensitive matching only works correctly with ASCII.
791  bool CaseSensitive =
792 #ifdef _WIN32
793  false;
794 #else
795  true;
796 #endif
797 
798  /// IsRelativeOverlay marks whether a ExternalContentsPrefixDir path must
799  /// be prefixed in every 'external-contents' when reading from YAML files.
800  bool IsRelativeOverlay = false;
801 
802  /// Whether to use to use the value of 'external-contents' for the
803  /// names of files. This global value is overridable on a per-file basis.
804  bool UseExternalNames = true;
805 
806  /// Whether to attempt a file lookup in external file system after it wasn't
807  /// found in VFS.
808  bool IsFallthrough = true;
809  /// @}
810 
811  RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> ExternalFS);
812 
813  /// Looks up the path <tt>[Start, End)</tt> in \p From, possibly recursing
814  /// into the contents of \p From if it is a directory. Returns a LookupResult
815  /// giving the matched entry and, if that entry is a FileEntry or
816  /// DirectoryRemapEntry, the path it redirects to in the external file system.
819  Entry *From) const;
820 
821  /// Get the status for a path with the provided \c LookupResult.
822  ErrorOr<Status> status(const Twine &Path, const LookupResult &Result);
823 
824 public:
825  /// Looks up \p Path in \c Roots and returns a LookupResult giving the
826  /// matched entry and, if the entry was a FileEntry or DirectoryRemapEntry,
827  /// the path it redirects to in the external file system.
829 
830  /// Parses \p Buffer, which is expected to be in YAML format and
831  /// returns a virtual file system representing its contents.
832  static std::unique_ptr<RedirectingFileSystem>
833  create(std::unique_ptr<MemoryBuffer> Buffer,
835  void *DiagContext, IntrusiveRefCntPtr<FileSystem> ExternalFS);
836 
837  /// Redirect each of the remapped files from first to second.
838  static std::unique_ptr<RedirectingFileSystem>
839  create(ArrayRef<std::pair<std::string, std::string>> RemappedFiles,
840  bool UseExternalNames, FileSystem &ExternalFS);
841 
842  ErrorOr<Status> status(const Twine &Path) override;
843  ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
844 
845  std::error_code getRealPath(const Twine &Path,
846  SmallVectorImpl<char> &Output) const override;
847 
849 
850  std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
851 
852  std::error_code isLocal(const Twine &Path, bool &Result) override;
853 
854  std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const override;
855 
856  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
857 
858  void setExternalContentsPrefixDir(StringRef PrefixDir);
859 
861 
862  void setFallthrough(bool Fallthrough);
863 
864  std::vector<llvm::StringRef> getRoots() const;
865 
866  void dump(raw_ostream &OS) const;
867  void dumpEntry(raw_ostream &OS, Entry *E, int NumSpaces = 0) const;
868 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
869  LLVM_DUMP_METHOD void dump() const;
870 #endif
871 };
872 
873 /// Collect all pairs of <virtual path, real path> entries from the
874 /// \p YAMLFilePath. This is used by the module dependency collector to forward
875 /// the entries into the reproducer output VFS YAML file.
876 void collectVFSFromYAML(
877  std::unique_ptr<llvm::MemoryBuffer> Buffer,
878  llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath,
879  SmallVectorImpl<YAMLVFSEntry> &CollectedEntries,
880  void *DiagContext = nullptr,
881  IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
882 
884  std::vector<YAMLVFSEntry> Mappings;
885  Optional<bool> IsCaseSensitive;
886  Optional<bool> IsOverlayRelative;
887  Optional<bool> UseExternalNames;
888  std::string OverlayDir;
889 
890  void addEntry(StringRef VirtualPath, StringRef RealPath, bool IsDirectory);
891 
892 public:
893  YAMLVFSWriter() = default;
894 
895  void addFileMapping(StringRef VirtualPath, StringRef RealPath);
896  void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath);
897 
898  void setCaseSensitivity(bool CaseSensitive) {
899  IsCaseSensitive = CaseSensitive;
900  }
901 
902  void setUseExternalNames(bool UseExtNames) { UseExternalNames = UseExtNames; }
903 
904  void setOverlayDir(StringRef OverlayDirectory) {
905  IsOverlayRelative = true;
906  OverlayDir.assign(OverlayDirectory.str());
907  }
908 
909  const std::vector<YAMLVFSEntry> &getMappings() const { return Mappings; }
910 
911  void write(llvm::raw_ostream &OS);
912 };
913 
914 } // namespace vfs
915 } // namespace llvm
916 
917 #endif // LLVM_SUPPORT_VIRTUALFILESYSTEM_H
llvm::vfs::File::getBuffer
virtual llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBuffer(const Twine &Name, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)=0
Get the contents of the file as a MemoryBuffer.
llvm::vfs::RedirectingFileSystem::EK_File
@ EK_File
Definition: VirtualFileSystem.h:612
llvm::vfs::RedirectingFSDirIterImpl
Directory iterator implementation for RedirectingFileSystem's directory entries.
Definition: VirtualFileSystem.cpp:1051
llvm::vfs::InMemoryFileSystem::setCurrentWorkingDirectory
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
Definition: VirtualFileSystem.cpp:970
llvm::vfs::FileSystem::dir_begin
virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC)=0
Get a directory_iterator for Dir.
LLVM_DUMP_METHOD
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:491
llvm::vfs::Status::isRegularFile
bool isRegularFile() const
Definition: VirtualFileSystem.cpp:96
llvm::vfs::RedirectingFileSystem::setCurrentWorkingDirectory
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
Definition: VirtualFileSystem.cpp:1139
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::vfs::RedirectingFileSystem::DirectoryEntry::getLastContent
Entry * getLastContent() const
Definition: VirtualFileSystem.h:650
llvm::vfs::RedirectingFileSystem::getCurrentWorkingDirectory
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
Definition: VirtualFileSystem.cpp:1134
llvm::vfs::RedirectingFileSystem::RemapEntry::getUseName
NameKind getUseName() const
Definition: VirtualFileSystem.h:681
Optional.h
llvm::vfs::YAMLVFSWriter::YAMLVFSWriter
YAMLVFSWriter()=default
llvm::vfs::detail::DirIterImpl::CurrentEntry
directory_entry CurrentEntry
Definition: VirtualFileSystem.h:152
FileSystem.h
llvm::vfs::RedirectingFileSystem::RemapEntry::useExternalName
bool useExternalName(bool GlobalUseExternalName) const
Whether to use the external path as the name for this file or directory.
Definition: VirtualFileSystem.h:676
llvm::vfs::RedirectingFileSystem::DirectoryRemapEntry::classof
static bool classof(const Entry *E)
Definition: VirtualFileSystem.h:704
llvm::vfs::ProxyFileSystem::dir_begin
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
Definition: VirtualFileSystem.h:382
llvm::vfs::createPhysicalFileSystem
std::unique_ptr< FileSystem > createPhysicalFileSystem()
Create an vfs::FileSystem for the 'real' file system, as seen by the operating system.
Definition: VirtualFileSystem.cpp:351
llvm::vfs::InMemoryFileSystem::getCurrentWorkingDirectory
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
Definition: VirtualFileSystem.h:483
llvm::vfs::RedirectingFileSystem::LookupResult::E
Entry * E
The entry the looked-up path corresponds to.
Definition: VirtualFileSystem.h:721
llvm::vfs::RedirectingFileSystem::FileEntry::FileEntry
FileEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
Definition: VirtualFileSystem.h:712
llvm::vfs::InMemoryFileSystem::dir_begin
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
Definition: VirtualFileSystem.cpp:954
StringRef.h
llvm::vfs::recursive_directory_iterator::recursive_directory_iterator
recursive_directory_iterator()=default
Construct an 'end' iterator.
llvm::vfs::RedirectingFileSystem::DirectoryEntry::contents_begin
iterator contents_begin()
Definition: VirtualFileSystem.h:654
llvm::vfs::RedirectingFileSystem::setFallthrough
void setFallthrough(bool Fallthrough)
Definition: VirtualFileSystem.cpp:1256
llvm::vfs::ProxyFileSystem::getUnderlyingFS
FileSystem & getUnderlyingFS()
Definition: VirtualFileSystem.h:400
llvm::vfs::RedirectingFileSystem::DirectoryRemapEntry
A directory in the vfs that maps to a directory in the external file system.
Definition: VirtualFileSystem.h:698
llvm::vfs::directory_iterator::operator!=
bool operator!=(const directory_iterator &RHS) const
Definition: VirtualFileSystem.h:190
llvm::vfs::ProxyFileSystem::getRealPath
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Gets real path of Path e.g.
Definition: VirtualFileSystem.h:391
llvm::vfs::RedirectingFileSystem::create
static std::unique_ptr< RedirectingFileSystem > create(std::unique_ptr< MemoryBuffer > Buffer, SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, void *DiagContext, IntrusiveRefCntPtr< FileSystem > ExternalFS)
Parses Buffer, which is expected to be in YAML format and returns a virtual file system representing ...
Definition: VirtualFileSystem.cpp:1751
llvm::SmallVector< IntrusiveRefCntPtr< FileSystem >, 1 >
llvm::vfs::Status::IsVFSMapped
bool IsVFSMapped
Definition: VirtualFileSystem.h:58
Path.h
llvm::vfs::InMemoryFileSystem::useNormalizedPaths
bool useNormalizedPaths() const
Return true if this file system normalizes . and .. in paths.
Definition: VirtualFileSystem.h:476
llvm::vfs::RedirectingFileSystem::NK_External
@ NK_External
Definition: VirtualFileSystem.h:613
llvm::vfs::InMemoryFileSystem::InMemoryFileSystem
InMemoryFileSystem(bool UseNormalizedPaths=true)
Definition: VirtualFileSystem.cpp:701
Content
T Content
Definition: ELFObjHandler.cpp:90
llvm::vfs::detail::DirIterImpl
An interface for virtual file systems to provide an iterator over the (non-recursive) contents of a d...
Definition: VirtualFileSystem.h:145
llvm::vfs::YAMLVFSEntry::VPath
std::string VPath
Definition: VirtualFileSystem.h:514
llvm::vfs::detail::DirIterImpl::~DirIterImpl
virtual ~DirIterImpl()
llvm::vfs::InMemoryFileSystem::getRealPath
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Canonicalizes Path by combining with the current working directory and normalizing the path (e....
Definition: VirtualFileSystem.cpp:988
llvm::vfs::RedirectingFileSystem::Entry::getName
StringRef getName() const
Definition: VirtualFileSystem.h:624
llvm::vfs::FileSystem::status
virtual llvm::ErrorOr< Status > status(const Twine &Path)=0
Get the status of the entry at Path, if one exists.
llvm::vfs::FileSystem::setCurrentWorkingDirectory
virtual std::error_code setCurrentWorkingDirectory(const Twine &Path)=0
Set the working directory.
llvm::vfs::RedirectingFileSystem::FileEntry
A file in the vfs that maps to a file in the external file system.
Definition: VirtualFileSystem.h:710
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::vfs::OverlayFileSystem::overlays_rend
reverse_iterator overlays_rend()
Get an iterator pointing one-past the most recently added file system.
Definition: VirtualFileSystem.h:363
llvm::vfs::directory_iterator
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
Definition: VirtualFileSystem.h:159
llvm::vfs::OverlayFileSystem::getCurrentWorkingDirectory
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
Definition: VirtualFileSystem.cpp:422
T1
#define T1
Definition: Mips16ISelLowering.cpp:340
llvm::vfs::OverlayFileSystem::overlays_rbegin
const_reverse_iterator overlays_rbegin() const
Definition: VirtualFileSystem.h:360
llvm::vfs::ProxyFileSystem::isLocal
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
Definition: VirtualFileSystem.h:395
llvm::Optional< uint32_t >
llvm::vfs::Status::getSize
uint64_t getSize() const
Definition: VirtualFileSystem.h:83
llvm::vfs::recursive_directory_iterator::level
int level() const
Gets the current level. Starting path is at level 0.
Definition: VirtualFileSystem.h:235
llvm::vfs::RedirectingFileSystem::EK_Directory
@ EK_Directory
Definition: VirtualFileSystem.h:612
llvm::vfs::Status
The result of a status operation.
Definition: VirtualFileSystem.h:46
IntrusiveRefCntPtr.h
llvm::vfs::RedirectingFileSystem::openFileForRead
ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
Definition: VirtualFileSystem.cpp:2006
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::vfs::OverlayFileSystem::getRealPath
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Gets real path of Path e.g.
Definition: VirtualFileSystem.cpp:443
llvm::vfs::RedirectingFileSystem
A virtual file system parsed from a YAML file.
Definition: VirtualFileSystem.h:610
llvm::vfs::RedirectingFileSystem::Entry::Entry
Entry(EntryKind K, StringRef Name)
Definition: VirtualFileSystem.h:621
llvm::vfs::RedirectingFileSystem::isLocal
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
Definition: VirtualFileSystem.cpp:1152
llvm::vfs::FileSystem::isLocal
virtual std::error_code isLocal(const Twine &Path, bool &Result)
Is the file mounted on a local filesystem?
Definition: VirtualFileSystem.cpp:141
llvm::sys::TimePoint
std::chrono::time_point< std::chrono::system_clock, D > TimePoint
A time point on the system clock.
Definition: Chrono.h:33
llvm::vfs::OverlayFileSystem::overlays_end
iterator overlays_end()
Get an iterator pointing one-past the least recently added file system.
Definition: VirtualFileSystem.h:355
Chrono.h
llvm::vfs::OverlayFileSystem::iterator
FileSystemList::reverse_iterator iterator
Definition: VirtualFileSystem.h:345
Mappings
Inject TLI Mappings
Definition: InjectTLIMappings.cpp:172
llvm::vfs::directory_entry::directory_entry
directory_entry(std::string Path, llvm::sys::fs::file_type Type)
Definition: VirtualFileSystem.h:134
llvm::vfs::Status::getPermissions
llvm::sys::fs::perms getPermissions() const
Definition: VirtualFileSystem.h:78
llvm::vfs::OverlayFileSystem::status
llvm::ErrorOr< Status > status(const Twine &Path) override
Get the status of the entry at Path, if one exists.
Definition: VirtualFileSystem.cpp:400
llvm::vfs::RedirectingFileSystem::getRealPath
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Gets real path of Path e.g.
Definition: VirtualFileSystem.cpp:2045
llvm::orc::tpctypes::LookupResult
std::vector< JITTargetAddress > LookupResult
Definition: TargetProcessControlTypes.h:144
llvm::vfs::Status::copyWithNewName
static Status copyWithNewName(const Status &In, const Twine &NewName)
Get a copy of a Status with a different name.
Definition: VirtualFileSystem.cpp:77
llvm::vfs::recursive_directory_iterator::operator==
bool operator==(const recursive_directory_iterator &Other) const
Definition: VirtualFileSystem.h:227
llvm::vfs::detail::RecDirIterState::HasNoPushRequest
bool HasNoPushRequest
Definition: VirtualFileSystem.h:202
llvm::vfs::YAMLVFSWriter
Definition: VirtualFileSystem.h:883
llvm::vfs::RedirectingFileSystem::RemapEntry::getExternalContentsPath
StringRef getExternalContentsPath() const
Definition: VirtualFileSystem.h:673
llvm::vfs::RedirectingFileSystem::DirectoryEntry::DirectoryEntry
DirectoryEntry(StringRef Name, std::vector< std::unique_ptr< Entry >> Contents, Status S)
Constructs a directory entry with explicitly specified contents.
Definition: VirtualFileSystem.h:635
llvm::vfs::FileSystem::getBufferForFile
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const Twine &Name, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
This is a convenience method that opens a file, gets its content and then closes the file.
Definition: VirtualFileSystem.cpp:115
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::User
Definition: User.h:44
llvm::vfs::collectVFSFromYAML
void collectVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, SmallVectorImpl< YAMLVFSEntry > &CollectedEntries, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())
Collect all pairs of <virtual path, real path> entries from the YAMLFilePath.
llvm::vfs::directory_iterator::increment
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
Definition: VirtualFileSystem.h:174
llvm::sys::fs::file_type::status_error
@ status_error
llvm::vfs::OverlayFileSystem::overlays_begin
iterator overlays_begin()
Get an iterator pointing to the most recently added file system.
Definition: VirtualFileSystem.h:351
llvm::vfs::FileSystem::openFileForRead
virtual llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path)=0
Get a File object for the file at Path, if one exists.
llvm::vfs::detail::DirIterImpl::increment
virtual std::error_code increment()=0
Sets CurrentEntry to the next entry in the directory on success, to directory_entry() at end,...
llvm::vfs::RedirectingFileSystem::LookupResult::getExternalRedirect
Optional< StringRef > getExternalRedirect() const
If the found Entry maps the the input path to a path in the external file system (i....
Definition: VirtualFileSystem.h:736
llvm::vfs::ProxyFileSystem::setCurrentWorkingDirectory
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
Definition: VirtualFileSystem.h:388
llvm::vfs::InMemoryFileSystem::~InMemoryFileSystem
~InMemoryFileSystem() override
llvm::vfs::OverlayFileSystem::overlays_rend
const_reverse_iterator overlays_rend() const
Definition: VirtualFileSystem.h:364
llvm::ThreadSafeRefCountedBase
A thread-safe version of RefCountedBase.
Definition: IntrusiveRefCntPtr.h:101
llvm::vfs::RedirectingFileSystem::DirectoryEntry::addContent
void addContent(std::unique_ptr< Entry > Content)
Definition: VirtualFileSystem.h:646
llvm::vfs::directory_entry::path
llvm::StringRef path() const
Definition: VirtualFileSystem.h:137
llvm::vfs::RedirectingFileSystem::Entry::getKind
EntryKind getKind() const
Definition: VirtualFileSystem.h:625
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::vfs::OverlayFileSystem::overlays_rbegin
reverse_iterator overlays_rbegin()
Get an iterator pointing to the least recently added file system.
Definition: VirtualFileSystem.h:359
llvm::vfs::RedirectingFileSystem::RemapEntry::RemapEntry
RemapEntry(EntryKind K, StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
Definition: VirtualFileSystem.h:667
llvm::vfs::FileSystem::exists
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
Definition: VirtualFileSystem.cpp:145
llvm::vfs::getVFSFromYAML
std::unique_ptr< FileSystem > getVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())
Gets a FileSystem for a virtual file system described in YAML format.
llvm::sys::fs::file_type
file_type
An enumeration for the file system's view of the type.
Definition: FileSystem.h:66
llvm::vfs::RedirectingFileSystem::DirectoryEntry::iterator
decltype(Contents)::iterator iterator
Definition: VirtualFileSystem.h:652
llvm::vfs::directory_entry
A member of a directory, yielded by a directory_iterator.
Definition: VirtualFileSystem.h:128
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:245
llvm::None
const NoneType None
Definition: None.h:23
llvm::vfs::RedirectingFileSystem::RemapEntry::classof
static bool classof(const Entry *E)
Definition: VirtualFileSystem.h:683
SourceMgr.h
llvm::StringRef::equals
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:187
llvm::vfs::recursive_directory_iterator::no_push
void no_push()
Definition: VirtualFileSystem.h:241
llvm::vfs::RedirectingFileSystem::getExternalContentsPrefixDir
StringRef getExternalContentsPrefixDir() const
Definition: VirtualFileSystem.cpp:1252
llvm::vfs::File::getName
virtual llvm::ErrorOr< std::string > getName()
Get the name of the file.
Definition: VirtualFileSystem.h:110
llvm::vfs::YAMLVFSEntry::IsDirectory
bool IsDirectory
Definition: VirtualFileSystem.h:516
llvm::vfs::Status::isOther
bool isOther() const
Definition: VirtualFileSystem.cpp:98
llvm::tgtok::In
@ In
Definition: TGLexer.h:51
llvm::sys::fs::file_type::type_unknown
@ type_unknown
llvm::vfs::RedirectingFileSystem::EntryKind
EntryKind
Definition: VirtualFileSystem.h:612
llvm::sys::fs::UniqueID
Definition: UniqueID.h:23
llvm::sys::fs::file_status
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:226
llvm::vfs::Status::getName
StringRef getName() const
Returns the name that should be used for this file or directory.
Definition: VirtualFileSystem.h:73
llvm::vfs::getRealFileSystem
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
Definition: VirtualFileSystem.cpp:346
llvm::vfs::FileSystem::getCurrentWorkingDirectory
virtual llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const =0
Get the working directory of this file system.
llvm::vfs::Status::getUser
uint32_t getUser() const
Definition: VirtualFileSystem.h:81
llvm::StringRef::equals_insensitive
LLVM_NODISCARD bool equals_insensitive(StringRef RHS) const
Check for string equality, ignoring case.
Definition: StringRef.h:194
llvm::vfs::YAMLVFSEntry
Definition: VirtualFileSystem.h:509
llvm::vfs::ProxyFileSystem::status
llvm::ErrorOr< Status > status(const Twine &Path) override
Get the status of the entry at Path, if one exists.
Definition: VirtualFileSystem.h:375
llvm::vfs::recursive_directory_iterator::increment
recursive_directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
Definition: VirtualFileSystem.cpp:2348
llvm::vfs::OverlayFileSystem::const_reverse_iterator
FileSystemList::const_iterator const_reverse_iterator
Definition: VirtualFileSystem.h:348
llvm::vfs::RedirectingFileSystem::NameKind
NameKind
Definition: VirtualFileSystem.h:613
uint64_t
llvm::vfs::RedirectingFileSystem::RemapEntry
A file or directory in the vfs that is mapped to a file or directory in the external filesystem.
Definition: VirtualFileSystem.h:662
llvm::vfs::RedirectingFileSystem::DirectoryEntry::DirectoryEntry
DirectoryEntry(StringRef Name, Status S)
Constructs an empty directory entry.
Definition: VirtualFileSystem.h:641
llvm::vfs::detail::InMemoryFile
Definition: VirtualFileSystem.cpp:569
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::vfs::Status::isDirectory
bool isDirectory() const
Definition: VirtualFileSystem.cpp:94
llvm::vfs::RedirectingFileSystem::DirectoryEntry::contents_end
iterator contents_end()
Definition: VirtualFileSystem.h:655
llvm::vfs::InMemoryFileSystem::toString
std::string toString() const
Definition: VirtualFileSystem.cpp:710
ErrorOr.h
llvm::SourceMgr::DiagHandlerTy
void(*)(const SMDiagnostic &, void *Context) DiagHandlerTy
Clients that want to handle their own diagnostics in a custom way can register a function pointer+con...
Definition: SourceMgr.h:43
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::vfs::RedirectingFileSystem::dir_begin
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
Definition: VirtualFileSystem.cpp:1192
llvm::SmallVectorImpl< IntrusiveRefCntPtr< FileSystem > >::const_iterator
typename SuperClass::const_iterator const_iterator
Definition: SmallVector.h:563
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::vfs::RedirectingFileSystem::setExternalContentsPrefixDir
void setExternalContentsPrefixDir(StringRef PrefixDir)
Definition: VirtualFileSystem.cpp:1248
llvm::vfs::YAMLVFSEntry::YAMLVFSEntry
YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory=false)
Definition: VirtualFileSystem.h:511
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1605
llvm::vfs::ProxyFileSystem::openFileForRead
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
Definition: VirtualFileSystem.h:379
llvm::X86AS::FS
@ FS
Definition: X86.h:188
llvm::vfs::OverlayFileSystem::overlays_end
const_iterator overlays_end() const
Definition: VirtualFileSystem.h:356
llvm::vfs::RedirectingFileSystemParser
A helper class to hold the common YAML parsing state.
Definition: VirtualFileSystem.cpp:1296
llvm::vfs::InMemoryFileSystem::status
llvm::ErrorOr< Status > status(const Twine &Path) override
Get the status of the entry at Path, if one exists.
Definition: VirtualFileSystem.cpp:882
llvm::vfs::directory_iterator::directory_iterator
directory_iterator()=default
Construct an 'end' iterator.
llvm::vfs::getNextVirtualUniqueID
llvm::sys::fs::UniqueID getNextVirtualUniqueID()
Get a globally unique ID for a virtual file or directory.
Definition: VirtualFileSystem.cpp:2142
llvm::vfs::YAMLVFSWriter::setCaseSensitivity
void setCaseSensitivity(bool CaseSensitive)
Definition: VirtualFileSystem.h:898
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
None.h
DiagHandler
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:1095
llvm::vfs::RedirectingFileSystem::getRoots
std::vector< llvm::StringRef > getRoots() const
Definition: VirtualFileSystem.cpp:1260
llvm::vfs::RedirectingFileSystem::DirectoryEntry
A directory in the vfs with explicitly specified contents.
Definition: VirtualFileSystem.h:629
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
uint32_t
llvm::vfs::RedirectingFileSystem::dump
LLVM_DUMP_METHOD void dump() const
Definition: VirtualFileSystem.cpp:1292
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::vfs::Status::getUniqueID
llvm::sys::fs::UniqueID getUniqueID() const
Definition: VirtualFileSystem.h:80
llvm::vfs::OverlayFileSystem
A file system that allows overlaying one AbstractFileSystem on top of another.
Definition: VirtualFileSystem.h:322
llvm::AMDGPU::HSAMD::Kernel::Arg::Key::IsVolatile
constexpr char IsVolatile[]
Key for Kernel::Arg::Metadata::mIsVolatile.
Definition: AMDGPUMetadata.h:194
llvm::vfs::YAMLVFSWriter::write
void write(llvm::raw_ostream &OS)
Definition: VirtualFileSystem.cpp:2328
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:273
llvm::vfs::InMemoryFileSystem::addHardLink
bool addHardLink(const Twine &From, const Twine &To)
Add a hard link to a file.
Definition: VirtualFileSystem.cpp:870
llvm::sys::path::const_iterator
Path iterator.
Definition: Path.h:52
llvm::vfs::File
Represents an open file.
Definition: VirtualFileSystem.h:99
llvm::vfs::directory_entry::type
llvm::sys::fs::file_type type() const
Definition: VirtualFileSystem.h:138
llvm::vfs::recursive_directory_iterator::operator!=
bool operator!=(const recursive_directory_iterator &RHS) const
Definition: VirtualFileSystem.h:230
llvm::vfs::YAMLVFSWriter::setOverlayDir
void setOverlayDir(StringRef OverlayDirectory)
Definition: VirtualFileSystem.h:904
llvm::vfs::directory_iterator::directory_iterator
directory_iterator(std::shared_ptr< detail::DirIterImpl > I)
Definition: VirtualFileSystem.h:163
llvm::vfs::Status::isSymlink
bool isSymlink() const
Definition: VirtualFileSystem.cpp:102
llvm::vfs::InMemoryFileSystem::addFileNoOwn
bool addFileNoOwn(const Twine &Path, time_t ModificationTime, const llvm::MemoryBufferRef &Buffer, Optional< uint32_t > User=None, Optional< uint32_t > Group=None, Optional< llvm::sys::fs::file_type > Type=None, Optional< llvm::sys::fs::perms > Perms=None)
Add a buffer to the VFS with a path.
Definition: VirtualFileSystem.cpp:815
llvm::vfs::RedirectingFileSystem::DirectoryEntry::classof
static bool classof(const Entry *E)
Definition: VirtualFileSystem.h:657
llvm::vfs::RedirectingFileSystem::dumpEntry
void dumpEntry(raw_ostream &OS, Entry *E, int NumSpaces=0) const
Definition: VirtualFileSystem.cpp:1272
llvm::vfs::recursive_directory_iterator
An input iterator over the recursive contents of a virtual path, similar to llvm::sys::fs::recursive_...
Definition: VirtualFileSystem.h:209
llvm::vfs::OverlayFileSystem::reverse_iterator
FileSystemList::iterator reverse_iterator
Definition: VirtualFileSystem.h:347
llvm::vfs::YAMLVFSWriter::setUseExternalNames
void setUseExternalNames(bool UseExtNames)
Definition: VirtualFileSystem.h:902
llvm::vfs::File::close
virtual std::error_code close()=0
Closes the file.
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::vfs::RedirectingFileSystem::DirectoryRemapEntry::DirectoryRemapEntry
DirectoryRemapEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
Definition: VirtualFileSystem.h:700
llvm::vfs::OverlayFileSystem::const_iterator
FileSystemList::const_reverse_iterator const_iterator
Definition: VirtualFileSystem.h:346
llvm::vfs::RedirectingFileSystem::EK_DirectoryRemap
@ EK_DirectoryRemap
Definition: VirtualFileSystem.h:612
llvm::vfs::FileSystem
The virtual file system interface.
Definition: VirtualFileSystem.h:245
llvm::vfs::OverlayFileSystem::overlays_begin
const_iterator overlays_begin() const
Definition: VirtualFileSystem.h:352
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
llvm::vfs::RedirectingFileSystem::DirectoryEntry::getStatus
Status getStatus()
Definition: VirtualFileSystem.h:644
llvm::vfs::InMemoryFileSystem
An in-memory file system.
Definition: VirtualFileSystem.h:416
llvm::vfs::directory_iterator::operator->
const directory_entry * operator->() const
Definition: VirtualFileSystem.h:183
llvm::vfs::RedirectingFileSystem::LookupResult::LookupResult
LookupResult(Entry *E, sys::path::const_iterator Start, sys::path::const_iterator End)
Definition: VirtualFileSystem.cpp:1846
llvm::vfs::directory_entry::directory_entry
directory_entry()=default
llvm::vfs::ProxyFileSystem::getCurrentWorkingDirectory
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
Definition: VirtualFileSystem.h:385
llvm::vfs::recursive_directory_iterator::operator->
const directory_entry * operator->() const
Definition: VirtualFileSystem.h:225
llvm::vfs::RedirectingFileSystem::lookupPath
ErrorOr< LookupResult > lookupPath(StringRef Path) const
Looks up Path in Roots and returns a LookupResult giving the matched entry and, if the entry was a Fi...
Definition: VirtualFileSystem.cpp:1883
llvm::vfs::OverlayFileSystem::dir_begin
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
Definition: VirtualFileSystem.cpp:536
llvm::vfs::RedirectingFileSystem::NK_Virtual
@ NK_Virtual
Definition: VirtualFileSystem.h:613
llvm::vfs::directory_iterator::operator*
const directory_entry & operator*() const
Definition: VirtualFileSystem.h:182
llvm::vfs::RedirectingFileSystem::NK_NotSet
@ NK_NotSet
Definition: VirtualFileSystem.h:613
llvm::vfs::File::status
virtual llvm::ErrorOr< Status > status()=0
Get the status of the file.
llvm::vfs::YAMLVFSWriter::addFileMapping
void addFileMapping(StringRef VirtualPath, StringRef RealPath)
Definition: VirtualFileSystem.cpp:2158
llvm::vfs::detail::RecDirIterState::Stack
std::stack< directory_iterator, std::vector< directory_iterator > > Stack
Definition: VirtualFileSystem.h:201
llvm::vfs::OverlayFileSystem::setCurrentWorkingDirectory
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
Definition: VirtualFileSystem.cpp:428
llvm::vfs::ProxyFileSystem
By default, this delegates all calls to the underlying file system.
Definition: VirtualFileSystem.h:370
llvm::vfs::Status::exists
bool exists() const
Definition: VirtualFileSystem.cpp:106
llvm::vfs::InMemoryFileSystem::isLocal
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
Definition: VirtualFileSystem.cpp:1000
llvm::vfs::File::~File
virtual ~File()
Destroy the file after closing it (if open).
llvm::vfs::OverlayFileSystem::pushOverlay
void pushOverlay(IntrusiveRefCntPtr< FileSystem > FS)
Pushes a file system on top of the stack.
Definition: VirtualFileSystem.cpp:393
llvm::vfs::Status::getLastModificationTime
llvm::sys::TimePoint getLastModificationTime() const
Definition: VirtualFileSystem.h:79
llvm::vfs::OverlayFileSystem::openFileForRead
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
Definition: VirtualFileSystem.cpp:411
llvm::sys::fs::perms
perms
Definition: FileSystem.h:86
SmallVector.h
llvm::vfs::YAMLVFSWriter::getMappings
const std::vector< YAMLVFSEntry > & getMappings() const
Definition: VirtualFileSystem.h:909
llvm::vfs::RedirectingFileSystem::FileEntry::classof
static bool classof(const Entry *E)
Definition: VirtualFileSystem.h:715
llvm::vfs::YAMLVFSEntry::RPath
std::string RPath
Definition: VirtualFileSystem.h:515
llvm::SmallVectorImpl< IntrusiveRefCntPtr< FileSystem > >::iterator
typename SuperClass::iterator iterator
Definition: SmallVector.h:562
llvm::sys::fs::status
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::vfs::RedirectingFileSystem::LookupResult
Represents the result of a path lookup into the RedirectingFileSystem.
Definition: VirtualFileSystem.h:719
llvm::vfs::YAMLVFSWriter::addDirectoryMapping
void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath)
Definition: VirtualFileSystem.cpp:2162
llvm::vfs::Status::getType
llvm::sys::fs::file_type getType() const
Definition: VirtualFileSystem.h:77
llvm::vfs::detail::RecDirIterState
Keeps state for the recursive_directory_iterator.
Definition: VirtualFileSystem.h:200
llvm::vfs::directory_iterator::operator==
bool operator==(const directory_iterator &RHS) const
Definition: VirtualFileSystem.h:185
llvm::vfs::recursive_directory_iterator::operator*
const directory_entry & operator*() const
Definition: VirtualFileSystem.h:224
llvm::vfs::Status::getGroup
uint32_t getGroup() const
Definition: VirtualFileSystem.h:82
llvm::SmallVectorImpl< char >
llvm::vfs::FileSystem::getRealPath
virtual std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const
Gets real path of Path e.g.
Definition: VirtualFileSystem.cpp:136
llvm::vfs::FileSystem::makeAbsolute
virtual std::error_code makeAbsolute(SmallVectorImpl< char > &Path) const
Make Path an absolute path.
Definition: VirtualFileSystem.cpp:124
llvm::vfs::ProxyFileSystem::ProxyFileSystem
ProxyFileSystem(IntrusiveRefCntPtr< FileSystem > FS)
Definition: VirtualFileSystem.h:372
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::vfs::RedirectingFileSystem::makeAbsolute
std::error_code makeAbsolute(SmallVectorImpl< char > &Path) const override
Make Path an absolute path.
Definition: VirtualFileSystem.cpp:1163
llvm::vfs::Status::equivalent
bool equivalent(const Status &Other) const
Definition: VirtualFileSystem.cpp:89
llvm::vfs::OverlayFileSystem::isLocal
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
Definition: VirtualFileSystem.cpp:435
llvm::vfs::InMemoryFileSystem::openFileForRead
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
Definition: VirtualFileSystem.cpp:890
llvm::vfs::Status::isStatusKnown
bool isStatusKnown() const
Definition: VirtualFileSystem.cpp:104
llvm::IntrusiveRefCntPtr
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
Definition: IntrusiveRefCntPtr.h:163
llvm::vfs::Status::Status
Status()=default
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1172
llvm::vfs::RedirectingFileSystem::Entry
A single file or directory in the VFS.
Definition: VirtualFileSystem.h:616
llvm::vfs::FileSystem::~FileSystem
virtual ~FileSystem()
llvm::vfs::RedirectingFileSystem::Entry::~Entry
virtual ~Entry()=default
llvm::vfs::OverlayFileSystem::OverlayFileSystem
OverlayFileSystem(IntrusiveRefCntPtr< FileSystem > Base)
Definition: VirtualFileSystem.cpp:389