1//===- VirtualFileSystem.h - Virtual File System Layer ----------*- C++ -*-===//
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
7//===----------------------------------------------------------------------===//
10/// Defines the virtual file system interface vfs::FileSystem.
12//===----------------------------------------------------------------------===//
14#ifndef LLVM_SUPPORT_VIRTUALFILESYSTEM_H
15#define LLVM_SUPPORT_VIRTUALFILESYSTEM_H
36#include <system_error>
48/// The result of a \p status operation.
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.
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.
78 /// Get a copy of a Status with a different size.
80 /// Get a copy of a Status with a different name.
82 const Twine &NewName);
84 const Twine &NewName);
86 /// Returns the name that should be used for this file or directory.
89 /// @name Status interface from llvm::sys::fs
99 /// @name Status queries
100 /// These are static queries in llvm::sys::fs.
112/// Represents an open file.
115 /// Destroy the file after closing it (if open).
116 /// Sub-classes should generally call close() inside their destructors. We
117 /// cannot do that from the base class, since close is virtual.
120 /// Get the status of the file.
123 /// Get the name of the file
131 /// Get the contents of the file as a \p MemoryBuffer.
134 bool RequiresNullTerminator =
true,
bool IsVolatile =
false) = 0;
137 virtual std::error_code
close() = 0;
139 // Get the same file with a different path.
144 // Set the file's underlying path.
148/// A member of a directory, yielded by a directory_iterator.
149/// Only information available on most platforms is included.
157 : Path(
std::
move(Path)), Type(Type) {}
165/// An interface for virtual file systems to provide an iterator over the
166/// (non-recursive) contents of a directory.
170 /// Sets \c CurrentEntry to the next entry in the directory on success,
171 /// to directory_entry() at end, or returns a system-defined \c error_code.
179/// An input iterator over the entries in a virtual path, similar to
180/// llvm::sys::fs::directory_iterator.
182 std::shared_ptr<detail::DirIterImpl> Impl;
// Input iterator semantics on copy
187 assert(Impl.get() !=
nullptr &&
"requires non-null implementation");
188 if (Impl->CurrentEntry.path().empty())
189 Impl.reset();
// Normalize the end iterator to Impl == nullptr.
192 /// Construct an 'end' iterator.
195 /// Equivalent to operator++, with an error code.
197 assert(Impl &&
"attempting to increment past end");
198 EC = Impl->increment();
199 if (Impl->CurrentEntry.path().empty())
200 Impl.reset();
// Normalize the end iterator to Impl == nullptr.
208 if (Impl &&
RHS.Impl)
209 return Impl->CurrentEntry.path() ==
RHS.Impl->CurrentEntry.path();
210 return !Impl && !
RHS.Impl;
213 return !(*
this ==
RHS);
221/// Keeps state for the recursive_directory_iterator.
223 std::vector<directory_iterator>
Stack;
227}
// end namespace detail
229/// An input iterator over the recursive contents of a virtual path,
230/// similar to llvm::sys::fs::recursive_directory_iterator.
233 std::shared_ptr<detail::RecDirIterState>
234 State;
// Input iterator semantics on copy.
238 std::error_code &EC);
240 /// Construct an 'end' iterator.
243 /// Equivalent to operator++, with an error code.
250 return State ==
Other.State;
// identity
253 return !(*
this ==
RHS);
256 /// Gets the current level. Starting path is at level 0.
258 assert(!State->Stack.empty() &&
259 "Cannot get level without any iteration state");
260 return State->Stack.size() - 1;
263 void no_push() { State->HasNoPushRequest =
true; }
266/// The virtual file system interface.
270 static const char ID;
273 /// Get the status of the entry at \p Path, if one exists.
276 /// Get a \p File object for the text file at \p Path, if one exists.
280 /// Get a \p File object for the binary file at \p Path, if one exists.
281 /// Some non-ascii based file systems perform encoding conversions
282 /// when reading as a text file, and this function should be used if
283 /// a file's bytes should be read as-is. On most filesystems, this
284 /// is the same behaviour as openFileForRead.
290 /// This is a convenience method that opens a file, gets its content and then
292 /// The IsText parameter is used to distinguish whether the file should be
293 /// opened as a binary or text file.
295 getBufferForFile(
const Twine &Name, int64_t FileSize = -1,
296 bool RequiresNullTerminator =
true,
bool IsVolatile =
false,
299 /// Get a directory_iterator for \p Dir.
300 /// \note The 'end' iterator is directory_iterator().
302 std::error_code &EC) = 0;
304 /// Set the working directory. This will affect all following operations on
305 /// this file system and may propagate down for nested file systems.
308 /// Get the working directory of this file system.
311 /// Gets real path of \p Path e.g. collapse all . and .. patterns, resolve
312 /// symlinks. For real file system, this uses `llvm::sys::fs::real_path`.
313 /// This returns errc::operation_not_permitted if not implemented by subclass.
317 /// Check whether \p Path exists. By default this uses \c status(), but
318 /// filesystems may provide a more efficient implementation if available.
321 /// Is the file mounted on a local filesystem?
322 virtual std::error_code
isLocal(
const Twine &Path,
bool &Result);
324 /// Make \a Path an absolute path.
326 /// Makes \a Path absolute using the current directory if it is not already.
327 /// An empty \a Path will result in the current directory.
329 /// /absolute/path => /absolute/path
330 /// relative/../path => <current-directory>/relative/../path
332 /// \param Path A path that is modified to be an absolute path.
333 /// \returns success if \a path has been made absolute, otherwise a
334 /// platform-specific error_code.
337 /// \returns true if \p A and \p B represent the same file, or an error or
338 /// false if they do not.
343 unsigned IndentLevel = 0)
const {
354#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
360 unsigned IndentLevel)
const {
362 OS <<
"FileSystem\n";
366 for (
unsigned i = 0; i < IndentLevel; ++i)
371/// Gets an \p vfs::FileSystem for the 'real' file system, as seen by
372/// the operating system.
373/// The working directory is linked to the process's working directory.
374/// (This is usually thread-hostile).
377/// Create an \p vfs::FileSystem for the 'real' file system, as seen by
378/// the operating system.
379/// It has its own working directory, independent of (but initially equal to)
380/// that of the process.
383/// A file system that allows overlaying one \p AbstractFileSystem on top
386/// Consists of a stack of >=1 \p FileSystem objects, which are treated as being
387/// one merged file system. When there is a directory that exists in more than
388/// one file system, the \p OverlayFileSystem contains a directory containing
389/// the union of their contents. The attributes (permissions, etc.) of the
390/// top-most (most recently added) directory are used. When there is a file
391/// that exists in more than one file system, the file in the top-most file
392/// system overrides the other(s).
394 :
public RTTIExtends<OverlayFileSystem, FileSystem> {
397 /// The stack of file systems, implemented as a list in order of
399 FileSystemList FSList;
402 static const char ID;
405 /// Pushes a file system on top of the stack.
415 std::error_code
isLocal(
const Twine &Path,
bool &Result)
override;
426 /// Get an iterator pointing to the most recently added file system.
430 /// Get an iterator pointing one-past the least recently added file system.
434 /// Get an iterator pointing to the least recently added file system.
438 /// Get an iterator pointing one-past the most recently added file system.
447 unsigned IndentLevel)
const override;
448 void visitChildFileSystems(VisitCallbackTy Callback)
override;
451/// By default, this delegates all calls to the underlying file system. This
452/// is useful when derived file systems want to override some calls and still
453/// proxy other calls.
455 :
public RTTIExtends<ProxyFileSystem, FileSystem> {
457 static const char ID;
462 return FS->status(Path);
464 bool exists(
const Twine &Path)
override {
return FS->exists(Path); }
467 return FS->openFileForRead(Path);
470 return FS->dir_begin(Dir, EC);
473 return FS->getCurrentWorkingDirectory();
476 return FS->setCurrentWorkingDirectory(Path);
480 return FS->getRealPath(Path, Output);
483 return FS->isLocal(Path, Result);
491 FS->visitChildFileSystems(Callback);
498 void anchor()
override;
503class InMemoryDirectory;
511 std::unique_ptr<llvm::MemoryBuffer>
Buffer;
527 : Value(
std::make_pair(Name,
Node)) {}
532 explicit operator bool()
const {
return static_cast<bool>(Value); }
533 operator std::error_code()
const {
return Value.getError(); }
534 std::error_code
getError()
const {
return Value.getError(); }
540/// An in-memory file system.
542 :
public RTTIExtends<InMemoryFileSystem, FileSystem> {
543 std::unique_ptr<detail::InMemoryDirectory> Root;
544 std::string WorkingDirectory;
545 bool UseNormalizedPaths =
true;
548 static const char ID;
554 /// Create node with \p MakeNode and add it into this filesystem at \p Path.
555 bool addFile(
const Twine &Path, time_t ModificationTime,
556 std::unique_ptr<llvm::MemoryBuffer> Buffer,
557 std::optional<uint32_t>
User, std::optional<uint32_t> Group,
558 std::optional<llvm::sys::fs::file_type>
Type,
559 std::optional<llvm::sys::fs::perms> Perms, MakeNodeFn MakeNode);
561 /// Looks up the in-memory node for the path \p P.
562 /// If \p FollowFinalSymlink is true, the returned node is guaranteed to
563 /// not be a symlink and its path may differ from \p P.
565 size_t SymlinkDepth = 0)
const;
573 /// Add a file containing a buffer or a directory to the VFS with a
574 /// path. The VFS owns the buffer. If present, User, Group, Type
575 /// and Perms apply to the newly-created file or directory.
576 /// \return true if the file or directory was successfully added,
577 /// false if the file or directory already exists in the file system with
578 /// different contents.
579 bool addFile(
const Twine &Path, time_t ModificationTime,
580 std::unique_ptr<llvm::MemoryBuffer> Buffer,
581 std::optional<uint32_t>
User = std::nullopt,
582 std::optional<uint32_t> Group = std::nullopt,
583 std::optional<llvm::sys::fs::file_type>
Type = std::nullopt,
584 std::optional<llvm::sys::fs::perms> Perms = std::nullopt);
586 /// Add a hard link to a file.
588 /// Here hard links are not intended to be fully equivalent to the classical
589 /// filesystem. Both the hard link and the file share the same buffer and
590 /// status (and thus have the same UniqueID). Because of this there is no way
591 /// to distinguish between the link and the file after the link has been
594 /// The \p Target path must be an existing file or a hardlink. The
595 /// \p NewLink file must not have been added before. The \p Target
596 /// path must not be a directory. The \p NewLink node is added as a hard
597 /// link which points to the resolved file of \p Target node.
598 /// \return true if the above condition is satisfied and hardlink was
599 /// successfully created, false otherwise.
602 /// Arbitrary max depth to search through symlinks. We can get into problems
603 /// if a link links to a link that links back to the link, for example.
606 /// Add a symbolic link. Unlike a HardLink, because \p Target doesn't need
607 /// to refer to a file (or refer to anything, as it happens). Also, an
608 /// in-memory directory for \p Target isn't automatically created.
611 time_t ModificationTime,
612 std::optional<uint32_t>
User = std::nullopt,
613 std::optional<uint32_t> Group = std::nullopt,
614 std::optional<llvm::sys::fs::perms> Perms = std::nullopt);
616 /// Add a buffer to the VFS with a path. The VFS does not own the buffer.
617 /// If present, User, Group, Type and Perms apply to the newly-created file
619 /// \return true if the file or directory was successfully added,
620 /// false if the file or directory already exists in the file system with
621 /// different contents.
624 std::optional<uint32_t>
User = std::nullopt,
625 std::optional<uint32_t> Group = std::nullopt,
626 std::optional<llvm::sys::fs::file_type>
Type = std::nullopt,
627 std::optional<llvm::sys::fs::perms> Perms = std::nullopt);
631 /// Return true if this file system normalizes . and .. in paths.
636 openFileForRead(
const Twine &Path)
override;
640 return WorkingDirectory;
642 /// Canonicalizes \p Path by combining with the current working
643 /// directory and normalizing the path (e.g. remove dots). If the current
644 /// working directory is not set, this returns errc::operation_not_permitted.
646 /// This doesn't resolve symlinks as they are not supported in in-memory file
648 std::error_code getRealPath(
const Twine &Path,
650 std::error_code isLocal(
const Twine &Path,
bool &Result)
override;
651 std::error_code setCurrentWorkingDirectory(
const Twine &Path)
override;
655 unsigned IndentLevel)
const override;
658/// Get a globally unique ID for a virtual file or directory.
661/// Gets a \p FileSystem for a virtual file system described in YAML
666 StringRef YAMLFilePath,
void *DiagContext =
nullptr,
670 template <
typename T1,
typename T2>
682/// A virtual file system parsed from a YAML file.
684/// Currently, this class allows creating virtual files and directories. Virtual
685/// files map to existing external files in \c ExternalFS, and virtual
686/// directories may either map to existing directories in \c ExternalFS or list
687/// their contents in the form of other virtual directories and/or files.
689/// The basic structure of the parsed file is:
692/// 'version': <version number>,
693/// <optional configuration>
695/// <directory entries>
699/// The roots may be absolute or relative. If relative they will be made
700/// absolute against either current working directory or the directory where
701/// the Overlay YAML file is located, depending on the 'root-relative'
704/// All configuration options are optional.
705/// 'case-sensitive': <boolean, default=(true for Posix, false for Windows)>
706/// 'use-external-names': <boolean, default=true>
707/// 'root-relative': <string, one of 'cwd' or 'overlay-dir', default='cwd'>
708/// 'overlay-relative': <boolean, default=false>
709/// 'fallthrough': <boolean, default=true, deprecated - use 'redirecting-with'
711/// 'redirecting-with': <string, one of 'fallthrough', 'fallback', or
712/// 'redirect-only', default='fallthrough'>
714/// To clarify, 'root-relative' option will prepend the current working
715/// directory, or the overlay directory to the 'roots->name' field only if
716/// 'roots->name' is a relative path. On the other hand, when 'overlay-relative'
717/// is set to 'true', external paths will always be prepended with the overlay
718/// directory, even if external paths are not relative paths. The
719/// 'root-relative' option has no interaction with the 'overlay-relative'
722/// Virtual directories that list their contents are represented as
725/// 'type': 'directory',
727/// 'contents': [ <file or directory entries> ]
730/// The default attributes for such virtual directories are:
732/// MTime = now() when created
736/// UniqueID = unspecified unique value
738/// When a path prefix matches such a directory, the next component in the path
739/// is matched against the entries in the 'contents' array.
741/// Re-mapped directories, on the other hand, are represented as
744/// 'type': 'directory-remap',
746/// 'use-external-name': <boolean>, # Optional
747/// 'external-contents': <path to external directory>
750/// and inherit their attributes from the external directory. When a path
751/// prefix matches such an entry, the unmatched components are appended to the
752/// 'external-contents' path, and the resulting path is looked up in the
753/// external file system instead.
755/// Re-mapped files are represented as
760/// 'use-external-name': <boolean>, # Optional
761/// 'external-contents': <path to external file>
764/// Their attributes and file contents are determined by looking up the file at
765/// their 'external-contents' path in the external file system.
767/// For 'file', 'directory' and 'directory-remap' entries the 'name' field may
768/// contain multiple path components (e.g. /path/to/file). However, any
769/// directory in such a path that contains more than one child must be uniquely
770/// represented by a 'directory' entry.
772/// When the 'use-external-name' field is set, calls to \a vfs::File::status()
773/// give the external (remapped) filesystem name instead of the name the file
774/// was accessed by. This is an intentional leak through the \a
775/// RedirectingFileSystem abstraction layer. It enables clients to discover
776/// (and use) the external file location when communicating with users or tools
777/// that don't use the same VFS overlay.
779/// FIXME: 'use-external-name' causes behaviour that's inconsistent with how
780/// "real" filesystems behave. Maybe there should be a separate channel for
783 :
public RTTIExtends<RedirectingFileSystem, vfs::FileSystem> {
785 static const char ID;
789 /// The type of redirection to perform.
791 /// Lookup the redirected path first (ie. the one specified in
792 /// 'external-contents') and if that fails "fallthrough" to a lookup of the
793 /// originally provided path.
795 /// Lookup the provided path first and if that fails, "fallback" to a
796 /// lookup of the redirected path.
798 /// Only lookup the redirected path, do not lookup the originally provided
803 /// The type of relative path used by Roots.
805 /// The roots are relative to the current working directory.
807 /// The roots are relative to the directory where the Overlay YAML file
812 /// A single file or directory in the VFS.
825 /// A directory in the vfs with explicitly specified contents.
827 std::vector<std::unique_ptr<Entry>> Contents;
831 /// Constructs a directory entry with explicitly specified contents.
837 /// Constructs an empty directory entry.
844 Contents.push_back(std::move(Content));
857 /// A file or directory in the vfs that is mapped to a file or directory in
858 /// the external filesystem.
860 std::string ExternalContentsPath;
866 :
Entry(K, Name), ExternalContentsPath(ExternalContentsPath),
872 /// Whether to use the external path as the name for this file or directory.
874 return UseName ==
NK_NotSet ? GlobalUseExternalName
881 switch (
E->getKind()) {
893 /// A directory in the vfs that maps to a directory in the external file
906 /// A file in the vfs that maps to a file in the external file system.
915 /// Represents the result of a path lookup into the RedirectingFileSystem.
917 /// Chain of parent directory entries for \c E.
920 /// The entry the looked-up path corresponds to.
924 /// When the found Entry is a DirectoryRemapEntry, stores the path in the
925 /// external file system that the looked-up path in the virtual file system
927 std::optional<std::string> ExternalRedirect;
933 /// If the found Entry maps the input path to a path in the external
934 /// file system (i.e. it is a FileEntry or DirectoryRemapEntry), returns
940 return FE->getExternalContentsPath();
944 /// Get the (canonical) path of the found entry. This uses the as-written
945 /// path components from the VFS specification.
953 /// Canonicalize path by removing ".", "..", "./", components. This is
954 /// a VFS request, do not bother about symlinks in the path components
955 /// but canonicalize in order to perform the correct entry search.
958 /// Get the File status, or error, from the underlying external file system.
959 /// This returns the status with the originally requested name, while looking
960 /// up the entry using a potentially different path.
962 const Twine &OriginalPath)
const;
964 /// Make \a Path an absolute path.
966 /// Makes \a Path absolute using the \a WorkingDir if it is not already.
968 /// /absolute/path => /absolute/path
969 /// relative/../path => <WorkingDir>/relative/../path
971 /// \param WorkingDir A path that will be used as the base Dir if \a Path
972 /// is not already absolute.
973 /// \param Path A path that is modified to be an absolute path.
974 /// \returns success if \a path has been made absolute, otherwise a
975 /// platform-specific error_code.
979 // In a RedirectingFileSystem, keys can be specified in Posix or Windows
980 // style (or even a mixture of both), so this comparison helper allows
981 // slashes (representing a root) to match backslashes (and vice versa). Note
982 // that, other than the root, path components should not contain slashes or
987 return (lhs ==
"/" && rhs ==
"\\") || (lhs ==
"\\" && rhs ==
"/");
990 /// The root(s) of the virtual file system.
991 std::vector<std::unique_ptr<Entry>> Roots;
993 /// The current working directory of the file system.
994 std::string WorkingDirectory;
996 /// The file system to use for external references.
999 /// This represents the directory path that the YAML file is located.
1000 /// This will be prefixed to each 'external-contents' if IsRelativeOverlay
1001 /// is set. This will also be prefixed to each 'roots->name' if RootRelative
1002 /// is set to RootRelativeKind::OverlayDir and the path is relative.
1003 std::string OverlayFileDir;
1005 /// @name Configuration
1008 /// Whether to perform case-sensitive comparisons.
1010 /// Currently, case-insensitive matching only works correctly with ASCII.
1013 /// IsRelativeOverlay marks whether a OverlayFileDir path must
1014 /// be prefixed in every 'external-contents' when reading from YAML files.
1015 bool IsRelativeOverlay =
false;
1017 /// Whether to use to use the value of 'external-contents' for the
1018 /// names of files. This global value is overridable on a per-file basis.
1019 bool UseExternalNames =
true;
1021 /// True if this FS has redirected a lookup. This does not include
1023 mutable bool HasBeenUsed =
false;
1025 /// Used to enable or disable updating `HasBeenUsed`.
1026 bool UsageTrackingActive =
false;
1028 /// Determines the lookups to perform, as well as their order. See
1029 /// \c RedirectKind for details.
1030 RedirectKind Redirection = RedirectKind::Fallthrough;
1032 /// Determine the prefix directory if the roots are relative paths. See
1033 /// \c RootRelativeKind for details.
1034 RootRelativeKind RootRelative = RootRelativeKind::CWD;
1039 // Explicitly non-copyable.
1043 /// Looks up the path <tt>[Start, End)</tt> in \p From, possibly recursing
1044 /// into the contents of \p From if it is a directory. Returns a LookupResult
1045 /// giving the matched entry and, if that entry is a FileEntry or
1046 /// DirectoryRemapEntry, the path it redirects to in the external file system.
1052 /// Get the status for a path with the provided \c LookupResult.
1054 const LookupResult &Result);
1057 /// Looks up \p Path in \c Roots and returns a LookupResult giving the
1058 /// matched entry and, if the entry was a FileEntry or DirectoryRemapEntry,
1059 /// the path it redirects to in the external file system.
1062 /// Parses \p Buffer, which is expected to be in YAML format and
1063 /// returns a virtual file system representing its contents.
1064 static std::unique_ptr<RedirectingFileSystem>
1065 create(std::unique_ptr<MemoryBuffer> Buffer,
1069 /// Redirect each of the remapped files from first to second.
1070 static std::unique_ptr<RedirectingFileSystem>
1071 create(
ArrayRef<std::pair<std::string, std::string>> RemappedFiles,
1075 bool exists(
const Twine &Path)
override;
1078 std::error_code getRealPath(
const Twine &Path,
1083 std::error_code setCurrentWorkingDirectory(
const Twine &Path)
override;
1085 std::error_code isLocal(
const Twine &Path,
bool &Result)
override;
1091 void setOverlayFileDir(
StringRef PrefixDir);
1095 /// Sets the redirection kind to \c Fallthrough if true or \c RedirectOnly
1096 /// otherwise. Will removed in the future, use \c setRedirection instead.
1097 void setFallthrough(
bool Fallthrough);
1101 std::vector<llvm::StringRef> getRoots()
const;
1108 void printEntry(
raw_ostream &OS, Entry *
E,
unsigned IndentLevel = 0)
const;
1112 unsigned IndentLevel)
const override;
1113 void visitChildFileSystems(VisitCallbackTy Callback)
override;
1116/// Collect all pairs of <virtual path, real path> entries from the
1117/// \p VFS. This is used by the module dependency collector to forward
1118/// the entries into the reproducer output VFS YAML file.
1124 std::vector<YAMLVFSEntry> Mappings;
1125 std::optional<bool> IsCaseSensitive;
1126 std::optional<bool> IsOverlayRelative;
1127 std::optional<bool> UseExternalNames;
1128 std::string OverlayDir;
1139 IsCaseSensitive = CaseSensitive;
1145 IsOverlayRelative =
true;
1146 OverlayDir.assign(OverlayDirectory.
str());
1149 const std::vector<YAMLVFSEntry> &
getMappings()
const {
return Mappings; }
1154/// File system that tracks the number of calls to the underlying file system.
1155/// This is particularly useful when wrapped around \c RealFileSystem to add
1156/// lightweight tracking of expensive syscalls.
1205 unsigned IndentLevel)
const override;
1211#endif // LLVM_SUPPORT_VIRTUALFILESYSTEM_H
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Provides ErrorOr<T> smart pointer.
static void makeAbsolute(vfs::FileSystem &VFS, SmallVectorImpl< char > &Path)
Make Path absolute.
This file defines the RefCountedBase, ThreadSafeRefCountedBase, and IntrusiveRefCntPtr classes.
static const char * toString(MIToken::TokenKind TokenKind)
static void printImpl(const MCAsmInfo &MAI, raw_ostream &OS, const MCSpecifierExpr &Expr)
This file defines the SmallVector class.
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Represents either an error or a value T.
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Inheritance utility for extensible RTTI.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
std::reverse_iterator< const_iterator > const_reverse_iterator
std::reverse_iterator< iterator > reverse_iterator
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
void(*)(const SMDiagnostic &, void *Context) DiagHandlerTy
Clients that want to handle their own diagnostics in a custom way can register a function pointer+con...
StringRef - Represent a constant reference to a string, i.e.
std::string str() const
str - Get the contents as an std::string.
bool equals_insensitive(StringRef RHS) const
Check for string equality, ignoring case.
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...
The instances of the Type class are immutable: once they are created, they are never changed.
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.
Represents the result of a call to sys::fs::status().
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.
virtual bool exists(const Twine &Path)
Check whether Path exists.
virtual llvm::ErrorOr< std::unique_ptr< File > > openFileForReadBinary(const Twine &Path)
Get a File object for the binary file at Path, if one exists.
virtual std::error_code setCurrentWorkingDirectory(const Twine &Path)=0
Set the working directory.
virtual void printImpl(raw_ostream &OS, PrintType Type, unsigned IndentLevel) const
virtual llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path)=0
Get a File object for the text file at Path, if one exists.
virtual std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output)
Gets real path of Path e.g.
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
void print(raw_ostream &OS, PrintType Type=PrintType::Contents, unsigned IndentLevel=0) const
virtual void visitChildFileSystems(VisitCallbackTy Callback)
void visit(VisitCallbackTy Callback)
llvm::ErrorOr< bool > equivalent(const Twine &A, const Twine &B)
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.
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.
~InMemoryFileSystem() override
static constexpr size_t MaxSymlinkDepth
Arbitrary max depth to search through symlinks.
InMemoryFileSystem(bool UseNormalizedPaths=true)
bool useNormalizedPaths() const
Return true if this file system normalizes . and .. in paths.
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.
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
const_reverse_iterator overlays_rend() const
iterator_range< iterator > range
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 getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) override
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
OverlayFileSystem(IntrusiveRefCntPtr< FileSystem > Base)
FileSystemList::const_iterator const_reverse_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
FileSystemList::iterator reverse_iterator
bool exists(const Twine &Path) override
llvm::ErrorOr< Status > status(const Twine &Path) override
iterator overlays_begin()
Get an iterator pointing to the most recently added file system.
iterator_range< const_iterator > const_range
const_reverse_iterator overlays_rbegin() const
FileSystemList::reverse_iterator iterator
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
void visitChildFileSystems(VisitCallbackTy Callback) override
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) override
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
llvm::ErrorOr< Status > status(const Twine &Path) override
bool exists(const Twine &Path) override
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
std::error_code isLocal(const Twine &Path, bool &Result) 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.
iterator contents_begin()
static bool classof(const Entry *E)
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.
decltype(Contents)::iterator iterator
void addContent(std::unique_ptr< Entry > Content)
Entry * getLastContent() const
DirectoryRemapEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
static bool classof(const Entry *E)
A single file or directory in the VFS.
StringRef getName() const
EntryKind getKind() const
Entry(EntryKind K, StringRef Name)
static bool classof(const Entry *E)
FileEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)
StringRef getExternalContentsPath() const
NameKind getUseName() const
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.
static bool classof(const Entry *E)
A virtual file system parsed from a YAML file.
void setUsageTrackingActive(bool Active)
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.
friend class RedirectingFileSystemParser
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.
friend class RedirectingFSDirIterImpl
The result of a status operation.
llvm::sys::fs::perms getPermissions() const
llvm::sys::fs::UniqueID getUniqueID() const
LLVM_ABI bool equivalent(const Status &Other) const
static LLVM_ABI Status copyWithNewName(const Status &In, const Twine &NewName)
Get a copy of a Status with a different name.
LLVM_ABI bool isStatusKnown() const
LLVM_ABI bool exists() 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 LLVM_ABI Status copyWithNewSize(const Status &In, uint64_t NewSize)
Get a copy of a Status with a different size.
LLVM_ABI bool isOther() const
LLVM_ABI bool isSymlink() const
llvm::sys::TimePoint getLastModificationTime() const
llvm::sys::fs::file_type getType() const
LLVM_ABI bool isRegularFile() const
LLVM_ABI bool isDirectory() const
StringRef getName() const
Returns the name that should be used for this file or directory.
bool exists(const Twine &Path) override
TracingFileSystem(llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)
ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
std::size_t NumOpenFileForReadCalls
std::size_t NumIsLocalCalls
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
std::size_t NumExistsCalls
ErrorOr< Status > status(const Twine &Path) override
std::error_code isLocal(const Twine &Path, bool &Result) override
std::size_t NumDirBeginCalls
std::size_t NumGetRealPathCalls
std::size_t NumStatusCalls
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) override
LLVM_ABI void addFileMapping(StringRef VirtualPath, StringRef RealPath)
void setCaseSensitivity(bool CaseSensitive)
void setOverlayDir(StringRef OverlayDirectory)
const std::vector< YAMLVFSEntry > & getMappings() const
LLVM_ABI void write(llvm::raw_ostream &OS)
LLVM_ABI void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath)
void setUseExternalNames(bool UseExtNames)
The in memory file system is a tree of Nodes.
std::error_code getError() const
NamedNodeOrError(std::error_code EC)
const detail::InMemoryNode * operator*() const
StringRef getName() const
NamedNodeOrError(llvm::errc EC)
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.
const directory_entry & operator*() const
LLVM_ABI recursive_directory_iterator(FileSystem &FS, const Twine &Path, std::error_code &EC)
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.
LLVM_ABI 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.
file_type
An enumeration for the file system's view of the type.
std::chrono::time_point< std::chrono::system_clock, D > TimePoint
A time point on the system clock.
LLVM_ABI void collectVFSEntries(RedirectingFileSystem &VFS, SmallVectorImpl< YAMLVFSEntry > &CollectedEntries)
Collect all pairs of <virtual path, real path> entries from the VFS.
LLVM_ABI std::unique_ptr< FileSystem > createPhysicalFileSystem()
Create an vfs::FileSystem for the 'real' file system, as seen by the operating system.
LLVM_ABI llvm::sys::fs::UniqueID getNextVirtualUniqueID()
Get a globally unique ID for a virtual file or directory.
LLVM_ABI IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
LLVM_ABI 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.
This is an optimization pass for GlobalISel generic memory operations.
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
auto reverse(ContainerTy &&C)
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Implement std::hash so that hash_code can be used in STL containers.
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.
LLVM_ABI LookupResult(Entry *E, sys::path::const_iterator Start, sys::path::const_iterator End)
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,...
directory_entry CurrentEntry
LLVM_ABI Status makeStatus() const
llvm::sys::fs::file_type Type
std::unique_ptr< llvm::MemoryBuffer > Buffer
llvm::sys::fs::perms Perms
llvm::sys::fs::UniqueID DirUID
Keeps state for the recursive_directory_iterator.
std::vector< directory_iterator > Stack