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