LLVM 19.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
20#include "llvm/ADT/StringRef.h"
21#include "llvm/Support/Chrono.h"
22#include "llvm/Support/Errc.h"
23#include "llvm/Support/Error.h"
27#include "llvm/Support/Path.h"
29#include <cassert>
30#include <cstdint>
31#include <ctime>
32#include <memory>
33#include <optional>
34#include <stack>
35#include <string>
36#include <system_error>
37#include <utility>
38#include <vector>
39
40namespace llvm {
41
42class MemoryBuffer;
43class MemoryBufferRef;
44class Twine;
45
46namespace vfs {
47
48/// The result of a \p status operation.
49class Status {
50 std::string Name;
54 uint32_t Group;
55 uint64_t Size;
58
59public:
60 /// Whether this entity has an external path different from the virtual path,
61 /// and the external path is exposed by leaking it through the abstraction.
62 /// For example, a RedirectingFileSystem will set this for paths where
63 /// UseExternalName is true.
64 ///
65 /// FIXME: Currently the external path is exposed by replacing the virtual
66 /// path in this Status object. Instead, we should leave the path in the
67 /// Status intact (matching the requested virtual path) - see
68 /// FileManager::getFileRef for how we plan to fix this.
70
71 Status() = default;
77
78 /// Get a copy of a Status with a different size.
79 static Status copyWithNewSize(const Status &In, uint64_t NewSize);
80 /// Get a copy of a Status with a different name.
81 static Status copyWithNewName(const Status &In, const Twine &NewName);
83 const Twine &NewName);
84
85 /// Returns the name that should be used for this file or directory.
86 StringRef getName() const { return Name; }
87
88 /// @name Status interface from llvm::sys::fs
89 /// @{
91 llvm::sys::fs::perms getPermissions() const { return Perms; }
93 llvm::sys::fs::UniqueID getUniqueID() const { return UID; }
94 uint32_t getUser() const { return User; }
95 uint32_t getGroup() const { return Group; }
96 uint64_t getSize() const { return Size; }
97 /// @}
98 /// @name Status queries
99 /// These are static queries in llvm::sys::fs.
100 /// @{
101 bool equivalent(const Status &Other) const;
102 bool isDirectory() const;
103 bool isRegularFile() const;
104 bool isOther() const;
105 bool isSymlink() const;
106 bool isStatusKnown() const;
107 bool exists() const;
108 /// @}
109};
110
111/// Represents an open file.
112class File {
113public:
114 /// Destroy the file after closing it (if open).
115 /// Sub-classes should generally call close() inside their destructors. We
116 /// cannot do that from the base class, since close is virtual.
117 virtual ~File();
118
119 /// Get the status of the file.
121
122 /// Get the name of the file
124 if (auto Status = status())
125 return Status->getName().str();
126 else
127 return Status.getError();
128 }
129
130 /// Get the contents of the file as a \p MemoryBuffer.
132 getBuffer(const Twine &Name, int64_t FileSize = -1,
133 bool RequiresNullTerminator = true, bool IsVolatile = false) = 0;
134
135 /// Closes the file.
136 virtual std::error_code close() = 0;
137
138 // Get the same file with a different path.
140 getWithPath(ErrorOr<std::unique_ptr<File>> Result, const Twine &P);
141
142protected:
143 // Set the file's underlying path.
144 virtual void setPath(const Twine &Path) {}
145};
146
147/// A member of a directory, yielded by a directory_iterator.
148/// Only information available on most platforms is included.
150 std::string Path;
152
153public:
154 directory_entry() = default;
156 : Path(std::move(Path)), Type(Type) {}
157
158 llvm::StringRef path() const { return Path; }
160};
161
162namespace detail {
163
164/// An interface for virtual file systems to provide an iterator over the
165/// (non-recursive) contents of a directory.
167 virtual ~DirIterImpl();
168
169 /// Sets \c CurrentEntry to the next entry in the directory on success,
170 /// to directory_entry() at end, or returns a system-defined \c error_code.
171 virtual std::error_code increment() = 0;
172
174};
175
176} // namespace detail
177
178/// An input iterator over the entries in a virtual path, similar to
179/// llvm::sys::fs::directory_iterator.
181 std::shared_ptr<detail::DirIterImpl> Impl; // Input iterator semantics on copy
182
183public:
184 directory_iterator(std::shared_ptr<detail::DirIterImpl> I)
185 : Impl(std::move(I)) {
186 assert(Impl.get() != nullptr && "requires non-null implementation");
187 if (Impl->CurrentEntry.path().empty())
188 Impl.reset(); // Normalize the end iterator to Impl == nullptr.
189 }
190
191 /// Construct an 'end' iterator.
193
194 /// Equivalent to operator++, with an error code.
195 directory_iterator &increment(std::error_code &EC) {
196 assert(Impl && "attempting to increment past end");
197 EC = Impl->increment();
198 if (Impl->CurrentEntry.path().empty())
199 Impl.reset(); // Normalize the end iterator to Impl == nullptr.
200 return *this;
201 }
202
203 const directory_entry &operator*() const { return Impl->CurrentEntry; }
204 const directory_entry *operator->() const { return &Impl->CurrentEntry; }
205
206 bool operator==(const directory_iterator &RHS) const {
207 if (Impl && RHS.Impl)
208 return Impl->CurrentEntry.path() == RHS.Impl->CurrentEntry.path();
209 return !Impl && !RHS.Impl;
210 }
211 bool operator!=(const directory_iterator &RHS) const {
212 return !(*this == RHS);
213 }
214};
215
216class FileSystem;
217
218namespace detail {
219
220/// Keeps state for the recursive_directory_iterator.
222 std::stack<directory_iterator, std::vector<directory_iterator>> Stack;
223 bool HasNoPushRequest = false;
224};
225
226} // end namespace detail
227
228/// An input iterator over the recursive contents of a virtual path,
229/// similar to llvm::sys::fs::recursive_directory_iterator.
231 FileSystem *FS;
232 std::shared_ptr<detail::RecDirIterState>
233 State; // Input iterator semantics on copy.
234
235public:
237 std::error_code &EC);
238
239 /// Construct an 'end' iterator.
241
242 /// Equivalent to operator++, with an error code.
243 recursive_directory_iterator &increment(std::error_code &EC);
244
245 const directory_entry &operator*() const { return *State->Stack.top(); }
246 const directory_entry *operator->() const { return &*State->Stack.top(); }
247
249 return State == Other.State; // identity
250 }
252 return !(*this == RHS);
253 }
254
255 /// Gets the current level. Starting path is at level 0.
256 int level() const {
257 assert(!State->Stack.empty() &&
258 "Cannot get level without any iteration state");
259 return State->Stack.size() - 1;
260 }
261
262 void no_push() { State->HasNoPushRequest = true; }
263};
264
265/// The virtual file system interface.
267 public RTTIExtends<FileSystem, RTTIRoot> {
268public:
269 static const char ID;
270 virtual ~FileSystem();
271
272 /// Get the status of the entry at \p Path, if one exists.
273 virtual llvm::ErrorOr<Status> status(const Twine &Path) = 0;
274
275 /// Get a \p File object for the file at \p Path, if one exists.
277 openFileForRead(const Twine &Path) = 0;
278
279 /// This is a convenience method that opens a file, gets its content and then
280 /// closes the file.
282 getBufferForFile(const Twine &Name, int64_t FileSize = -1,
283 bool RequiresNullTerminator = true, bool IsVolatile = false);
284
285 /// Get a directory_iterator for \p Dir.
286 /// \note The 'end' iterator is directory_iterator().
288 std::error_code &EC) = 0;
289
290 /// Set the working directory. This will affect all following operations on
291 /// this file system and may propagate down for nested file systems.
292 virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) = 0;
293
294 /// Get the working directory of this file system.
296
297 /// Gets real path of \p Path e.g. collapse all . and .. patterns, resolve
298 /// symlinks. For real file system, this uses `llvm::sys::fs::real_path`.
299 /// This returns errc::operation_not_permitted if not implemented by subclass.
300 virtual std::error_code getRealPath(const Twine &Path,
301 SmallVectorImpl<char> &Output) const;
302
303 /// Check whether a file exists. Provided for convenience.
304 bool exists(const Twine &Path);
305
306 /// Is the file mounted on a local filesystem?
307 virtual std::error_code isLocal(const Twine &Path, bool &Result);
308
309 /// Make \a Path an absolute path.
310 ///
311 /// Makes \a Path absolute using the current directory if it is not already.
312 /// An empty \a Path will result in the current directory.
313 ///
314 /// /absolute/path => /absolute/path
315 /// relative/../path => <current-directory>/relative/../path
316 ///
317 /// \param Path A path that is modified to be an absolute path.
318 /// \returns success if \a path has been made absolute, otherwise a
319 /// platform-specific error_code.
320 virtual std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const;
321
324 unsigned IndentLevel = 0) const {
325 printImpl(OS, Type, IndentLevel);
326 }
327
329 virtual void visitChildFileSystems(VisitCallbackTy Callback) {}
330 void visit(VisitCallbackTy Callback) {
331 Callback(*this);
332 visitChildFileSystems(Callback);
333 }
334
335#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
336 LLVM_DUMP_METHOD void dump() const;
337#endif
338
339protected:
341 unsigned IndentLevel) const {
342 printIndent(OS, IndentLevel);
343 OS << "FileSystem\n";
344 }
345
346 void printIndent(raw_ostream &OS, unsigned IndentLevel) const {
347 for (unsigned i = 0; i < IndentLevel; ++i)
348 OS << " ";
349 }
350};
351
352/// Gets an \p vfs::FileSystem for the 'real' file system, as seen by
353/// the operating system.
354/// The working directory is linked to the process's working directory.
355/// (This is usually thread-hostile).
357
358/// Create an \p vfs::FileSystem for the 'real' file system, as seen by
359/// the operating system.
360/// It has its own working directory, independent of (but initially equal to)
361/// that of the process.
362std::unique_ptr<FileSystem> createPhysicalFileSystem();
363
364/// A file system that allows overlaying one \p AbstractFileSystem on top
365/// of another.
366///
367/// Consists of a stack of >=1 \p FileSystem objects, which are treated as being
368/// one merged file system. When there is a directory that exists in more than
369/// one file system, the \p OverlayFileSystem contains a directory containing
370/// the union of their contents. The attributes (permissions, etc.) of the
371/// top-most (most recently added) directory are used. When there is a file
372/// that exists in more than one file system, the file in the top-most file
373/// system overrides the other(s).
374class OverlayFileSystem : public RTTIExtends<OverlayFileSystem, FileSystem> {
376
377 /// The stack of file systems, implemented as a list in order of
378 /// their addition.
379 FileSystemList FSList;
380
381public:
382 static const char ID;
384
385 /// Pushes a file system on top of the stack.
387
388 llvm::ErrorOr<Status> status(const Twine &Path) override;
390 openFileForRead(const Twine &Path) override;
391 directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
393 std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
394 std::error_code isLocal(const Twine &Path, bool &Result) override;
395 std::error_code getRealPath(const Twine &Path,
396 SmallVectorImpl<char> &Output) const override;
397
404
405 /// Get an iterator pointing to the most recently added file system.
406 iterator overlays_begin() { return FSList.rbegin(); }
407 const_iterator overlays_begin() const { return FSList.rbegin(); }
408
409 /// Get an iterator pointing one-past the least recently added file system.
410 iterator overlays_end() { return FSList.rend(); }
411 const_iterator overlays_end() const { return FSList.rend(); }
412
413 /// Get an iterator pointing to the least recently added file system.
415 const_reverse_iterator overlays_rbegin() const { return FSList.begin(); }
416
417 /// Get an iterator pointing one-past the most recently added file system.
418 reverse_iterator overlays_rend() { return FSList.end(); }
419 const_reverse_iterator overlays_rend() const { return FSList.end(); }
420
421 range overlays_range() { return llvm::reverse(FSList); }
422 const_range overlays_range() const { return llvm::reverse(FSList); }
423
424protected:
425 void printImpl(raw_ostream &OS, PrintType Type,
426 unsigned IndentLevel) const override;
427 void visitChildFileSystems(VisitCallbackTy Callback) override;
428};
429
430/// By default, this delegates all calls to the underlying file system. This
431/// is useful when derived file systems want to override some calls and still
432/// proxy other calls.
433class ProxyFileSystem : public RTTIExtends<ProxyFileSystem, FileSystem> {
434public:
435 static const char ID;
437 : FS(std::move(FS)) {}
438
439 llvm::ErrorOr<Status> status(const Twine &Path) override {
440 return FS->status(Path);
441 }
443 openFileForRead(const Twine &Path) override {
444 return FS->openFileForRead(Path);
445 }
446 directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override {
447 return FS->dir_begin(Dir, EC);
448 }
450 return FS->getCurrentWorkingDirectory();
451 }
452 std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
453 return FS->setCurrentWorkingDirectory(Path);
454 }
455 std::error_code getRealPath(const Twine &Path,
456 SmallVectorImpl<char> &Output) const override {
457 return FS->getRealPath(Path, Output);
458 }
459 std::error_code isLocal(const Twine &Path, bool &Result) override {
460 return FS->isLocal(Path, Result);
461 }
462
463protected:
464 FileSystem &getUnderlyingFS() const { return *FS; }
465 void visitChildFileSystems(VisitCallbackTy Callback) override {
466 if (FS) {
467 Callback(*FS);
468 FS->visitChildFileSystems(Callback);
469 }
470 }
471
472private:
474
475 virtual void anchor() override;
476};
477
478namespace detail {
479
480class InMemoryDirectory;
481class InMemoryNode;
482
488 std::unique_ptr<llvm::MemoryBuffer> Buffer;
493
494 Status makeStatus() const;
495};
496
499 Value;
500
501public:
504 : Value(std::make_pair(Name, Node)) {}
505 NamedNodeOrError(std::error_code EC) : Value(EC) {}
507
508 StringRef getName() const { return (*Value).first; }
509 explicit operator bool() const { return static_cast<bool>(Value); }
510 operator std::error_code() const { return Value.getError(); }
511 std::error_code getError() const { return Value.getError(); }
512 const detail::InMemoryNode *operator*() const { return (*Value).second; }
513};
514
515} // namespace detail
516
517/// An in-memory file system.
518class InMemoryFileSystem : public RTTIExtends<InMemoryFileSystem, FileSystem> {
519 std::unique_ptr<detail::InMemoryDirectory> Root;
520 std::string WorkingDirectory;
521 bool UseNormalizedPaths = true;
522
523public:
524 static const char ID;
525
526private:
529
530 /// Create node with \p MakeNode and add it into this filesystem at \p Path.
531 bool addFile(const Twine &Path, time_t ModificationTime,
532 std::unique_ptr<llvm::MemoryBuffer> Buffer,
533 std::optional<uint32_t> User, std::optional<uint32_t> Group,
534 std::optional<llvm::sys::fs::file_type> Type,
535 std::optional<llvm::sys::fs::perms> Perms, MakeNodeFn MakeNode);
536
537 /// Looks up the in-memory node for the path \p P.
538 /// If \p FollowFinalSymlink is true, the returned node is guaranteed to
539 /// not be a symlink and its path may differ from \p P.
540 detail::NamedNodeOrError lookupNode(const Twine &P, bool FollowFinalSymlink,
541 size_t SymlinkDepth = 0) const;
542
543 class DirIterator;
544
545public:
546 explicit InMemoryFileSystem(bool UseNormalizedPaths = true);
548
549 /// Add a file containing a buffer or a directory to the VFS with a
550 /// path. The VFS owns the buffer. If present, User, Group, Type
551 /// and Perms apply to the newly-created file or directory.
552 /// \return true if the file or directory was successfully added,
553 /// false if the file or directory already exists in the file system with
554 /// different contents.
555 bool addFile(const Twine &Path, time_t ModificationTime,
556 std::unique_ptr<llvm::MemoryBuffer> Buffer,
557 std::optional<uint32_t> User = std::nullopt,
558 std::optional<uint32_t> Group = std::nullopt,
559 std::optional<llvm::sys::fs::file_type> Type = std::nullopt,
560 std::optional<llvm::sys::fs::perms> Perms = std::nullopt);
561
562 /// Add a hard link to a file.
563 ///
564 /// Here hard links are not intended to be fully equivalent to the classical
565 /// filesystem. Both the hard link and the file share the same buffer and
566 /// status (and thus have the same UniqueID). Because of this there is no way
567 /// to distinguish between the link and the file after the link has been
568 /// added.
569 ///
570 /// The \p Target path must be an existing file or a hardlink. The
571 /// \p NewLink file must not have been added before. The \p Target
572 /// path must not be a directory. The \p NewLink node is added as a hard
573 /// link which points to the resolved file of \p Target node.
574 /// \return true if the above condition is satisfied and hardlink was
575 /// successfully created, false otherwise.
576 bool addHardLink(const Twine &NewLink, const Twine &Target);
577
578 /// Arbitrary max depth to search through symlinks. We can get into problems
579 /// if a link links to a link that links back to the link, for example.
580 static constexpr size_t MaxSymlinkDepth = 16;
581
582 /// Add a symbolic link. Unlike a HardLink, because \p Target doesn't need
583 /// to refer to a file (or refer to anything, as it happens). Also, an
584 /// in-memory directory for \p Target isn't automatically created.
585 bool
586 addSymbolicLink(const Twine &NewLink, const Twine &Target,
587 time_t ModificationTime,
588 std::optional<uint32_t> User = std::nullopt,
589 std::optional<uint32_t> Group = std::nullopt,
590 std::optional<llvm::sys::fs::perms> Perms = std::nullopt);
591
592 /// Add a buffer to the VFS with a path. The VFS does not own the buffer.
593 /// If present, User, Group, Type and Perms apply to the newly-created file
594 /// or directory.
595 /// \return true if the file or directory was successfully added,
596 /// false if the file or directory already exists in the file system with
597 /// different contents.
598 bool addFileNoOwn(const Twine &Path, time_t ModificationTime,
599 const llvm::MemoryBufferRef &Buffer,
600 std::optional<uint32_t> User = std::nullopt,
601 std::optional<uint32_t> Group = std::nullopt,
602 std::optional<llvm::sys::fs::file_type> Type = std::nullopt,
603 std::optional<llvm::sys::fs::perms> Perms = std::nullopt);
604
605 std::string toString() const;
606
607 /// Return true if this file system normalizes . and .. in paths.
608 bool useNormalizedPaths() const { return UseNormalizedPaths; }
609
610 llvm::ErrorOr<Status> status(const Twine &Path) override;
612 openFileForRead(const Twine &Path) override;
613 directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
614
616 return WorkingDirectory;
617 }
618 /// Canonicalizes \p Path by combining with the current working
619 /// directory and normalizing the path (e.g. remove dots). If the current
620 /// working directory is not set, this returns errc::operation_not_permitted.
621 ///
622 /// This doesn't resolve symlinks as they are not supported in in-memory file
623 /// system.
624 std::error_code getRealPath(const Twine &Path,
625 SmallVectorImpl<char> &Output) const override;
626 std::error_code isLocal(const Twine &Path, bool &Result) override;
627 std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
628
629protected:
630 void printImpl(raw_ostream &OS, PrintType Type,
631 unsigned IndentLevel) const override;
632};
633
634/// Get a globally unique ID for a virtual file or directory.
636
637/// Gets a \p FileSystem for a virtual file system described in YAML
638/// format.
639std::unique_ptr<FileSystem>
640getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer,
642 StringRef YAMLFilePath, void *DiagContext = nullptr,
644
646 template <typename T1, typename T2>
647 YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory = false)
648 : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)),
650 std::string VPath;
651 std::string RPath;
652 bool IsDirectory = false;
653};
654
657
658/// A virtual file system parsed from a YAML file.
659///
660/// Currently, this class allows creating virtual files and directories. Virtual
661/// files map to existing external files in \c ExternalFS, and virtual
662/// directories may either map to existing directories in \c ExternalFS or list
663/// their contents in the form of other virtual directories and/or files.
664///
665/// The basic structure of the parsed file is:
666/// \verbatim
667/// {
668/// 'version': <version number>,
669/// <optional configuration>
670/// 'roots': [
671/// <directory entries>
672/// ]
673/// }
674/// \endverbatim
675/// The roots may be absolute or relative. If relative they will be made
676/// absolute against either current working directory or the directory where
677/// the Overlay YAML file is located, depending on the 'root-relative'
678/// configuration.
679///
680/// All configuration options are optional.
681/// 'case-sensitive': <boolean, default=(true for Posix, false for Windows)>
682/// 'use-external-names': <boolean, default=true>
683/// 'root-relative': <string, one of 'cwd' or 'overlay-dir', default='cwd'>
684/// 'overlay-relative': <boolean, default=false>
685/// 'fallthrough': <boolean, default=true, deprecated - use 'redirecting-with'
686/// instead>
687/// 'redirecting-with': <string, one of 'fallthrough', 'fallback', or
688/// 'redirect-only', default='fallthrough'>
689///
690/// To clarify, 'root-relative' option will prepend the current working
691/// directory, or the overlay directory to the 'roots->name' field only if
692/// 'roots->name' is a relative path. On the other hand, when 'overlay-relative'
693/// is set to 'true', external paths will always be prepended with the overlay
694/// directory, even if external paths are not relative paths. The
695/// 'root-relative' option has no interaction with the 'overlay-relative'
696/// option.
697///
698/// Virtual directories that list their contents are represented as
699/// \verbatim
700/// {
701/// 'type': 'directory',
702/// 'name': <string>,
703/// 'contents': [ <file or directory entries> ]
704/// }
705/// \endverbatim
706/// The default attributes for such virtual directories are:
707/// \verbatim
708/// MTime = now() when created
709/// Perms = 0777
710/// User = Group = 0
711/// Size = 0
712/// UniqueID = unspecified unique value
713/// \endverbatim
714/// When a path prefix matches such a directory, the next component in the path
715/// is matched against the entries in the 'contents' array.
716///
717/// Re-mapped directories, on the other hand, are represented as
718/// /// \verbatim
719/// {
720/// 'type': 'directory-remap',
721/// 'name': <string>,
722/// 'use-external-name': <boolean>, # Optional
723/// 'external-contents': <path to external directory>
724/// }
725/// \endverbatim
726/// and inherit their attributes from the external directory. When a path
727/// prefix matches such an entry, the unmatched components are appended to the
728/// 'external-contents' path, and the resulting path is looked up in the
729/// external file system instead.
730///
731/// Re-mapped files are represented as
732/// \verbatim
733/// {
734/// 'type': 'file',
735/// 'name': <string>,
736/// 'use-external-name': <boolean>, # Optional
737/// 'external-contents': <path to external file>
738/// }
739/// \endverbatim
740/// Their attributes and file contents are determined by looking up the file at
741/// their 'external-contents' path in the external file system.
742///
743/// For 'file', 'directory' and 'directory-remap' entries the 'name' field may
744/// contain multiple path components (e.g. /path/to/file). However, any
745/// directory in such a path that contains more than one child must be uniquely
746/// represented by a 'directory' entry.
747///
748/// When the 'use-external-name' field is set, calls to \a vfs::File::status()
749/// give the external (remapped) filesystem name instead of the name the file
750/// was accessed by. This is an intentional leak through the \a
751/// RedirectingFileSystem abstraction layer. It enables clients to discover
752/// (and use) the external file location when communicating with users or tools
753/// that don't use the same VFS overlay.
754///
755/// FIXME: 'use-external-name' causes behaviour that's inconsistent with how
756/// "real" filesystems behave. Maybe there should be a separate channel for
757/// this information.
759 : public RTTIExtends<RedirectingFileSystem, vfs::FileSystem> {
760public:
761 static const char ID;
764
765 /// The type of redirection to perform.
766 enum class RedirectKind {
767 /// Lookup the redirected path first (ie. the one specified in
768 /// 'external-contents') and if that fails "fallthrough" to a lookup of the
769 /// originally provided path.
771 /// Lookup the provided path first and if that fails, "fallback" to a
772 /// lookup of the redirected path.
773 Fallback,
774 /// Only lookup the redirected path, do not lookup the originally provided
775 /// path.
777 };
778
779 /// The type of relative path used by Roots.
780 enum class RootRelativeKind {
781 /// The roots are relative to the current working directory.
782 CWD,
783 /// The roots are relative to the directory where the Overlay YAML file
784 // locates.
786 };
787
788 /// A single file or directory in the VFS.
789 class Entry {
790 EntryKind Kind;
791 std::string Name;
792
793 public:
794 Entry(EntryKind K, StringRef Name) : Kind(K), Name(Name) {}
795 virtual ~Entry() = default;
796
797 StringRef getName() const { return Name; }
798 EntryKind getKind() const { return Kind; }
799 };
800
801 /// A directory in the vfs with explicitly specified contents.
802 class DirectoryEntry : public Entry {
803 std::vector<std::unique_ptr<Entry>> Contents;
804 Status S;
805
806 public:
807 /// Constructs a directory entry with explicitly specified contents.
808 DirectoryEntry(StringRef Name, std::vector<std::unique_ptr<Entry>> Contents,
809 Status S)
810 : Entry(EK_Directory, Name), Contents(std::move(Contents)),
811 S(std::move(S)) {}
812
813 /// Constructs an empty directory entry.
815 : Entry(EK_Directory, Name), S(std::move(S)) {}
816
817 Status getStatus() { return S; }
818
819 void addContent(std::unique_ptr<Entry> Content) {
820 Contents.push_back(std::move(Content));
821 }
822
823 Entry *getLastContent() const { return Contents.back().get(); }
824
825 using iterator = decltype(Contents)::iterator;
826
827 iterator contents_begin() { return Contents.begin(); }
828 iterator contents_end() { return Contents.end(); }
829
830 static bool classof(const Entry *E) { return E->getKind() == EK_Directory; }
831 };
832
833 /// A file or directory in the vfs that is mapped to a file or directory in
834 /// the external filesystem.
835 class RemapEntry : public Entry {
836 std::string ExternalContentsPath;
837 NameKind UseName;
838
839 protected:
840 RemapEntry(EntryKind K, StringRef Name, StringRef ExternalContentsPath,
841 NameKind UseName)
842 : Entry(K, Name), ExternalContentsPath(ExternalContentsPath),
843 UseName(UseName) {}
844
845 public:
846 StringRef getExternalContentsPath() const { return ExternalContentsPath; }
847
848 /// Whether to use the external path as the name for this file or directory.
849 bool useExternalName(bool GlobalUseExternalName) const {
850 return UseName == NK_NotSet ? GlobalUseExternalName
851 : (UseName == NK_External);
852 }
853
854 NameKind getUseName() const { return UseName; }
855
856 static bool classof(const Entry *E) {
857 switch (E->getKind()) {
859 [[fallthrough]];
860 case EK_File:
861 return true;
862 case EK_Directory:
863 return false;
864 }
865 llvm_unreachable("invalid entry kind");
866 }
867 };
868
869 /// A directory in the vfs that maps to a directory in the external file
870 /// system.
872 public:
873 DirectoryRemapEntry(StringRef Name, StringRef ExternalContentsPath,
874 NameKind UseName)
875 : RemapEntry(EK_DirectoryRemap, Name, ExternalContentsPath, UseName) {}
876
877 static bool classof(const Entry *E) {
878 return E->getKind() == EK_DirectoryRemap;
879 }
880 };
881
882 /// A file in the vfs that maps to a file in the external file system.
883 class FileEntry : public RemapEntry {
884 public:
885 FileEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
886 : RemapEntry(EK_File, Name, ExternalContentsPath, UseName) {}
887
888 static bool classof(const Entry *E) { return E->getKind() == EK_File; }
889 };
890
891 /// Represents the result of a path lookup into the RedirectingFileSystem.
893 /// Chain of parent directory entries for \c E.
895
896 /// The entry the looked-up path corresponds to.
898
899 private:
900 /// When the found Entry is a DirectoryRemapEntry, stores the path in the
901 /// external file system that the looked-up path in the virtual file system
902 // corresponds to.
903 std::optional<std::string> ExternalRedirect;
904
905 public:
908
909 /// If the found Entry maps the input path to a path in the external
910 /// file system (i.e. it is a FileEntry or DirectoryRemapEntry), returns
911 /// that path.
912 std::optional<StringRef> getExternalRedirect() const {
913 if (isa<DirectoryRemapEntry>(E))
914 return StringRef(*ExternalRedirect);
915 if (auto *FE = dyn_cast<FileEntry>(E))
916 return FE->getExternalContentsPath();
917 return std::nullopt;
918 }
919
920 /// Get the (canonical) path of the found entry. This uses the as-written
921 /// path components from the VFS specification.
922 void getPath(llvm::SmallVectorImpl<char> &Path) const;
923 };
924
925private:
928
929 /// Canonicalize path by removing ".", "..", "./", components. This is
930 /// a VFS request, do not bother about symlinks in the path components
931 /// but canonicalize in order to perform the correct entry search.
932 std::error_code makeCanonicalForLookup(SmallVectorImpl<char> &Path) const;
933
934 /// Get the File status, or error, from the underlying external file system.
935 /// This returns the status with the originally requested name, while looking
936 /// up the entry using a potentially different path.
937 ErrorOr<Status> getExternalStatus(const Twine &LookupPath,
938 const Twine &OriginalPath) const;
939
940 /// Make \a Path an absolute path.
941 ///
942 /// Makes \a Path absolute using the \a WorkingDir if it is not already.
943 ///
944 /// /absolute/path => /absolute/path
945 /// relative/../path => <WorkingDir>/relative/../path
946 ///
947 /// \param WorkingDir A path that will be used as the base Dir if \a Path
948 /// is not already absolute.
949 /// \param Path A path that is modified to be an absolute path.
950 /// \returns success if \a path has been made absolute, otherwise a
951 /// platform-specific error_code.
952 std::error_code makeAbsolute(StringRef WorkingDir,
953 SmallVectorImpl<char> &Path) const;
954
955 // In a RedirectingFileSystem, keys can be specified in Posix or Windows
956 // style (or even a mixture of both), so this comparison helper allows
957 // slashes (representing a root) to match backslashes (and vice versa). Note
958 // that, other than the root, path components should not contain slashes or
959 // backslashes.
960 bool pathComponentMatches(llvm::StringRef lhs, llvm::StringRef rhs) const {
961 if ((CaseSensitive ? lhs.equals(rhs) : lhs.equals_insensitive(rhs)))
962 return true;
963 return (lhs == "/" && rhs == "\\") || (lhs == "\\" && rhs == "/");
964 }
965
966 /// The root(s) of the virtual file system.
967 std::vector<std::unique_ptr<Entry>> Roots;
968
969 /// The current working directory of the file system.
970 std::string WorkingDirectory;
971
972 /// The file system to use for external references.
974
975 /// This represents the directory path that the YAML file is located.
976 /// This will be prefixed to each 'external-contents' if IsRelativeOverlay
977 /// is set. This will also be prefixed to each 'roots->name' if RootRelative
978 /// is set to RootRelativeKind::OverlayDir and the path is relative.
979 std::string OverlayFileDir;
980
981 /// @name Configuration
982 /// @{
983
984 /// Whether to perform case-sensitive comparisons.
985 ///
986 /// Currently, case-insensitive matching only works correctly with ASCII.
987 bool CaseSensitive = is_style_posix(sys::path::Style::native);
988
989 /// IsRelativeOverlay marks whether a OverlayFileDir path must
990 /// be prefixed in every 'external-contents' when reading from YAML files.
991 bool IsRelativeOverlay = false;
992
993 /// Whether to use to use the value of 'external-contents' for the
994 /// names of files. This global value is overridable on a per-file basis.
995 bool UseExternalNames = true;
996
997 /// True if this FS has redirected a lookup. This does not include
998 /// fallthrough.
999 mutable bool HasBeenUsed = false;
1000
1001 /// Used to enable or disable updating `HasBeenUsed`.
1002 bool UsageTrackingActive = false;
1003
1004 /// Determines the lookups to perform, as well as their order. See
1005 /// \c RedirectKind for details.
1007
1008 /// Determine the prefix directory if the roots are relative paths. See
1009 /// \c RootRelativeKind for details.
1011 /// @}
1012
1014
1015 /// Looks up the path <tt>[Start, End)</tt> in \p From, possibly recursing
1016 /// into the contents of \p From if it is a directory. Returns a LookupResult
1017 /// giving the matched entry and, if that entry is a FileEntry or
1018 /// DirectoryRemapEntry, the path it redirects to in the external file system.
1020 lookupPathImpl(llvm::sys::path::const_iterator Start,
1022 llvm::SmallVectorImpl<Entry *> &Entries) const;
1023
1024 /// Get the status for a path with the provided \c LookupResult.
1025 ErrorOr<Status> status(const Twine &LookupPath, const Twine &OriginalPath,
1026 const LookupResult &Result);
1027
1028public:
1029 /// Looks up \p Path in \c Roots and returns a LookupResult giving the
1030 /// matched entry and, if the entry was a FileEntry or DirectoryRemapEntry,
1031 /// the path it redirects to in the external file system.
1033
1034 /// Parses \p Buffer, which is expected to be in YAML format and
1035 /// returns a virtual file system representing its contents.
1036 static std::unique_ptr<RedirectingFileSystem>
1037 create(std::unique_ptr<MemoryBuffer> Buffer,
1039 void *DiagContext, IntrusiveRefCntPtr<FileSystem> ExternalFS);
1040
1041 /// Redirect each of the remapped files from first to second.
1042 static std::unique_ptr<RedirectingFileSystem>
1043 create(ArrayRef<std::pair<std::string, std::string>> RemappedFiles,
1044 bool UseExternalNames, FileSystem &ExternalFS);
1045
1046 ErrorOr<Status> status(const Twine &Path) override;
1048
1049 std::error_code getRealPath(const Twine &Path,
1050 SmallVectorImpl<char> &Output) const override;
1051
1053
1054 std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
1055
1056 std::error_code isLocal(const Twine &Path, bool &Result) override;
1057
1058 std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const override;
1059
1060 directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
1061
1062 void setOverlayFileDir(StringRef PrefixDir);
1063
1065
1066 /// Sets the redirection kind to \c Fallthrough if true or \c RedirectOnly
1067 /// otherwise. Will removed in the future, use \c setRedirection instead.
1068 void setFallthrough(bool Fallthrough);
1069
1071
1072 std::vector<llvm::StringRef> getRoots() const;
1073
1074 bool hasBeenUsed() const { return HasBeenUsed; };
1075 void clearHasBeenUsed() { HasBeenUsed = false; }
1076
1077 void setUsageTrackingActive(bool Active) { UsageTrackingActive = Active; }
1078
1079 void printEntry(raw_ostream &OS, Entry *E, unsigned IndentLevel = 0) const;
1080
1081protected:
1083 unsigned IndentLevel) const override;
1084 void visitChildFileSystems(VisitCallbackTy Callback) override;
1085};
1086
1087/// Collect all pairs of <virtual path, real path> entries from the
1088/// \p YAMLFilePath. This is used by the module dependency collector to forward
1089/// the entries into the reproducer output VFS YAML file.
1091 std::unique_ptr<llvm::MemoryBuffer> Buffer,
1093 SmallVectorImpl<YAMLVFSEntry> &CollectedEntries,
1094 void *DiagContext = nullptr,
1096
1098 std::vector<YAMLVFSEntry> Mappings;
1099 std::optional<bool> IsCaseSensitive;
1100 std::optional<bool> IsOverlayRelative;
1101 std::optional<bool> UseExternalNames;
1102 std::string OverlayDir;
1103
1104 void addEntry(StringRef VirtualPath, StringRef RealPath, bool IsDirectory);
1105
1106public:
1107 YAMLVFSWriter() = default;
1108
1109 void addFileMapping(StringRef VirtualPath, StringRef RealPath);
1110 void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath);
1111
1112 void setCaseSensitivity(bool CaseSensitive) {
1113 IsCaseSensitive = CaseSensitive;
1114 }
1115
1116 void setUseExternalNames(bool UseExtNames) { UseExternalNames = UseExtNames; }
1117
1118 void setOverlayDir(StringRef OverlayDirectory) {
1119 IsOverlayRelative = true;
1120 OverlayDir.assign(OverlayDirectory.str());
1121 }
1122
1123 const std::vector<YAMLVFSEntry> &getMappings() const { return Mappings; }
1124
1125 void write(llvm::raw_ostream &OS);
1126};
1127
1128} // namespace vfs
1129} // namespace llvm
1130
1131#endif // LLVM_SUPPORT_VIRTUALFILESYSTEM_H
BlockVerifier::State From
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:529
T Content
std::string Name
bool End
Definition: ELF_riscv.cpp:480
Provides ErrorOr<T> smart pointer.
static void makeAbsolute(SmallVectorImpl< char > &Path)
Make Path absolute.
This file defines the RefCountedBase, ThreadSafeRefCountedBase, and IntrusiveRefCntPtr classes.
#define I(x, y, z)
Definition: MD5.cpp:58
#define T1
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file defines the SmallVector class.
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:1060
Value * RHS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Represents either an error or a value T.
Definition: ErrorOr.h:56
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
Inheritance utility for extensible RTTI.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
std::reverse_iterator< const_iterator > const_reverse_iterator
Definition: SmallVector.h:267
std::reverse_iterator< iterator > reverse_iterator
Definition: SmallVector.h:268
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
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:222
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:164
bool equals_insensitive(StringRef RHS) const
Check for string equality, ignoring case.
Definition: StringRef.h:170
Target - Wrapper for Target specific information.
A thread-safe version of RefCountedBase.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
An efficient, type-erasing, non-owning reference to a callable.
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:226
The virtual file system interface.
llvm::function_ref< void(FileSystem &)> VisitCallbackTy
virtual llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const =0
Get the working directory of this file system.
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
virtual std::error_code setCurrentWorkingDirectory(const Twine &Path)=0
Set the working directory.
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.
virtual void printImpl(raw_ostream &OS, PrintType Type, unsigned IndentLevel) const
virtual std::error_code makeAbsolute(SmallVectorImpl< char > &Path) const
Make Path an absolute path.
static const char ID
virtual llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path)=0
Get a File object for the file at Path, if one exists.
virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC)=0
Get a directory_iterator for Dir.
void printIndent(raw_ostream &OS, unsigned IndentLevel) const
LLVM_DUMP_METHOD void dump() const
void print(raw_ostream &OS, PrintType Type=PrintType::Contents, unsigned IndentLevel=0) const
virtual void visitChildFileSystems(VisitCallbackTy Callback)
void visit(VisitCallbackTy Callback)
virtual std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const
Gets real path of Path e.g.
virtual std::error_code isLocal(const Twine &Path, bool &Result)
Is the file mounted on a local filesystem?
virtual llvm::ErrorOr< Status > status(const Twine &Path)=0
Get the status of the entry at Path, if one exists.
Represents an open file.
static ErrorOr< std::unique_ptr< File > > getWithPath(ErrorOr< std::unique_ptr< File > > Result, const Twine &P)
virtual llvm::ErrorOr< Status > status()=0
Get the status of the file.
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.
virtual llvm::ErrorOr< std::string > getName()
Get the name of the file.
virtual void setPath(const Twine &Path)
virtual ~File()
Destroy the file after closing it (if open).
virtual std::error_code close()=0
Closes the file.
Adaptor from InMemoryDir::iterator to directory_iterator.
An in-memory file system.
std::error_code isLocal(const Twine &Path, bool &Result) override
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
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....
static constexpr size_t MaxSymlinkDepth
Arbitrary max depth to search through symlinks.
bool useNormalizedPaths() const
Return true if this file system normalizes . and .. in paths.
void printImpl(raw_ostream &OS, PrintType Type, unsigned IndentLevel) const override
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
bool addHardLink(const Twine &NewLink, const Twine &Target)
Add a hard link to a file.
bool addFileNoOwn(const Twine &Path, time_t ModificationTime, const llvm::MemoryBufferRef &Buffer, std::optional< uint32_t > User=std::nullopt, std::optional< uint32_t > Group=std::nullopt, std::optional< llvm::sys::fs::file_type > Type=std::nullopt, std::optional< llvm::sys::fs::perms > Perms=std::nullopt)
Add a buffer to the VFS with a path.
bool addSymbolicLink(const Twine &NewLink, const Twine &Target, time_t ModificationTime, std::optional< uint32_t > User=std::nullopt, std::optional< uint32_t > Group=std::nullopt, std::optional< llvm::sys::fs::perms > Perms=std::nullopt)
Add a symbolic link.
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
llvm::ErrorOr< Status > status(const Twine &Path) override
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
A file system that allows overlaying one AbstractFileSystem on top of another.
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
const_iterator overlays_end() const
const_iterator overlays_begin() const
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
reverse_iterator overlays_rbegin()
Get an iterator pointing to the least recently added file system.
const_range overlays_range() const
void visitChildFileSystems(VisitCallbackTy Callback) override
const_reverse_iterator overlays_rend() const
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
reverse_iterator overlays_rend()
Get an iterator pointing one-past the most recently added file system.
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
void pushOverlay(IntrusiveRefCntPtr< FileSystem > FS)
Pushes a file system on top of the stack.
FileSystemList::const_reverse_iterator const_iterator
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
iterator overlays_end()
Get an iterator pointing one-past the least recently added file system.
std::error_code isLocal(const Twine &Path, bool &Result) override
llvm::ErrorOr< Status > status(const Twine &Path) override
iterator overlays_begin()
Get an iterator pointing to the most recently added file system.
const_reverse_iterator overlays_rbegin() const
FileSystemList::reverse_iterator iterator
void printImpl(raw_ostream &OS, PrintType Type, unsigned IndentLevel) const override
By default, this delegates all calls to the underlying file system.
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
void visitChildFileSystems(VisitCallbackTy Callback) override
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
llvm::ErrorOr< Status > status(const Twine &Path) override
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
std::error_code isLocal(const Twine &Path, bool &Result) override
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
ProxyFileSystem(IntrusiveRefCntPtr< FileSystem > FS)
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
FileSystem & getUnderlyingFS() const
Directory iterator implementation for RedirectingFileSystem's directory entries.
A helper class to hold the common YAML parsing state.
A directory in the vfs with explicitly specified contents.
DirectoryEntry(StringRef Name, Status S)
Constructs an empty directory entry.
DirectoryEntry(StringRef Name, std::vector< std::unique_ptr< Entry > > Contents, Status S)
Constructs a directory entry with explicitly specified contents.
void addContent(std::unique_ptr< Entry > Content)
A directory in the vfs that maps to a directory in the external file system.
DirectoryRemapEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
A single file or directory in the VFS.
Entry(EntryKind K, StringRef Name)
A file in the vfs that maps to a file in the external file system.
FileEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
A file or directory in the vfs that is mapped to a file or directory in the external filesystem.
RemapEntry(EntryKind K, StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
bool useExternalName(bool GlobalUseExternalName) const
Whether to use the external path as the name for this file or directory.
A virtual file system parsed from a YAML file.
RootRelativeKind
The type of relative path used by Roots.
@ OverlayDir
The roots are relative to the directory where the Overlay YAML file.
@ CWD
The roots are relative to the current working directory.
void printImpl(raw_ostream &OS, PrintType Type, unsigned IndentLevel) const override
std::vector< llvm::StringRef > getRoots() const
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
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...
RedirectKind
The type of redirection to perform.
@ Fallthrough
Lookup the redirected path first (ie.
@ Fallback
Lookup the provided path first and if that fails, "fallback" to a lookup of the redirected path.
@ RedirectOnly
Only lookup the redirected path, do not lookup the originally provided path.
void setFallthrough(bool Fallthrough)
Sets the redirection kind to Fallthrough if true or RedirectOnly otherwise.
void visitChildFileSystems(VisitCallbackTy Callback) override
ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
void setOverlayFileDir(StringRef PrefixDir)
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
void setRedirection(RedirectingFileSystem::RedirectKind Kind)
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
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 ...
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Gets real path of Path e.g.
void printEntry(raw_ostream &OS, Entry *E, unsigned IndentLevel=0) const
The result of a status operation.
llvm::sys::fs::perms getPermissions() const
llvm::sys::fs::UniqueID getUniqueID() const
uint32_t getUser() const
bool equivalent(const Status &Other) const
static Status copyWithNewName(const Status &In, const Twine &NewName)
Get a copy of a Status with a different name.
uint64_t getSize() const
bool isStatusKnown() const
bool ExposesExternalVFSPath
Whether this entity has an external path different from the virtual path, and the external path is ex...
uint32_t getGroup() const
static Status copyWithNewSize(const Status &In, uint64_t NewSize)
Get a copy of a Status with a different size.
llvm::sys::TimePoint getLastModificationTime() const
llvm::sys::fs::file_type getType() const
bool isRegularFile() const
bool isDirectory() const
StringRef getName() const
Returns the name that should be used for this file or directory.
Status(const Twine &Name, llvm::sys::fs::UniqueID UID, llvm::sys::TimePoint<> MTime, uint32_t User, uint32_t Group, uint64_t Size, llvm::sys::fs::file_type Type, llvm::sys::fs::perms Perms)
void addFileMapping(StringRef VirtualPath, StringRef RealPath)
void setCaseSensitivity(bool CaseSensitive)
void setOverlayDir(StringRef OverlayDirectory)
const std::vector< YAMLVFSEntry > & getMappings() const
void write(llvm::raw_ostream &OS)
void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath)
void setUseExternalNames(bool UseExtNames)
The in memory file system is a tree of Nodes.
const detail::InMemoryNode * operator*() const
NamedNodeOrError(llvm::SmallString< 128 > Name, const detail::InMemoryNode *Node)
A member of a directory, yielded by a directory_iterator.
directory_entry()=default
directory_entry(std::string Path, llvm::sys::fs::file_type Type)
llvm::StringRef path() const
llvm::sys::fs::file_type type() const
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
directory_iterator(std::shared_ptr< detail::DirIterImpl > I)
bool operator==(const directory_iterator &RHS) const
const directory_entry * operator->() const
const directory_entry & operator*() const
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
bool operator!=(const directory_iterator &RHS) const
directory_iterator()=default
Construct an 'end' iterator.
An input iterator over the recursive contents of a virtual path, similar to llvm::sys::fs::recursive_...
const directory_entry & operator*() const
recursive_directory_iterator()=default
Construct an 'end' iterator.
bool operator!=(const recursive_directory_iterator &RHS) const
bool operator==(const recursive_directory_iterator &Other) const
int level() const
Gets the current level. Starting path is at level 0.
recursive_directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
const directory_entry * operator->() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ClauseT.h:79
file_type
An enumeration for the file system's view of the type.
Definition: FileSystem.h:66
std::chrono::time_point< std::chrono::system_clock, D > TimePoint
A time point on the system clock.
Definition: Chrono.h:34
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.
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.
std::unique_ptr< FileSystem > createPhysicalFileSystem()
Create an vfs::FileSystem for the 'real' file system, as seen by the operating system.
llvm::sys::fs::UniqueID getNextVirtualUniqueID()
Get a globally unique ID for a virtual file or directory.
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
errc
Definition: Errc.h:35
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:428
@ Other
Any other memory.
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:1858
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
Represents the result of a path lookup into the RedirectingFileSystem.
std::optional< StringRef > getExternalRedirect() const
If the found Entry maps the input path to a path in the external file system (i.e.
Entry * E
The entry the looked-up path corresponds to.
void getPath(llvm::SmallVectorImpl< char > &Path) const
Get the (canonical) path of the found entry.
llvm::SmallVector< Entry *, 32 > Parents
Chain of parent directory entries for E.
YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory=false)
An interface for virtual file systems to provide an iterator over the (non-recursive) contents of a d...
virtual std::error_code increment()=0
Sets CurrentEntry to the next entry in the directory on success, to directory_entry() at end,...
std::unique_ptr< llvm::MemoryBuffer > Buffer
Keeps state for the recursive_directory_iterator.
std::stack< directory_iterator, std::vector< directory_iterator > > Stack