/home/arjun/llvm-project/llvm/include/llvm/Support/VirtualFileSystem.h
Line | Count | Source (jump to first uncovered line) |
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 | | |
17 | | #include "llvm/ADT/IntrusiveRefCntPtr.h" |
18 | | #include "llvm/ADT/None.h" |
19 | | #include "llvm/ADT/Optional.h" |
20 | | #include "llvm/ADT/SmallVector.h" |
21 | | #include "llvm/ADT/StringRef.h" |
22 | | #include "llvm/Support/Chrono.h" |
23 | | #include "llvm/Support/ErrorOr.h" |
24 | | #include "llvm/Support/FileSystem.h" |
25 | | #include "llvm/Support/Path.h" |
26 | | #include "llvm/Support/SourceMgr.h" |
27 | | #include <cassert> |
28 | | #include <cstdint> |
29 | | #include <ctime> |
30 | | #include <memory> |
31 | | #include <stack> |
32 | | #include <string> |
33 | | #include <system_error> |
34 | | #include <utility> |
35 | | #include <vector> |
36 | | |
37 | | namespace llvm { |
38 | | |
39 | | class MemoryBuffer; |
40 | | class Twine; |
41 | | |
42 | | namespace vfs { |
43 | | |
44 | | /// The result of a \p status operation. |
45 | | class Status { |
46 | | std::string Name; |
47 | | llvm::sys::fs::UniqueID UID; |
48 | | llvm::sys::TimePoint<> MTime; |
49 | | uint32_t User; |
50 | | uint32_t Group; |
51 | | uint64_t Size; |
52 | | llvm::sys::fs::file_type Type = llvm::sys::fs::file_type::status_error; |
53 | | llvm::sys::fs::perms Perms; |
54 | | |
55 | | public: |
56 | | // FIXME: remove when files support multiple names |
57 | | bool IsVFSMapped = false; |
58 | | |
59 | | Status() = default; |
60 | | Status(const llvm::sys::fs::file_status &Status); |
61 | | Status(const Twine &Name, llvm::sys::fs::UniqueID UID, |
62 | | llvm::sys::TimePoint<> MTime, uint32_t User, uint32_t Group, |
63 | | uint64_t Size, llvm::sys::fs::file_type Type, |
64 | | llvm::sys::fs::perms Perms); |
65 | | |
66 | | /// Get a copy of a Status with a different name. |
67 | | static Status copyWithNewName(const Status &In, const Twine &NewName); |
68 | | static Status copyWithNewName(const llvm::sys::fs::file_status &In, |
69 | | const Twine &NewName); |
70 | | |
71 | | /// Returns the name that should be used for this file or directory. |
72 | 0 | StringRef getName() const { return Name; } |
73 | | |
74 | | /// @name Status interface from llvm::sys::fs |
75 | | /// @{ |
76 | 0 | llvm::sys::fs::file_type getType() const { return Type; } |
77 | 0 | llvm::sys::fs::perms getPermissions() const { return Perms; } |
78 | 0 | llvm::sys::TimePoint<> getLastModificationTime() const { return MTime; } |
79 | 0 | llvm::sys::fs::UniqueID getUniqueID() const { return UID; } |
80 | 0 | uint32_t getUser() const { return User; } |
81 | 0 | uint32_t getGroup() const { return Group; } |
82 | 0 | uint64_t getSize() const { return Size; } |
83 | | /// @} |
84 | | /// @name Status queries |
85 | | /// These are static queries in llvm::sys::fs. |
86 | | /// @{ |
87 | | bool equivalent(const Status &Other) const; |
88 | | bool isDirectory() const; |
89 | | bool isRegularFile() const; |
90 | | bool isOther() const; |
91 | | bool isSymlink() const; |
92 | | bool isStatusKnown() const; |
93 | | bool exists() const; |
94 | | /// @} |
95 | | }; |
96 | | |
97 | | /// Represents an open file. |
98 | | class File { |
99 | | public: |
100 | | /// Destroy the file after closing it (if open). |
101 | | /// Sub-classes should generally call close() inside their destructors. We |
102 | | /// cannot do that from the base class, since close is virtual. |
103 | | virtual ~File(); |
104 | | |
105 | | /// Get the status of the file. |
106 | | virtual llvm::ErrorOr<Status> status() = 0; |
107 | | |
108 | | /// Get the name of the file |
109 | 0 | virtual llvm::ErrorOr<std::string> getName() { |
110 | 0 | if (auto Status = status()) |
111 | 0 | return Status->getName().str(); |
112 | 0 | else |
113 | 0 | return Status.getError(); |
114 | 0 | } |
115 | | |
116 | | /// Get the contents of the file as a \p MemoryBuffer. |
117 | | virtual llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> |
118 | | getBuffer(const Twine &Name, int64_t FileSize = -1, |
119 | | bool RequiresNullTerminator = true, bool IsVolatile = false) = 0; |
120 | | |
121 | | /// Closes the file. |
122 | | virtual std::error_code close() = 0; |
123 | | }; |
124 | | |
125 | | /// A member of a directory, yielded by a directory_iterator. |
126 | | /// Only information available on most platforms is included. |
127 | | class directory_entry { |
128 | | std::string Path; |
129 | | llvm::sys::fs::file_type Type = llvm::sys::fs::file_type::type_unknown; |
130 | | |
131 | | public: |
132 | 0 | directory_entry() = default; |
133 | | directory_entry(std::string Path, llvm::sys::fs::file_type Type) |
134 | 0 | : Path(std::move(Path)), Type(Type) {} |
135 | | |
136 | 0 | llvm::StringRef path() const { return Path; } |
137 | 0 | llvm::sys::fs::file_type type() const { return Type; } |
138 | | }; |
139 | | |
140 | | namespace detail { |
141 | | |
142 | | /// An interface for virtual file systems to provide an iterator over the |
143 | | /// (non-recursive) contents of a directory. |
144 | | struct DirIterImpl { |
145 | | virtual ~DirIterImpl(); |
146 | | |
147 | | /// Sets \c CurrentEntry to the next entry in the directory on success, |
148 | | /// to directory_entry() at end, or returns a system-defined \c error_code. |
149 | | virtual std::error_code increment() = 0; |
150 | | |
151 | | directory_entry CurrentEntry; |
152 | | }; |
153 | | |
154 | | } // namespace detail |
155 | | |
156 | | /// An input iterator over the entries in a virtual path, similar to |
157 | | /// llvm::sys::fs::directory_iterator. |
158 | | class directory_iterator { |
159 | | std::shared_ptr<detail::DirIterImpl> Impl; // Input iterator semantics on copy |
160 | | |
161 | | public: |
162 | | directory_iterator(std::shared_ptr<detail::DirIterImpl> I) |
163 | 0 | : Impl(std::move(I)) { |
164 | 0 | assert(Impl.get() != nullptr && "requires non-null implementation"); |
165 | 0 | if (Impl->CurrentEntry.path().empty()) |
166 | 0 | Impl.reset(); // Normalize the end iterator to Impl == nullptr. |
167 | 0 | } |
168 | | |
169 | | /// Construct an 'end' iterator. |
170 | 0 | directory_iterator() = default; |
171 | | |
172 | | /// Equivalent to operator++, with an error code. |
173 | 0 | directory_iterator &increment(std::error_code &EC) { |
174 | 0 | assert(Impl && "attempting to increment past end"); |
175 | 0 | EC = Impl->increment(); |
176 | 0 | if (Impl->CurrentEntry.path().empty()) |
177 | 0 | Impl.reset(); // Normalize the end iterator to Impl == nullptr. |
178 | 0 | return *this; |
179 | 0 | } |
180 | | |
181 | 0 | const directory_entry &operator*() const { return Impl->CurrentEntry; } |
182 | 0 | const directory_entry *operator->() const { return &Impl->CurrentEntry; } |
183 | | |
184 | 0 | bool operator==(const directory_iterator &RHS) const { |
185 | 0 | if (Impl && RHS.Impl) |
186 | 0 | return Impl->CurrentEntry.path() == RHS.Impl->CurrentEntry.path(); |
187 | 0 | return !Impl && !RHS.Impl; |
188 | 0 | } |
189 | 0 | bool operator!=(const directory_iterator &RHS) const { |
190 | 0 | return !(*this == RHS); |
191 | 0 | } |
192 | | }; |
193 | | |
194 | | class FileSystem; |
195 | | |
196 | | namespace detail { |
197 | | |
198 | | /// Keeps state for the recursive_directory_iterator. |
199 | | struct RecDirIterState { |
200 | | std::stack<directory_iterator, std::vector<directory_iterator>> Stack; |
201 | | bool HasNoPushRequest = false; |
202 | | }; |
203 | | |
204 | | } // end namespace detail |
205 | | |
206 | | /// An input iterator over the recursive contents of a virtual path, |
207 | | /// similar to llvm::sys::fs::recursive_directory_iterator. |
208 | | class recursive_directory_iterator { |
209 | | FileSystem *FS; |
210 | | std::shared_ptr<detail::RecDirIterState> |
211 | | State; // Input iterator semantics on copy. |
212 | | |
213 | | public: |
214 | | recursive_directory_iterator(FileSystem &FS, const Twine &Path, |
215 | | std::error_code &EC); |
216 | | |
217 | | /// Construct an 'end' iterator. |
218 | | recursive_directory_iterator() = default; |
219 | | |
220 | | /// Equivalent to operator++, with an error code. |
221 | | recursive_directory_iterator &increment(std::error_code &EC); |
222 | | |
223 | 0 | const directory_entry &operator*() const { return *State->Stack.top(); } |
224 | 0 | const directory_entry *operator->() const { return &*State->Stack.top(); } |
225 | | |
226 | 0 | bool operator==(const recursive_directory_iterator &Other) const { |
227 | 0 | return State == Other.State; // identity |
228 | 0 | } |
229 | 0 | bool operator!=(const recursive_directory_iterator &RHS) const { |
230 | 0 | return !(*this == RHS); |
231 | 0 | } |
232 | | |
233 | | /// Gets the current level. Starting path is at level 0. |
234 | 0 | int level() const { |
235 | 0 | assert(!State->Stack.empty() && |
236 | 0 | "Cannot get level without any iteration state"); |
237 | 0 | return State->Stack.size() - 1; |
238 | 0 | } |
239 | | |
240 | 0 | void no_push() { State->HasNoPushRequest = true; } |
241 | | }; |
242 | | |
243 | | /// The virtual file system interface. |
244 | | class FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> { |
245 | | public: |
246 | | virtual ~FileSystem(); |
247 | | |
248 | | /// Get the status of the entry at \p Path, if one exists. |
249 | | virtual llvm::ErrorOr<Status> status(const Twine &Path) = 0; |
250 | | |
251 | | /// Get a \p File object for the file at \p Path, if one exists. |
252 | | virtual llvm::ErrorOr<std::unique_ptr<File>> |
253 | | openFileForRead(const Twine &Path) = 0; |
254 | | |
255 | | /// This is a convenience method that opens a file, gets its content and then |
256 | | /// closes the file. |
257 | | llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> |
258 | | getBufferForFile(const Twine &Name, int64_t FileSize = -1, |
259 | | bool RequiresNullTerminator = true, bool IsVolatile = false); |
260 | | |
261 | | /// Get a directory_iterator for \p Dir. |
262 | | /// \note The 'end' iterator is directory_iterator(). |
263 | | virtual directory_iterator dir_begin(const Twine &Dir, |
264 | | std::error_code &EC) = 0; |
265 | | |
266 | | /// Set the working directory. This will affect all following operations on |
267 | | /// this file system and may propagate down for nested file systems. |
268 | | virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) = 0; |
269 | | |
270 | | /// Get the working directory of this file system. |
271 | | virtual llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const = 0; |
272 | | |
273 | | /// Gets real path of \p Path e.g. collapse all . and .. patterns, resolve |
274 | | /// symlinks. For real file system, this uses `llvm::sys::fs::real_path`. |
275 | | /// This returns errc::operation_not_permitted if not implemented by subclass. |
276 | | virtual std::error_code getRealPath(const Twine &Path, |
277 | | SmallVectorImpl<char> &Output) const; |
278 | | |
279 | | /// Check whether a file exists. Provided for convenience. |
280 | | bool exists(const Twine &Path); |
281 | | |
282 | | /// Is the file mounted on a local filesystem? |
283 | | virtual std::error_code isLocal(const Twine &Path, bool &Result); |
284 | | |
285 | | /// Make \a Path an absolute path. |
286 | | /// |
287 | | /// Makes \a Path absolute using the current directory if it is not already. |
288 | | /// An empty \a Path will result in the current directory. |
289 | | /// |
290 | | /// /absolute/path => /absolute/path |
291 | | /// relative/../path => <current-directory>/relative/../path |
292 | | /// |
293 | | /// \param Path A path that is modified to be an absolute path. |
294 | | /// \returns success if \a path has been made absolute, otherwise a |
295 | | /// platform-specific error_code. |
296 | | virtual std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const; |
297 | | }; |
298 | | |
299 | | /// Gets an \p vfs::FileSystem for the 'real' file system, as seen by |
300 | | /// the operating system. |
301 | | /// The working directory is linked to the process's working directory. |
302 | | /// (This is usually thread-hostile). |
303 | | IntrusiveRefCntPtr<FileSystem> getRealFileSystem(); |
304 | | |
305 | | /// Create an \p vfs::FileSystem for the 'real' file system, as seen by |
306 | | /// the operating system. |
307 | | /// It has its own working directory, independent of (but initially equal to) |
308 | | /// that of the process. |
309 | | std::unique_ptr<FileSystem> createPhysicalFileSystem(); |
310 | | |
311 | | /// A file system that allows overlaying one \p AbstractFileSystem on top |
312 | | /// of another. |
313 | | /// |
314 | | /// Consists of a stack of >=1 \p FileSystem objects, which are treated as being |
315 | | /// one merged file system. When there is a directory that exists in more than |
316 | | /// one file system, the \p OverlayFileSystem contains a directory containing |
317 | | /// the union of their contents. The attributes (permissions, etc.) of the |
318 | | /// top-most (most recently added) directory are used. When there is a file |
319 | | /// that exists in more than one file system, the file in the top-most file |
320 | | /// system overrides the other(s). |
321 | | class OverlayFileSystem : public FileSystem { |
322 | | using FileSystemList = SmallVector<IntrusiveRefCntPtr<FileSystem>, 1>; |
323 | | |
324 | | /// The stack of file systems, implemented as a list in order of |
325 | | /// their addition. |
326 | | FileSystemList FSList; |
327 | | |
328 | | public: |
329 | | OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> Base); |
330 | | |
331 | | /// Pushes a file system on top of the stack. |
332 | | void pushOverlay(IntrusiveRefCntPtr<FileSystem> FS); |
333 | | |
334 | | llvm::ErrorOr<Status> status(const Twine &Path) override; |
335 | | llvm::ErrorOr<std::unique_ptr<File>> |
336 | | openFileForRead(const Twine &Path) override; |
337 | | directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override; |
338 | | llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override; |
339 | | std::error_code setCurrentWorkingDirectory(const Twine &Path) override; |
340 | | std::error_code isLocal(const Twine &Path, bool &Result) override; |
341 | | std::error_code getRealPath(const Twine &Path, |
342 | | SmallVectorImpl<char> &Output) const override; |
343 | | |
344 | | using iterator = FileSystemList::reverse_iterator; |
345 | | using const_iterator = FileSystemList::const_reverse_iterator; |
346 | | using reverse_iterator = FileSystemList::iterator; |
347 | | using const_reverse_iterator = FileSystemList::const_iterator; |
348 | | |
349 | | /// Get an iterator pointing to the most recently added file system. |
350 | 0 | iterator overlays_begin() { return FSList.rbegin(); } |
351 | 0 | const_iterator overlays_begin() const { return FSList.rbegin(); } |
352 | | |
353 | | /// Get an iterator pointing one-past the least recently added file system. |
354 | 0 | iterator overlays_end() { return FSList.rend(); } |
355 | 0 | const_iterator overlays_end() const { return FSList.rend(); } |
356 | | |
357 | | /// Get an iterator pointing to the least recently added file system. |
358 | 0 | reverse_iterator overlays_rbegin() { return FSList.begin(); } |
359 | 0 | const_reverse_iterator overlays_rbegin() const { return FSList.begin(); } |
360 | | |
361 | | /// Get an iterator pointing one-past the most recently added file system. |
362 | 0 | reverse_iterator overlays_rend() { return FSList.end(); } |
363 | 0 | const_reverse_iterator overlays_rend() const { return FSList.end(); } |
364 | | }; |
365 | | |
366 | | /// By default, this delegates all calls to the underlying file system. This |
367 | | /// is useful when derived file systems want to override some calls and still |
368 | | /// proxy other calls. |
369 | | class ProxyFileSystem : public FileSystem { |
370 | | public: |
371 | | explicit ProxyFileSystem(IntrusiveRefCntPtr<FileSystem> FS) |
372 | 0 | : FS(std::move(FS)) {} |
373 | | |
374 | 0 | llvm::ErrorOr<Status> status(const Twine &Path) override { |
375 | 0 | return FS->status(Path); |
376 | 0 | } |
377 | | llvm::ErrorOr<std::unique_ptr<File>> |
378 | 0 | openFileForRead(const Twine &Path) override { |
379 | 0 | return FS->openFileForRead(Path); |
380 | 0 | } |
381 | 0 | directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override { |
382 | 0 | return FS->dir_begin(Dir, EC); |
383 | 0 | } |
384 | 0 | llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override { |
385 | 0 | return FS->getCurrentWorkingDirectory(); |
386 | 0 | } |
387 | 0 | std::error_code setCurrentWorkingDirectory(const Twine &Path) override { |
388 | 0 | return FS->setCurrentWorkingDirectory(Path); |
389 | 0 | } |
390 | | std::error_code getRealPath(const Twine &Path, |
391 | 0 | SmallVectorImpl<char> &Output) const override { |
392 | 0 | return FS->getRealPath(Path, Output); |
393 | 0 | } |
394 | 0 | std::error_code isLocal(const Twine &Path, bool &Result) override { |
395 | 0 | return FS->isLocal(Path, Result); |
396 | 0 | } |
397 | | |
398 | | protected: |
399 | 0 | FileSystem &getUnderlyingFS() { return *FS; } |
400 | | |
401 | | private: |
402 | | IntrusiveRefCntPtr<FileSystem> FS; |
403 | | |
404 | | virtual void anchor(); |
405 | | }; |
406 | | |
407 | | namespace detail { |
408 | | |
409 | | class InMemoryDirectory; |
410 | | class InMemoryFile; |
411 | | |
412 | | } // namespace detail |
413 | | |
414 | | /// An in-memory file system. |
415 | | class InMemoryFileSystem : public FileSystem { |
416 | | std::unique_ptr<detail::InMemoryDirectory> Root; |
417 | | std::string WorkingDirectory; |
418 | | bool UseNormalizedPaths = true; |
419 | | |
420 | | /// If HardLinkTarget is non-null, a hardlink is created to the To path which |
421 | | /// must be a file. If it is null then it adds the file as the public addFile. |
422 | | bool addFile(const Twine &Path, time_t ModificationTime, |
423 | | std::unique_ptr<llvm::MemoryBuffer> Buffer, |
424 | | Optional<uint32_t> User, Optional<uint32_t> Group, |
425 | | Optional<llvm::sys::fs::file_type> Type, |
426 | | Optional<llvm::sys::fs::perms> Perms, |
427 | | const detail::InMemoryFile *HardLinkTarget); |
428 | | |
429 | | public: |
430 | | explicit InMemoryFileSystem(bool UseNormalizedPaths = true); |
431 | | ~InMemoryFileSystem() override; |
432 | | |
433 | | /// Add a file containing a buffer or a directory to the VFS with a |
434 | | /// path. The VFS owns the buffer. If present, User, Group, Type |
435 | | /// and Perms apply to the newly-created file or directory. |
436 | | /// \return true if the file or directory was successfully added, |
437 | | /// false if the file or directory already exists in the file system with |
438 | | /// different contents. |
439 | | bool addFile(const Twine &Path, time_t ModificationTime, |
440 | | std::unique_ptr<llvm::MemoryBuffer> Buffer, |
441 | | Optional<uint32_t> User = None, Optional<uint32_t> Group = None, |
442 | | Optional<llvm::sys::fs::file_type> Type = None, |
443 | | Optional<llvm::sys::fs::perms> Perms = None); |
444 | | |
445 | | /// Add a hard link to a file. |
446 | | /// Here hard links are not intended to be fully equivalent to the classical |
447 | | /// filesystem. Both the hard link and the file share the same buffer and |
448 | | /// status (and thus have the same UniqueID). Because of this there is no way |
449 | | /// to distinguish between the link and the file after the link has been |
450 | | /// added. |
451 | | /// |
452 | | /// The To path must be an existing file or a hardlink. The From file must not |
453 | | /// have been added before. The To Path must not be a directory. The From Node |
454 | | /// is added as a hard link which points to the resolved file of To Node. |
455 | | /// \return true if the above condition is satisfied and hardlink was |
456 | | /// successfully created, false otherwise. |
457 | | bool addHardLink(const Twine &From, const Twine &To); |
458 | | |
459 | | /// Add a buffer to the VFS with a path. The VFS does not own the buffer. |
460 | | /// If present, User, Group, Type and Perms apply to the newly-created file |
461 | | /// or directory. |
462 | | /// \return true if the file or directory was successfully added, |
463 | | /// false if the file or directory already exists in the file system with |
464 | | /// different contents. |
465 | | bool addFileNoOwn(const Twine &Path, time_t ModificationTime, |
466 | | llvm::MemoryBuffer *Buffer, Optional<uint32_t> User = None, |
467 | | Optional<uint32_t> Group = None, |
468 | | Optional<llvm::sys::fs::file_type> Type = None, |
469 | | Optional<llvm::sys::fs::perms> Perms = None); |
470 | | |
471 | | std::string toString() const; |
472 | | |
473 | | /// Return true if this file system normalizes . and .. in paths. |
474 | 0 | bool useNormalizedPaths() const { return UseNormalizedPaths; } |
475 | | |
476 | | llvm::ErrorOr<Status> status(const Twine &Path) override; |
477 | | llvm::ErrorOr<std::unique_ptr<File>> |
478 | | openFileForRead(const Twine &Path) override; |
479 | | directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override; |
480 | | |
481 | 0 | llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override { |
482 | 0 | return WorkingDirectory; |
483 | 0 | } |
484 | | /// Canonicalizes \p Path by combining with the current working |
485 | | /// directory and normalizing the path (e.g. remove dots). If the current |
486 | | /// working directory is not set, this returns errc::operation_not_permitted. |
487 | | /// |
488 | | /// This doesn't resolve symlinks as they are not supported in in-memory file |
489 | | /// system. |
490 | | std::error_code getRealPath(const Twine &Path, |
491 | | SmallVectorImpl<char> &Output) const override; |
492 | | std::error_code isLocal(const Twine &Path, bool &Result) override; |
493 | | std::error_code setCurrentWorkingDirectory(const Twine &Path) override; |
494 | | }; |
495 | | |
496 | | /// Get a globally unique ID for a virtual file or directory. |
497 | | llvm::sys::fs::UniqueID getNextVirtualUniqueID(); |
498 | | |
499 | | /// Gets a \p FileSystem for a virtual file system described in YAML |
500 | | /// format. |
501 | | IntrusiveRefCntPtr<FileSystem> |
502 | | getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer, |
503 | | llvm::SourceMgr::DiagHandlerTy DiagHandler, |
504 | | StringRef YAMLFilePath, void *DiagContext = nullptr, |
505 | | IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem()); |
506 | | |
507 | | struct YAMLVFSEntry { |
508 | | template <typename T1, typename T2> |
509 | | YAMLVFSEntry(T1 &&VPath, T2 &&RPath, bool IsDirectory = false) |
510 | | : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)), |
511 | 0 | IsDirectory(IsDirectory) {} Unexecuted instantiation: _ZN4llvm3vfs12YAMLVFSEntryC2IPKcNS_9StringRefEEEOT_OT0_b Unexecuted instantiation: _ZN4llvm3vfs12YAMLVFSEntryC2IRNS_9StringRefES4_EEOT_OT0_b |
512 | | std::string VPath; |
513 | | std::string RPath; |
514 | | bool IsDirectory = false; |
515 | | }; |
516 | | |
517 | | class VFSFromYamlDirIterImpl; |
518 | | class RedirectingFileSystemParser; |
519 | | |
520 | | /// A virtual file system parsed from a YAML file. |
521 | | /// |
522 | | /// Currently, this class allows creating virtual directories and mapping |
523 | | /// virtual file paths to existing external files, available in \c ExternalFS. |
524 | | /// |
525 | | /// The basic structure of the parsed file is: |
526 | | /// \verbatim |
527 | | /// { |
528 | | /// 'version': <version number>, |
529 | | /// <optional configuration> |
530 | | /// 'roots': [ |
531 | | /// <directory entries> |
532 | | /// ] |
533 | | /// } |
534 | | /// \endverbatim |
535 | | /// |
536 | | /// All configuration options are optional. |
537 | | /// 'case-sensitive': <boolean, default=(true for Posix, false for Windows)> |
538 | | /// 'use-external-names': <boolean, default=true> |
539 | | /// 'overlay-relative': <boolean, default=false> |
540 | | /// 'fallthrough': <boolean, default=true> |
541 | | /// |
542 | | /// Virtual directories are represented as |
543 | | /// \verbatim |
544 | | /// { |
545 | | /// 'type': 'directory', |
546 | | /// 'name': <string>, |
547 | | /// 'contents': [ <file or directory entries> ] |
548 | | /// } |
549 | | /// \endverbatim |
550 | | /// |
551 | | /// The default attributes for virtual directories are: |
552 | | /// \verbatim |
553 | | /// MTime = now() when created |
554 | | /// Perms = 0777 |
555 | | /// User = Group = 0 |
556 | | /// Size = 0 |
557 | | /// UniqueID = unspecified unique value |
558 | | /// \endverbatim |
559 | | /// |
560 | | /// Re-mapped files are represented as |
561 | | /// \verbatim |
562 | | /// { |
563 | | /// 'type': 'file', |
564 | | /// 'name': <string>, |
565 | | /// 'use-external-name': <boolean> # Optional |
566 | | /// 'external-contents': <path to external file> |
567 | | /// } |
568 | | /// \endverbatim |
569 | | /// |
570 | | /// and inherit their attributes from the external contents. |
571 | | /// |
572 | | /// In both cases, the 'name' field may contain multiple path components (e.g. |
573 | | /// /path/to/file). However, any directory that contains more than one child |
574 | | /// must be uniquely represented by a directory entry. |
575 | | class RedirectingFileSystem : public vfs::FileSystem { |
576 | | public: |
577 | | enum EntryKind { EK_Directory, EK_File }; |
578 | | |
579 | | /// A single file or directory in the VFS. |
580 | | class Entry { |
581 | | EntryKind Kind; |
582 | | std::string Name; |
583 | | |
584 | | public: |
585 | 0 | Entry(EntryKind K, StringRef Name) : Kind(K), Name(Name) {} |
586 | 0 | virtual ~Entry() = default; |
587 | | |
588 | 0 | StringRef getName() const { return Name; } |
589 | 0 | EntryKind getKind() const { return Kind; } |
590 | | }; |
591 | | |
592 | | class RedirectingDirectoryEntry : public Entry { |
593 | | std::vector<std::unique_ptr<Entry>> Contents; |
594 | | Status S; |
595 | | |
596 | | public: |
597 | | RedirectingDirectoryEntry(StringRef Name, |
598 | | std::vector<std::unique_ptr<Entry>> Contents, |
599 | | Status S) |
600 | | : Entry(EK_Directory, Name), Contents(std::move(Contents)), |
601 | 0 | S(std::move(S)) {} |
602 | | RedirectingDirectoryEntry(StringRef Name, Status S) |
603 | 0 | : Entry(EK_Directory, Name), S(std::move(S)) {} |
604 | | |
605 | 0 | Status getStatus() { return S; } |
606 | | |
607 | 0 | void addContent(std::unique_ptr<Entry> Content) { |
608 | 0 | Contents.push_back(std::move(Content)); |
609 | 0 | } |
610 | | |
611 | 0 | Entry *getLastContent() const { return Contents.back().get(); } |
612 | | |
613 | | using iterator = decltype(Contents)::iterator; |
614 | | |
615 | 0 | iterator contents_begin() { return Contents.begin(); } |
616 | 0 | iterator contents_end() { return Contents.end(); } |
617 | | |
618 | 0 | static bool classof(const Entry *E) { return E->getKind() == EK_Directory; } |
619 | | }; |
620 | | |
621 | | class RedirectingFileEntry : public Entry { |
622 | | public: |
623 | | enum NameKind { NK_NotSet, NK_External, NK_Virtual }; |
624 | | |
625 | | private: |
626 | | std::string ExternalContentsPath; |
627 | | NameKind UseName; |
628 | | |
629 | | public: |
630 | | RedirectingFileEntry(StringRef Name, StringRef ExternalContentsPath, |
631 | | NameKind UseName) |
632 | | : Entry(EK_File, Name), ExternalContentsPath(ExternalContentsPath), |
633 | 0 | UseName(UseName) {} |
634 | | |
635 | 0 | StringRef getExternalContentsPath() const { return ExternalContentsPath; } |
636 | | |
637 | | /// whether to use the external path as the name for this file. |
638 | 0 | bool useExternalName(bool GlobalUseExternalName) const { |
639 | 0 | return UseName == NK_NotSet ? GlobalUseExternalName |
640 | 0 | : (UseName == NK_External); |
641 | 0 | } |
642 | | |
643 | 0 | NameKind getUseName() const { return UseName; } |
644 | | |
645 | 0 | static bool classof(const Entry *E) { return E->getKind() == EK_File; } |
646 | | }; |
647 | | |
648 | | private: |
649 | | friend class VFSFromYamlDirIterImpl; |
650 | | friend class RedirectingFileSystemParser; |
651 | | |
652 | 0 | bool shouldUseExternalFS() const { |
653 | 0 | return ExternalFSValidWD && IsFallthrough; |
654 | 0 | } |
655 | | |
656 | | // In a RedirectingFileSystem, keys can be specified in Posix or Windows |
657 | | // style (or even a mixture of both), so this comparison helper allows |
658 | | // slashes (representing a root) to match backslashes (and vice versa). Note |
659 | | // that, other than the root, path components should not contain slashes or |
660 | | // backslashes. |
661 | 0 | bool pathComponentMatches(llvm::StringRef lhs, llvm::StringRef rhs) const { |
662 | 0 | if ((CaseSensitive ? lhs.equals(rhs) : lhs.equals_lower(rhs))) |
663 | 0 | return true; |
664 | 0 | return (lhs == "/" && rhs == "\\") || (lhs == "\\" && rhs == "/"); |
665 | 0 | } |
666 | | |
667 | | /// The root(s) of the virtual file system. |
668 | | std::vector<std::unique_ptr<Entry>> Roots; |
669 | | |
670 | | /// The current working directory of the file system. |
671 | | std::string WorkingDirectory; |
672 | | |
673 | | /// Whether the current working directory is valid for the external FS. |
674 | | bool ExternalFSValidWD = false; |
675 | | |
676 | | /// The file system to use for external references. |
677 | | IntrusiveRefCntPtr<FileSystem> ExternalFS; |
678 | | |
679 | | /// If IsRelativeOverlay is set, this represents the directory |
680 | | /// path that should be prefixed to each 'external-contents' entry |
681 | | /// when reading from YAML files. |
682 | | std::string ExternalContentsPrefixDir; |
683 | | |
684 | | /// @name Configuration |
685 | | /// @{ |
686 | | |
687 | | /// Whether to perform case-sensitive comparisons. |
688 | | /// |
689 | | /// Currently, case-insensitive matching only works correctly with ASCII. |
690 | | bool CaseSensitive = |
691 | | #ifdef _WIN32 |
692 | | false; |
693 | | #else |
694 | | true; |
695 | | #endif |
696 | | |
697 | | /// IsRelativeOverlay marks whether a ExternalContentsPrefixDir path must |
698 | | /// be prefixed in every 'external-contents' when reading from YAML files. |
699 | | bool IsRelativeOverlay = false; |
700 | | |
701 | | /// Whether to use to use the value of 'external-contents' for the |
702 | | /// names of files. This global value is overridable on a per-file basis. |
703 | | bool UseExternalNames = true; |
704 | | |
705 | | /// Whether to attempt a file lookup in external file system after it wasn't |
706 | | /// found in VFS. |
707 | | bool IsFallthrough = true; |
708 | | /// @} |
709 | | |
710 | | RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> ExternalFS); |
711 | | |
712 | | /// Looks up the path <tt>[Start, End)</tt> in \p From, possibly |
713 | | /// recursing into the contents of \p From if it is a directory. |
714 | | ErrorOr<Entry *> lookupPath(llvm::sys::path::const_iterator Start, |
715 | | llvm::sys::path::const_iterator End, |
716 | | Entry *From) const; |
717 | | |
718 | | /// Get the status of a given an \c Entry. |
719 | | ErrorOr<Status> status(const Twine &Path, Entry *E); |
720 | | |
721 | | public: |
722 | | /// Looks up \p Path in \c Roots. |
723 | | ErrorOr<Entry *> lookupPath(const Twine &Path) const; |
724 | | |
725 | | /// Parses \p Buffer, which is expected to be in YAML format and |
726 | | /// returns a virtual file system representing its contents. |
727 | | static RedirectingFileSystem * |
728 | | create(std::unique_ptr<MemoryBuffer> Buffer, |
729 | | SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, |
730 | | void *DiagContext, IntrusiveRefCntPtr<FileSystem> ExternalFS); |
731 | | |
732 | | ErrorOr<Status> status(const Twine &Path) override; |
733 | | ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override; |
734 | | |
735 | | std::error_code getRealPath(const Twine &Path, |
736 | | SmallVectorImpl<char> &Output) const override; |
737 | | |
738 | | llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override; |
739 | | |
740 | | std::error_code setCurrentWorkingDirectory(const Twine &Path) override; |
741 | | |
742 | | std::error_code isLocal(const Twine &Path, bool &Result) override; |
743 | | |
744 | | std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const override; |
745 | | |
746 | | directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override; |
747 | | |
748 | | void setExternalContentsPrefixDir(StringRef PrefixDir); |
749 | | |
750 | | StringRef getExternalContentsPrefixDir() const; |
751 | | |
752 | | void dump(raw_ostream &OS) const; |
753 | | void dumpEntry(raw_ostream &OS, Entry *E, int NumSpaces = 0) const; |
754 | | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
755 | | LLVM_DUMP_METHOD void dump() const; |
756 | | #endif |
757 | | }; |
758 | | |
759 | | /// Collect all pairs of <virtual path, real path> entries from the |
760 | | /// \p YAMLFilePath. This is used by the module dependency collector to forward |
761 | | /// the entries into the reproducer output VFS YAML file. |
762 | | void collectVFSFromYAML( |
763 | | std::unique_ptr<llvm::MemoryBuffer> Buffer, |
764 | | llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, |
765 | | SmallVectorImpl<YAMLVFSEntry> &CollectedEntries, |
766 | | void *DiagContext = nullptr, |
767 | | IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem()); |
768 | | |
769 | | class YAMLVFSWriter { |
770 | | std::vector<YAMLVFSEntry> Mappings; |
771 | | Optional<bool> IsCaseSensitive; |
772 | | Optional<bool> IsOverlayRelative; |
773 | | Optional<bool> UseExternalNames; |
774 | | std::string OverlayDir; |
775 | | |
776 | | void addEntry(StringRef VirtualPath, StringRef RealPath, bool IsDirectory); |
777 | | |
778 | | public: |
779 | | YAMLVFSWriter() = default; |
780 | | |
781 | | void addFileMapping(StringRef VirtualPath, StringRef RealPath); |
782 | | void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath); |
783 | | |
784 | 0 | void setCaseSensitivity(bool CaseSensitive) { |
785 | 0 | IsCaseSensitive = CaseSensitive; |
786 | 0 | } |
787 | | |
788 | 0 | void setUseExternalNames(bool UseExtNames) { UseExternalNames = UseExtNames; } |
789 | | |
790 | 0 | void setOverlayDir(StringRef OverlayDirectory) { |
791 | 0 | IsOverlayRelative = true; |
792 | 0 | OverlayDir.assign(OverlayDirectory.str()); |
793 | 0 | } |
794 | | |
795 | 0 | const std::vector<YAMLVFSEntry> &getMappings() const { return Mappings; } |
796 | | |
797 | | void write(llvm::raw_ostream &OS); |
798 | | }; |
799 | | |
800 | | } // namespace vfs |
801 | | } // namespace llvm |
802 | | |
803 | | #endif // LLVM_SUPPORT_VIRTUALFILESYSTEM_H |