Bug Summary

File:lib/Support/VirtualFileSystem.cpp
Warning:line 1397, column 14
The left operand of '==' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name VirtualFileSystem.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-9/lib/clang/9.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Support -I /build/llvm-toolchain-snapshot-9~svn362543/lib/Support -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Support -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp -faddrsig
1//===- VirtualFileSystem.cpp - Virtual File System Layer ------------------===//
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// This file implements the VirtualFileSystem interface.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Support/VirtualFileSystem.h"
14#include "llvm/ADT/ArrayRef.h"
15#include "llvm/ADT/DenseMap.h"
16#include "llvm/ADT/IntrusiveRefCntPtr.h"
17#include "llvm/ADT/None.h"
18#include "llvm/ADT/Optional.h"
19#include "llvm/ADT/STLExtras.h"
20#include "llvm/ADT/SmallString.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/ADT/StringSet.h"
24#include "llvm/ADT/Twine.h"
25#include "llvm/ADT/iterator_range.h"
26#include "llvm/Config/llvm-config.h"
27#include "llvm/Support/Casting.h"
28#include "llvm/Support/Chrono.h"
29#include "llvm/Support/Compiler.h"
30#include "llvm/Support/Debug.h"
31#include "llvm/Support/Errc.h"
32#include "llvm/Support/ErrorHandling.h"
33#include "llvm/Support/ErrorOr.h"
34#include "llvm/Support/FileSystem.h"
35#include "llvm/Support/MemoryBuffer.h"
36#include "llvm/Support/Path.h"
37#include "llvm/Support/Process.h"
38#include "llvm/Support/SMLoc.h"
39#include "llvm/Support/SourceMgr.h"
40#include "llvm/Support/YAMLParser.h"
41#include "llvm/Support/raw_ostream.h"
42#include <algorithm>
43#include <atomic>
44#include <cassert>
45#include <cstdint>
46#include <iterator>
47#include <limits>
48#include <map>
49#include <memory>
50#include <mutex>
51#include <string>
52#include <system_error>
53#include <utility>
54#include <vector>
55
56using namespace llvm;
57using namespace llvm::vfs;
58
59using llvm::sys::fs::file_status;
60using llvm::sys::fs::file_type;
61using llvm::sys::fs::perms;
62using llvm::sys::fs::UniqueID;
63
64Status::Status(const file_status &Status)
65 : UID(Status.getUniqueID()), MTime(Status.getLastModificationTime()),
66 User(Status.getUser()), Group(Status.getGroup()), Size(Status.getSize()),
67 Type(Status.type()), Perms(Status.permissions()) {}
68
69Status::Status(const Twine &Name, UniqueID UID, sys::TimePoint<> MTime,
70 uint32_t User, uint32_t Group, uint64_t Size, file_type Type,
71 perms Perms)
72 : Name(Name.str()), UID(UID), MTime(MTime), User(User), Group(Group),
73 Size(Size), Type(Type), Perms(Perms) {}
74
75Status Status::copyWithNewName(const Status &In, const Twine &NewName) {
76 return Status(NewName, In.getUniqueID(), In.getLastModificationTime(),
77 In.getUser(), In.getGroup(), In.getSize(), In.getType(),
78 In.getPermissions());
79}
80
81Status Status::copyWithNewName(const file_status &In, const Twine &NewName) {
82 return Status(NewName, In.getUniqueID(), In.getLastModificationTime(),
83 In.getUser(), In.getGroup(), In.getSize(), In.type(),
84 In.permissions());
85}
86
87bool Status::equivalent(const Status &Other) const {
88 assert(isStatusKnown() && Other.isStatusKnown())((isStatusKnown() && Other.isStatusKnown()) ? static_cast
<void> (0) : __assert_fail ("isStatusKnown() && Other.isStatusKnown()"
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 88, __PRETTY_FUNCTION__))
;
89 return getUniqueID() == Other.getUniqueID();
90}
91
92bool Status::isDirectory() const { return Type == file_type::directory_file; }
93
94bool Status::isRegularFile() const { return Type == file_type::regular_file; }
95
96bool Status::isOther() const {
97 return exists() && !isRegularFile() && !isDirectory() && !isSymlink();
98}
99
100bool Status::isSymlink() const { return Type == file_type::symlink_file; }
101
102bool Status::isStatusKnown() const { return Type != file_type::status_error; }
103
104bool Status::exists() const {
105 return isStatusKnown() && Type != file_type::file_not_found;
106}
107
108File::~File() = default;
109
110FileSystem::~FileSystem() = default;
111
112ErrorOr<std::unique_ptr<MemoryBuffer>>
113FileSystem::getBufferForFile(const llvm::Twine &Name, int64_t FileSize,
114 bool RequiresNullTerminator, bool IsVolatile) {
115 auto F = openFileForRead(Name);
116 if (!F)
117 return F.getError();
118
119 return (*F)->getBuffer(Name, FileSize, RequiresNullTerminator, IsVolatile);
120}
121
122std::error_code FileSystem::makeAbsolute(SmallVectorImpl<char> &Path) const {
123 if (llvm::sys::path::is_absolute(Path))
124 return {};
125
126 auto WorkingDir = getCurrentWorkingDirectory();
127 if (!WorkingDir)
128 return WorkingDir.getError();
129
130 llvm::sys::fs::make_absolute(WorkingDir.get(), Path);
131 return {};
132}
133
134std::error_code FileSystem::getRealPath(const Twine &Path,
135 SmallVectorImpl<char> &Output) const {
136 return errc::operation_not_permitted;
137}
138
139std::error_code FileSystem::isLocal(const Twine &Path, bool &Result) {
140 return errc::operation_not_permitted;
141}
142
143bool FileSystem::exists(const Twine &Path) {
144 auto Status = status(Path);
145 return Status && Status->exists();
146}
147
148#ifndef NDEBUG
149static bool isTraversalComponent(StringRef Component) {
150 return Component.equals("..") || Component.equals(".");
151}
152
153static bool pathHasTraversal(StringRef Path) {
154 using namespace llvm::sys;
155
156 for (StringRef Comp : llvm::make_range(path::begin(Path), path::end(Path)))
157 if (isTraversalComponent(Comp))
158 return true;
159 return false;
160}
161#endif
162
163//===-----------------------------------------------------------------------===/
164// RealFileSystem implementation
165//===-----------------------------------------------------------------------===/
166
167namespace {
168
169/// Wrapper around a raw file descriptor.
170class RealFile : public File {
171 friend class RealFileSystem;
172
173 int FD;
174 Status S;
175 std::string RealName;
176
177 RealFile(int FD, StringRef NewName, StringRef NewRealPathName)
178 : FD(FD), S(NewName, {}, {}, {}, {}, {},
179 llvm::sys::fs::file_type::status_error, {}),
180 RealName(NewRealPathName.str()) {
181 assert(FD >= 0 && "Invalid or inactive file descriptor")((FD >= 0 && "Invalid or inactive file descriptor"
) ? static_cast<void> (0) : __assert_fail ("FD >= 0 && \"Invalid or inactive file descriptor\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 181, __PRETTY_FUNCTION__))
;
182 }
183
184public:
185 ~RealFile() override;
186
187 ErrorOr<Status> status() override;
188 ErrorOr<std::string> getName() override;
189 ErrorOr<std::unique_ptr<MemoryBuffer>> getBuffer(const Twine &Name,
190 int64_t FileSize,
191 bool RequiresNullTerminator,
192 bool IsVolatile) override;
193 std::error_code close() override;
194};
195
196} // namespace
197
198RealFile::~RealFile() { close(); }
199
200ErrorOr<Status> RealFile::status() {
201 assert(FD != -1 && "cannot stat closed file")((FD != -1 && "cannot stat closed file") ? static_cast
<void> (0) : __assert_fail ("FD != -1 && \"cannot stat closed file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 201, __PRETTY_FUNCTION__))
;
202 if (!S.isStatusKnown()) {
203 file_status RealStatus;
204 if (std::error_code EC = sys::fs::status(FD, RealStatus))
205 return EC;
206 S = Status::copyWithNewName(RealStatus, S.getName());
207 }
208 return S;
209}
210
211ErrorOr<std::string> RealFile::getName() {
212 return RealName.empty() ? S.getName().str() : RealName;
213}
214
215ErrorOr<std::unique_ptr<MemoryBuffer>>
216RealFile::getBuffer(const Twine &Name, int64_t FileSize,
217 bool RequiresNullTerminator, bool IsVolatile) {
218 assert(FD != -1 && "cannot get buffer for closed file")((FD != -1 && "cannot get buffer for closed file") ? static_cast
<void> (0) : __assert_fail ("FD != -1 && \"cannot get buffer for closed file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 218, __PRETTY_FUNCTION__))
;
219 return MemoryBuffer::getOpenFile(FD, Name, FileSize, RequiresNullTerminator,
220 IsVolatile);
221}
222
223std::error_code RealFile::close() {
224 std::error_code EC = sys::Process::SafelyCloseFileDescriptor(FD);
225 FD = -1;
226 return EC;
227}
228
229namespace {
230
231/// A file system according to your operating system.
232/// This may be linked to the process's working directory, or maintain its own.
233///
234/// Currently, its own working directory is emulated by storing the path and
235/// sending absolute paths to llvm::sys::fs:: functions.
236/// A more principled approach would be to push this down a level, modelling
237/// the working dir as an llvm::sys::fs::WorkingDir or similar.
238/// This would enable the use of openat()-style functions on some platforms.
239class RealFileSystem : public FileSystem {
240public:
241 explicit RealFileSystem(bool LinkCWDToProcess) {
242 if (!LinkCWDToProcess) {
243 SmallString<128> PWD, RealPWD;
244 if (llvm::sys::fs::current_path(PWD))
245 return; // Awful, but nothing to do here.
246 if (llvm::sys::fs::real_path(PWD, RealPWD))
247 WD = {PWD, PWD};
248 else
249 WD = {PWD, RealPWD};
250 }
251 }
252
253 ErrorOr<Status> status(const Twine &Path) override;
254 ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
255 directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
256
257 llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override;
258 std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
259 std::error_code isLocal(const Twine &Path, bool &Result) override;
260 std::error_code getRealPath(const Twine &Path,
261 SmallVectorImpl<char> &Output) const override;
262
263private:
264 // If this FS has its own working dir, use it to make Path absolute.
265 // The returned twine is safe to use as long as both Storage and Path live.
266 Twine adjustPath(const Twine &Path, SmallVectorImpl<char> &Storage) const {
267 if (!WD)
268 return Path;
269 Path.toVector(Storage);
270 sys::fs::make_absolute(WD->Resolved, Storage);
271 return Storage;
272 }
273
274 struct WorkingDirectory {
275 // The current working directory, without symlinks resolved. (echo $PWD).
276 SmallString<128> Specified;
277 // The current working directory, with links resolved. (readlink .).
278 SmallString<128> Resolved;
279 };
280 Optional<WorkingDirectory> WD;
281};
282
283} // namespace
284
285ErrorOr<Status> RealFileSystem::status(const Twine &Path) {
286 SmallString<256> Storage;
287 sys::fs::file_status RealStatus;
288 if (std::error_code EC =
289 sys::fs::status(adjustPath(Path, Storage), RealStatus))
290 return EC;
291 return Status::copyWithNewName(RealStatus, Path);
292}
293
294ErrorOr<std::unique_ptr<File>>
295RealFileSystem::openFileForRead(const Twine &Name) {
296 int FD;
297 SmallString<256> RealName, Storage;
298 if (std::error_code EC = sys::fs::openFileForRead(
299 adjustPath(Name, Storage), FD, sys::fs::OF_None, &RealName))
300 return EC;
301 return std::unique_ptr<File>(new RealFile(FD, Name.str(), RealName.str()));
302}
303
304llvm::ErrorOr<std::string> RealFileSystem::getCurrentWorkingDirectory() const {
305 if (WD)
306 return WD->Specified.str();
307
308 SmallString<128> Dir;
309 if (std::error_code EC = llvm::sys::fs::current_path(Dir))
310 return EC;
311 return Dir.str();
312}
313
314std::error_code RealFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
315 if (!WD)
316 return llvm::sys::fs::set_current_path(Path);
317
318 SmallString<128> Absolute, Resolved, Storage;
319 adjustPath(Path, Storage).toVector(Absolute);
320 bool IsDir;
321 if (auto Err = llvm::sys::fs::is_directory(Absolute, IsDir))
322 return Err;
323 if (!IsDir)
324 return std::make_error_code(std::errc::not_a_directory);
325 if (auto Err = llvm::sys::fs::real_path(Absolute, Resolved))
326 return Err;
327 WD = {Absolute, Resolved};
328 return std::error_code();
329}
330
331std::error_code RealFileSystem::isLocal(const Twine &Path, bool &Result) {
332 SmallString<256> Storage;
333 return llvm::sys::fs::is_local(adjustPath(Path, Storage), Result);
334}
335
336std::error_code
337RealFileSystem::getRealPath(const Twine &Path,
338 SmallVectorImpl<char> &Output) const {
339 SmallString<256> Storage;
340 return llvm::sys::fs::real_path(adjustPath(Path, Storage), Output);
341}
342
343IntrusiveRefCntPtr<FileSystem> vfs::getRealFileSystem() {
344 static IntrusiveRefCntPtr<FileSystem> FS(new RealFileSystem(true));
345 return FS;
346}
347
348std::unique_ptr<FileSystem> vfs::createPhysicalFileSystem() {
349 return llvm::make_unique<RealFileSystem>(false);
350}
351
352namespace {
353
354class RealFSDirIter : public llvm::vfs::detail::DirIterImpl {
355 llvm::sys::fs::directory_iterator Iter;
356
357public:
358 RealFSDirIter(const Twine &Path, std::error_code &EC) : Iter(Path, EC) {
359 if (Iter != llvm::sys::fs::directory_iterator())
360 CurrentEntry = directory_entry(Iter->path(), Iter->type());
361 }
362
363 std::error_code increment() override {
364 std::error_code EC;
365 Iter.increment(EC);
366 CurrentEntry = (Iter == llvm::sys::fs::directory_iterator())
367 ? directory_entry()
368 : directory_entry(Iter->path(), Iter->type());
369 return EC;
370 }
371};
372
373} // namespace
374
375directory_iterator RealFileSystem::dir_begin(const Twine &Dir,
376 std::error_code &EC) {
377 SmallString<128> Storage;
378 return directory_iterator(
379 std::make_shared<RealFSDirIter>(adjustPath(Dir, Storage), EC));
380}
381
382//===-----------------------------------------------------------------------===/
383// OverlayFileSystem implementation
384//===-----------------------------------------------------------------------===/
385
386OverlayFileSystem::OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> BaseFS) {
387 FSList.push_back(std::move(BaseFS));
388}
389
390void OverlayFileSystem::pushOverlay(IntrusiveRefCntPtr<FileSystem> FS) {
391 FSList.push_back(FS);
392 // Synchronize added file systems by duplicating the working directory from
393 // the first one in the list.
394 FS->setCurrentWorkingDirectory(getCurrentWorkingDirectory().get());
395}
396
397ErrorOr<Status> OverlayFileSystem::status(const Twine &Path) {
398 // FIXME: handle symlinks that cross file systems
399 for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
400 ErrorOr<Status> Status = (*I)->status(Path);
401 if (Status || Status.getError() != llvm::errc::no_such_file_or_directory)
402 return Status;
403 }
404 return make_error_code(llvm::errc::no_such_file_or_directory);
405}
406
407ErrorOr<std::unique_ptr<File>>
408OverlayFileSystem::openFileForRead(const llvm::Twine &Path) {
409 // FIXME: handle symlinks that cross file systems
410 for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
411 auto Result = (*I)->openFileForRead(Path);
412 if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
413 return Result;
414 }
415 return make_error_code(llvm::errc::no_such_file_or_directory);
416}
417
418llvm::ErrorOr<std::string>
419OverlayFileSystem::getCurrentWorkingDirectory() const {
420 // All file systems are synchronized, just take the first working directory.
421 return FSList.front()->getCurrentWorkingDirectory();
422}
423
424std::error_code
425OverlayFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
426 for (auto &FS : FSList)
427 if (std::error_code EC = FS->setCurrentWorkingDirectory(Path))
428 return EC;
429 return {};
430}
431
432std::error_code OverlayFileSystem::isLocal(const Twine &Path, bool &Result) {
433 for (auto &FS : FSList)
434 if (FS->exists(Path))
435 return FS->isLocal(Path, Result);
436 return errc::no_such_file_or_directory;
437}
438
439std::error_code
440OverlayFileSystem::getRealPath(const Twine &Path,
441 SmallVectorImpl<char> &Output) const {
442 for (auto &FS : FSList)
443 if (FS->exists(Path))
444 return FS->getRealPath(Path, Output);
445 return errc::no_such_file_or_directory;
446}
447
448llvm::vfs::detail::DirIterImpl::~DirIterImpl() = default;
449
450namespace {
451
452class OverlayFSDirIterImpl : public llvm::vfs::detail::DirIterImpl {
453 OverlayFileSystem &Overlays;
454 std::string Path;
455 OverlayFileSystem::iterator CurrentFS;
456 directory_iterator CurrentDirIter;
457 llvm::StringSet<> SeenNames;
458
459 std::error_code incrementFS() {
460 assert(CurrentFS != Overlays.overlays_end() && "incrementing past end")((CurrentFS != Overlays.overlays_end() && "incrementing past end"
) ? static_cast<void> (0) : __assert_fail ("CurrentFS != Overlays.overlays_end() && \"incrementing past end\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 460, __PRETTY_FUNCTION__))
;
461 ++CurrentFS;
462 for (auto E = Overlays.overlays_end(); CurrentFS != E; ++CurrentFS) {
463 std::error_code EC;
464 CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
465 if (EC && EC != errc::no_such_file_or_directory)
466 return EC;
467 if (CurrentDirIter != directory_iterator())
468 break; // found
469 }
470 return {};
471 }
472
473 std::error_code incrementDirIter(bool IsFirstTime) {
474 assert((IsFirstTime || CurrentDirIter != directory_iterator()) &&(((IsFirstTime || CurrentDirIter != directory_iterator()) &&
"incrementing past end") ? static_cast<void> (0) : __assert_fail
("(IsFirstTime || CurrentDirIter != directory_iterator()) && \"incrementing past end\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 475, __PRETTY_FUNCTION__))
475 "incrementing past end")(((IsFirstTime || CurrentDirIter != directory_iterator()) &&
"incrementing past end") ? static_cast<void> (0) : __assert_fail
("(IsFirstTime || CurrentDirIter != directory_iterator()) && \"incrementing past end\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 475, __PRETTY_FUNCTION__))
;
476 std::error_code EC;
477 if (!IsFirstTime)
478 CurrentDirIter.increment(EC);
479 if (!EC && CurrentDirIter == directory_iterator())
480 EC = incrementFS();
481 return EC;
482 }
483
484 std::error_code incrementImpl(bool IsFirstTime) {
485 while (true) {
486 std::error_code EC = incrementDirIter(IsFirstTime);
487 if (EC || CurrentDirIter == directory_iterator()) {
488 CurrentEntry = directory_entry();
489 return EC;
490 }
491 CurrentEntry = *CurrentDirIter;
492 StringRef Name = llvm::sys::path::filename(CurrentEntry.path());
493 if (SeenNames.insert(Name).second)
494 return EC; // name not seen before
495 }
496 llvm_unreachable("returned above")::llvm::llvm_unreachable_internal("returned above", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 496)
;
497 }
498
499public:
500 OverlayFSDirIterImpl(const Twine &Path, OverlayFileSystem &FS,
501 std::error_code &EC)
502 : Overlays(FS), Path(Path.str()), CurrentFS(Overlays.overlays_begin()) {
503 CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
504 EC = incrementImpl(true);
505 }
506
507 std::error_code increment() override { return incrementImpl(false); }
508};
509
510} // namespace
511
512directory_iterator OverlayFileSystem::dir_begin(const Twine &Dir,
513 std::error_code &EC) {
514 return directory_iterator(
515 std::make_shared<OverlayFSDirIterImpl>(Dir, *this, EC));
516}
517
518void ProxyFileSystem::anchor() {}
519
520namespace llvm {
521namespace vfs {
522
523namespace detail {
524
525enum InMemoryNodeKind { IME_File, IME_Directory, IME_HardLink };
526
527/// The in memory file system is a tree of Nodes. Every node can either be a
528/// file , hardlink or a directory.
529class InMemoryNode {
530 InMemoryNodeKind Kind;
531 std::string FileName;
532
533public:
534 InMemoryNode(llvm::StringRef FileName, InMemoryNodeKind Kind)
535 : Kind(Kind), FileName(llvm::sys::path::filename(FileName)) {}
536 virtual ~InMemoryNode() = default;
537
538 /// Get the filename of this node (the name without the directory part).
539 StringRef getFileName() const { return FileName; }
540 InMemoryNodeKind getKind() const { return Kind; }
541 virtual std::string toString(unsigned Indent) const = 0;
542};
543
544class InMemoryFile : public InMemoryNode {
545 Status Stat;
546 std::unique_ptr<llvm::MemoryBuffer> Buffer;
547
548public:
549 InMemoryFile(Status Stat, std::unique_ptr<llvm::MemoryBuffer> Buffer)
550 : InMemoryNode(Stat.getName(), IME_File), Stat(std::move(Stat)),
551 Buffer(std::move(Buffer)) {}
552
553 /// Return the \p Status for this node. \p RequestedName should be the name
554 /// through which the caller referred to this node. It will override
555 /// \p Status::Name in the return value, to mimic the behavior of \p RealFile.
556 Status getStatus(const Twine &RequestedName) const {
557 return Status::copyWithNewName(Stat, RequestedName);
558 }
559 llvm::MemoryBuffer *getBuffer() const { return Buffer.get(); }
560
561 std::string toString(unsigned Indent) const override {
562 return (std::string(Indent, ' ') + Stat.getName() + "\n").str();
563 }
564
565 static bool classof(const InMemoryNode *N) {
566 return N->getKind() == IME_File;
567 }
568};
569
570namespace {
571
572class InMemoryHardLink : public InMemoryNode {
573 const InMemoryFile &ResolvedFile;
574
575public:
576 InMemoryHardLink(StringRef Path, const InMemoryFile &ResolvedFile)
577 : InMemoryNode(Path, IME_HardLink), ResolvedFile(ResolvedFile) {}
578 const InMemoryFile &getResolvedFile() const { return ResolvedFile; }
579
580 std::string toString(unsigned Indent) const override {
581 return std::string(Indent, ' ') + "HardLink to -> " +
582 ResolvedFile.toString(0);
583 }
584
585 static bool classof(const InMemoryNode *N) {
586 return N->getKind() == IME_HardLink;
587 }
588};
589
590/// Adapt a InMemoryFile for VFS' File interface. The goal is to make
591/// \p InMemoryFileAdaptor mimic as much as possible the behavior of
592/// \p RealFile.
593class InMemoryFileAdaptor : public File {
594 const InMemoryFile &Node;
595 /// The name to use when returning a Status for this file.
596 std::string RequestedName;
597
598public:
599 explicit InMemoryFileAdaptor(const InMemoryFile &Node,
600 std::string RequestedName)
601 : Node(Node), RequestedName(std::move(RequestedName)) {}
602
603 llvm::ErrorOr<Status> status() override {
604 return Node.getStatus(RequestedName);
605 }
606
607 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
608 getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
609 bool IsVolatile) override {
610 llvm::MemoryBuffer *Buf = Node.getBuffer();
611 return llvm::MemoryBuffer::getMemBuffer(
612 Buf->getBuffer(), Buf->getBufferIdentifier(), RequiresNullTerminator);
613 }
614
615 std::error_code close() override { return {}; }
616};
617} // namespace
618
619class InMemoryDirectory : public InMemoryNode {
620 Status Stat;
621 llvm::StringMap<std::unique_ptr<InMemoryNode>> Entries;
622
623public:
624 InMemoryDirectory(Status Stat)
625 : InMemoryNode(Stat.getName(), IME_Directory), Stat(std::move(Stat)) {}
626
627 /// Return the \p Status for this node. \p RequestedName should be the name
628 /// through which the caller referred to this node. It will override
629 /// \p Status::Name in the return value, to mimic the behavior of \p RealFile.
630 Status getStatus(const Twine &RequestedName) const {
631 return Status::copyWithNewName(Stat, RequestedName);
632 }
633 InMemoryNode *getChild(StringRef Name) {
634 auto I = Entries.find(Name);
635 if (I != Entries.end())
636 return I->second.get();
637 return nullptr;
638 }
639
640 InMemoryNode *addChild(StringRef Name, std::unique_ptr<InMemoryNode> Child) {
641 return Entries.insert(make_pair(Name, std::move(Child)))
642 .first->second.get();
643 }
644
645 using const_iterator = decltype(Entries)::const_iterator;
646
647 const_iterator begin() const { return Entries.begin(); }
648 const_iterator end() const { return Entries.end(); }
649
650 std::string toString(unsigned Indent) const override {
651 std::string Result =
652 (std::string(Indent, ' ') + Stat.getName() + "\n").str();
653 for (const auto &Entry : Entries)
654 Result += Entry.second->toString(Indent + 2);
655 return Result;
656 }
657
658 static bool classof(const InMemoryNode *N) {
659 return N->getKind() == IME_Directory;
660 }
661};
662
663namespace {
664Status getNodeStatus(const InMemoryNode *Node, const Twine &RequestedName) {
665 if (auto Dir = dyn_cast<detail::InMemoryDirectory>(Node))
666 return Dir->getStatus(RequestedName);
667 if (auto File = dyn_cast<detail::InMemoryFile>(Node))
668 return File->getStatus(RequestedName);
669 if (auto Link = dyn_cast<detail::InMemoryHardLink>(Node))
670 return Link->getResolvedFile().getStatus(RequestedName);
671 llvm_unreachable("Unknown node type")::llvm::llvm_unreachable_internal("Unknown node type", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 671)
;
672}
673} // namespace
674} // namespace detail
675
676InMemoryFileSystem::InMemoryFileSystem(bool UseNormalizedPaths)
677 : Root(new detail::InMemoryDirectory(
678 Status("", getNextVirtualUniqueID(), llvm::sys::TimePoint<>(), 0, 0,
679 0, llvm::sys::fs::file_type::directory_file,
680 llvm::sys::fs::perms::all_all))),
681 UseNormalizedPaths(UseNormalizedPaths) {}
682
683InMemoryFileSystem::~InMemoryFileSystem() = default;
684
685std::string InMemoryFileSystem::toString() const {
686 return Root->toString(/*Indent=*/0);
687}
688
689bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime,
690 std::unique_ptr<llvm::MemoryBuffer> Buffer,
691 Optional<uint32_t> User,
692 Optional<uint32_t> Group,
693 Optional<llvm::sys::fs::file_type> Type,
694 Optional<llvm::sys::fs::perms> Perms,
695 const detail::InMemoryFile *HardLinkTarget) {
696 SmallString<128> Path;
697 P.toVector(Path);
698
699 // Fix up relative paths. This just prepends the current working directory.
700 std::error_code EC = makeAbsolute(Path);
701 assert(!EC)((!EC) ? static_cast<void> (0) : __assert_fail ("!EC", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 701, __PRETTY_FUNCTION__))
;
702 (void)EC;
703
704 if (useNormalizedPaths())
705 llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
706
707 if (Path.empty())
708 return false;
709
710 detail::InMemoryDirectory *Dir = Root.get();
711 auto I = llvm::sys::path::begin(Path), E = sys::path::end(Path);
712 const auto ResolvedUser = User.getValueOr(0);
713 const auto ResolvedGroup = Group.getValueOr(0);
714 const auto ResolvedType = Type.getValueOr(sys::fs::file_type::regular_file);
715 const auto ResolvedPerms = Perms.getValueOr(sys::fs::all_all);
716 assert(!(HardLinkTarget && Buffer) && "HardLink cannot have a buffer")((!(HardLinkTarget && Buffer) && "HardLink cannot have a buffer"
) ? static_cast<void> (0) : __assert_fail ("!(HardLinkTarget && Buffer) && \"HardLink cannot have a buffer\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 716, __PRETTY_FUNCTION__))
;
717 // Any intermediate directories we create should be accessible by
718 // the owner, even if Perms says otherwise for the final path.
719 const auto NewDirectoryPerms = ResolvedPerms | sys::fs::owner_all;
720 while (true) {
721 StringRef Name = *I;
722 detail::InMemoryNode *Node = Dir->getChild(Name);
723 ++I;
724 if (!Node) {
725 if (I == E) {
726 // End of the path.
727 std::unique_ptr<detail::InMemoryNode> Child;
728 if (HardLinkTarget)
729 Child.reset(new detail::InMemoryHardLink(P.str(), *HardLinkTarget));
730 else {
731 // Create a new file or directory.
732 Status Stat(P.str(), getNextVirtualUniqueID(),
733 llvm::sys::toTimePoint(ModificationTime), ResolvedUser,
734 ResolvedGroup, Buffer->getBufferSize(), ResolvedType,
735 ResolvedPerms);
736 if (ResolvedType == sys::fs::file_type::directory_file) {
737 Child.reset(new detail::InMemoryDirectory(std::move(Stat)));
738 } else {
739 Child.reset(
740 new detail::InMemoryFile(std::move(Stat), std::move(Buffer)));
741 }
742 }
743 Dir->addChild(Name, std::move(Child));
744 return true;
745 }
746
747 // Create a new directory. Use the path up to here.
748 Status Stat(
749 StringRef(Path.str().begin(), Name.end() - Path.str().begin()),
750 getNextVirtualUniqueID(), llvm::sys::toTimePoint(ModificationTime),
751 ResolvedUser, ResolvedGroup, 0, sys::fs::file_type::directory_file,
752 NewDirectoryPerms);
753 Dir = cast<detail::InMemoryDirectory>(Dir->addChild(
754 Name, llvm::make_unique<detail::InMemoryDirectory>(std::move(Stat))));
755 continue;
756 }
757
758 if (auto *NewDir = dyn_cast<detail::InMemoryDirectory>(Node)) {
759 Dir = NewDir;
760 } else {
761 assert((isa<detail::InMemoryFile>(Node) ||(((isa<detail::InMemoryFile>(Node) || isa<detail::InMemoryHardLink
>(Node)) && "Must be either file, hardlink or directory!"
) ? static_cast<void> (0) : __assert_fail ("(isa<detail::InMemoryFile>(Node) || isa<detail::InMemoryHardLink>(Node)) && \"Must be either file, hardlink or directory!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 763, __PRETTY_FUNCTION__))
762 isa<detail::InMemoryHardLink>(Node)) &&(((isa<detail::InMemoryFile>(Node) || isa<detail::InMemoryHardLink
>(Node)) && "Must be either file, hardlink or directory!"
) ? static_cast<void> (0) : __assert_fail ("(isa<detail::InMemoryFile>(Node) || isa<detail::InMemoryHardLink>(Node)) && \"Must be either file, hardlink or directory!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 763, __PRETTY_FUNCTION__))
763 "Must be either file, hardlink or directory!")(((isa<detail::InMemoryFile>(Node) || isa<detail::InMemoryHardLink
>(Node)) && "Must be either file, hardlink or directory!"
) ? static_cast<void> (0) : __assert_fail ("(isa<detail::InMemoryFile>(Node) || isa<detail::InMemoryHardLink>(Node)) && \"Must be either file, hardlink or directory!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 763, __PRETTY_FUNCTION__))
;
764
765 // Trying to insert a directory in place of a file.
766 if (I != E)
767 return false;
768
769 // Return false only if the new file is different from the existing one.
770 if (auto Link = dyn_cast<detail::InMemoryHardLink>(Node)) {
771 return Link->getResolvedFile().getBuffer()->getBuffer() ==
772 Buffer->getBuffer();
773 }
774 return cast<detail::InMemoryFile>(Node)->getBuffer()->getBuffer() ==
775 Buffer->getBuffer();
776 }
777 }
778}
779
780bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime,
781 std::unique_ptr<llvm::MemoryBuffer> Buffer,
782 Optional<uint32_t> User,
783 Optional<uint32_t> Group,
784 Optional<llvm::sys::fs::file_type> Type,
785 Optional<llvm::sys::fs::perms> Perms) {
786 return addFile(P, ModificationTime, std::move(Buffer), User, Group, Type,
787 Perms, /*HardLinkTarget=*/nullptr);
788}
789
790bool InMemoryFileSystem::addFileNoOwn(const Twine &P, time_t ModificationTime,
791 llvm::MemoryBuffer *Buffer,
792 Optional<uint32_t> User,
793 Optional<uint32_t> Group,
794 Optional<llvm::sys::fs::file_type> Type,
795 Optional<llvm::sys::fs::perms> Perms) {
796 return addFile(P, ModificationTime,
797 llvm::MemoryBuffer::getMemBuffer(
798 Buffer->getBuffer(), Buffer->getBufferIdentifier()),
799 std::move(User), std::move(Group), std::move(Type),
800 std::move(Perms));
801}
802
803static ErrorOr<const detail::InMemoryNode *>
804lookupInMemoryNode(const InMemoryFileSystem &FS, detail::InMemoryDirectory *Dir,
805 const Twine &P) {
806 SmallString<128> Path;
807 P.toVector(Path);
808
809 // Fix up relative paths. This just prepends the current working directory.
810 std::error_code EC = FS.makeAbsolute(Path);
811 assert(!EC)((!EC) ? static_cast<void> (0) : __assert_fail ("!EC", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 811, __PRETTY_FUNCTION__))
;
812 (void)EC;
813
814 if (FS.useNormalizedPaths())
815 llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
816
817 if (Path.empty())
818 return Dir;
819
820 auto I = llvm::sys::path::begin(Path), E = llvm::sys::path::end(Path);
821 while (true) {
822 detail::InMemoryNode *Node = Dir->getChild(*I);
823 ++I;
824 if (!Node)
825 return errc::no_such_file_or_directory;
826
827 // Return the file if it's at the end of the path.
828 if (auto File = dyn_cast<detail::InMemoryFile>(Node)) {
829 if (I == E)
830 return File;
831 return errc::no_such_file_or_directory;
832 }
833
834 // If Node is HardLink then return the resolved file.
835 if (auto File = dyn_cast<detail::InMemoryHardLink>(Node)) {
836 if (I == E)
837 return &File->getResolvedFile();
838 return errc::no_such_file_or_directory;
839 }
840 // Traverse directories.
841 Dir = cast<detail::InMemoryDirectory>(Node);
842 if (I == E)
843 return Dir;
844 }
845}
846
847bool InMemoryFileSystem::addHardLink(const Twine &FromPath,
848 const Twine &ToPath) {
849 auto FromNode = lookupInMemoryNode(*this, Root.get(), FromPath);
850 auto ToNode = lookupInMemoryNode(*this, Root.get(), ToPath);
851 // FromPath must not have been added before. ToPath must have been added
852 // before. Resolved ToPath must be a File.
853 if (!ToNode || FromNode || !isa<detail::InMemoryFile>(*ToNode))
854 return false;
855 return this->addFile(FromPath, 0, nullptr, None, None, None, None,
856 cast<detail::InMemoryFile>(*ToNode));
857}
858
859llvm::ErrorOr<Status> InMemoryFileSystem::status(const Twine &Path) {
860 auto Node = lookupInMemoryNode(*this, Root.get(), Path);
861 if (Node)
862 return detail::getNodeStatus(*Node, Path);
863 return Node.getError();
864}
865
866llvm::ErrorOr<std::unique_ptr<File>>
867InMemoryFileSystem::openFileForRead(const Twine &Path) {
868 auto Node = lookupInMemoryNode(*this, Root.get(), Path);
869 if (!Node)
870 return Node.getError();
871
872 // When we have a file provide a heap-allocated wrapper for the memory buffer
873 // to match the ownership semantics for File.
874 if (auto *F = dyn_cast<detail::InMemoryFile>(*Node))
875 return std::unique_ptr<File>(
876 new detail::InMemoryFileAdaptor(*F, Path.str()));
877
878 // FIXME: errc::not_a_file?
879 return make_error_code(llvm::errc::invalid_argument);
880}
881
882namespace {
883
884/// Adaptor from InMemoryDir::iterator to directory_iterator.
885class InMemoryDirIterator : public llvm::vfs::detail::DirIterImpl {
886 detail::InMemoryDirectory::const_iterator I;
887 detail::InMemoryDirectory::const_iterator E;
888 std::string RequestedDirName;
889
890 void setCurrentEntry() {
891 if (I != E) {
892 SmallString<256> Path(RequestedDirName);
893 llvm::sys::path::append(Path, I->second->getFileName());
894 sys::fs::file_type Type;
895 switch (I->second->getKind()) {
896 case detail::IME_File:
897 case detail::IME_HardLink:
898 Type = sys::fs::file_type::regular_file;
899 break;
900 case detail::IME_Directory:
901 Type = sys::fs::file_type::directory_file;
902 break;
903 }
904 CurrentEntry = directory_entry(Path.str(), Type);
905 } else {
906 // When we're at the end, make CurrentEntry invalid and DirIterImpl will
907 // do the rest.
908 CurrentEntry = directory_entry();
909 }
910 }
911
912public:
913 InMemoryDirIterator() = default;
914
915 explicit InMemoryDirIterator(const detail::InMemoryDirectory &Dir,
916 std::string RequestedDirName)
917 : I(Dir.begin()), E(Dir.end()),
918 RequestedDirName(std::move(RequestedDirName)) {
919 setCurrentEntry();
920 }
921
922 std::error_code increment() override {
923 ++I;
924 setCurrentEntry();
925 return {};
926 }
927};
928
929} // namespace
930
931directory_iterator InMemoryFileSystem::dir_begin(const Twine &Dir,
932 std::error_code &EC) {
933 auto Node = lookupInMemoryNode(*this, Root.get(), Dir);
934 if (!Node) {
935 EC = Node.getError();
936 return directory_iterator(std::make_shared<InMemoryDirIterator>());
937 }
938
939 if (auto *DirNode = dyn_cast<detail::InMemoryDirectory>(*Node))
940 return directory_iterator(
941 std::make_shared<InMemoryDirIterator>(*DirNode, Dir.str()));
942
943 EC = make_error_code(llvm::errc::not_a_directory);
944 return directory_iterator(std::make_shared<InMemoryDirIterator>());
945}
946
947std::error_code InMemoryFileSystem::setCurrentWorkingDirectory(const Twine &P) {
948 SmallString<128> Path;
949 P.toVector(Path);
950
951 // Fix up relative paths. This just prepends the current working directory.
952 std::error_code EC = makeAbsolute(Path);
953 assert(!EC)((!EC) ? static_cast<void> (0) : __assert_fail ("!EC", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 953, __PRETTY_FUNCTION__))
;
954 (void)EC;
955
956 if (useNormalizedPaths())
957 llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
958
959 if (!Path.empty())
960 WorkingDirectory = Path.str();
961 return {};
962}
963
964std::error_code
965InMemoryFileSystem::getRealPath(const Twine &Path,
966 SmallVectorImpl<char> &Output) const {
967 auto CWD = getCurrentWorkingDirectory();
968 if (!CWD || CWD->empty())
969 return errc::operation_not_permitted;
970 Path.toVector(Output);
971 if (auto EC = makeAbsolute(Output))
972 return EC;
973 llvm::sys::path::remove_dots(Output, /*remove_dot_dot=*/true);
974 return {};
975}
976
977std::error_code InMemoryFileSystem::isLocal(const Twine &Path, bool &Result) {
978 Result = false;
979 return {};
980}
981
982} // namespace vfs
983} // namespace llvm
984
985//===-----------------------------------------------------------------------===/
986// RedirectingFileSystem implementation
987//===-----------------------------------------------------------------------===/
988
989// FIXME: reuse implementation common with OverlayFSDirIterImpl as these
990// iterators are conceptually similar.
991class llvm::vfs::VFSFromYamlDirIterImpl
992 : public llvm::vfs::detail::DirIterImpl {
993 std::string Dir;
994 RedirectingFileSystem::RedirectingDirectoryEntry::iterator Current, End;
995
996 // To handle 'fallthrough' mode we need to iterate at first through
997 // RedirectingDirectoryEntry and then through ExternalFS. These operations are
998 // done sequentially, we just need to keep a track of what kind of iteration
999 // we are currently performing.
1000
1001 /// Flag telling if we should iterate through ExternalFS or stop at the last
1002 /// RedirectingDirectoryEntry::iterator.
1003 bool IterateExternalFS;
1004 /// Flag telling if we have switched to iterating through ExternalFS.
1005 bool IsExternalFSCurrent = false;
1006 FileSystem &ExternalFS;
1007 directory_iterator ExternalDirIter;
1008 llvm::StringSet<> SeenNames;
1009
1010 /// To combine multiple iterations, different methods are responsible for
1011 /// different iteration steps.
1012 /// @{
1013
1014 /// Responsible for dispatching between RedirectingDirectoryEntry iteration
1015 /// and ExternalFS iteration.
1016 std::error_code incrementImpl(bool IsFirstTime);
1017 /// Responsible for RedirectingDirectoryEntry iteration.
1018 std::error_code incrementContent(bool IsFirstTime);
1019 /// Responsible for ExternalFS iteration.
1020 std::error_code incrementExternal();
1021 /// @}
1022
1023public:
1024 VFSFromYamlDirIterImpl(
1025 const Twine &Path,
1026 RedirectingFileSystem::RedirectingDirectoryEntry::iterator Begin,
1027 RedirectingFileSystem::RedirectingDirectoryEntry::iterator End,
1028 bool IterateExternalFS, FileSystem &ExternalFS, std::error_code &EC);
1029
1030 std::error_code increment() override;
1031};
1032
1033llvm::ErrorOr<std::string>
1034RedirectingFileSystem::getCurrentWorkingDirectory() const {
1035 return ExternalFS->getCurrentWorkingDirectory();
1036}
1037
1038std::error_code
1039RedirectingFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
1040 return ExternalFS->setCurrentWorkingDirectory(Path);
1041}
1042
1043std::error_code RedirectingFileSystem::isLocal(const Twine &Path,
1044 bool &Result) {
1045 return ExternalFS->isLocal(Path, Result);
1046}
1047
1048directory_iterator RedirectingFileSystem::dir_begin(const Twine &Dir,
1049 std::error_code &EC) {
1050 ErrorOr<RedirectingFileSystem::Entry *> E = lookupPath(Dir);
1051 if (!E) {
1052 EC = E.getError();
1053 if (IsFallthrough && EC == errc::no_such_file_or_directory)
1054 return ExternalFS->dir_begin(Dir, EC);
1055 return {};
1056 }
1057 ErrorOr<Status> S = status(Dir, *E);
1058 if (!S) {
1059 EC = S.getError();
1060 return {};
1061 }
1062 if (!S->isDirectory()) {
1063 EC = std::error_code(static_cast<int>(errc::not_a_directory),
1064 std::system_category());
1065 return {};
1066 }
1067
1068 auto *D = cast<RedirectingFileSystem::RedirectingDirectoryEntry>(*E);
1069 return directory_iterator(std::make_shared<VFSFromYamlDirIterImpl>(
1070 Dir, D->contents_begin(), D->contents_end(),
1071 /*IterateExternalFS=*/IsFallthrough, *ExternalFS, EC));
1072}
1073
1074void RedirectingFileSystem::setExternalContentsPrefixDir(StringRef PrefixDir) {
1075 ExternalContentsPrefixDir = PrefixDir.str();
1076}
1077
1078StringRef RedirectingFileSystem::getExternalContentsPrefixDir() const {
1079 return ExternalContentsPrefixDir;
1080}
1081
1082#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1083LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void RedirectingFileSystem::dump() const {
1084 for (const auto &Root : Roots)
1085 dumpEntry(Root.get());
1086}
1087
1088LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void
1089RedirectingFileSystem::dumpEntry(RedirectingFileSystem::Entry *E,
1090 int NumSpaces) const {
1091 StringRef Name = E->getName();
1092 for (int i = 0, e = NumSpaces; i < e; ++i)
1093 dbgs() << " ";
1094 dbgs() << "'" << Name.str().c_str() << "'"
1095 << "\n";
1096
1097 if (E->getKind() == RedirectingFileSystem::EK_Directory) {
1098 auto *DE = dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(E);
1099 assert(DE && "Should be a directory")((DE && "Should be a directory") ? static_cast<void
> (0) : __assert_fail ("DE && \"Should be a directory\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1099, __PRETTY_FUNCTION__))
;
1100
1101 for (std::unique_ptr<Entry> &SubEntry :
1102 llvm::make_range(DE->contents_begin(), DE->contents_end()))
1103 dumpEntry(SubEntry.get(), NumSpaces + 2);
1104 }
1105}
1106#endif
1107
1108/// A helper class to hold the common YAML parsing state.
1109class llvm::vfs::RedirectingFileSystemParser {
1110 yaml::Stream &Stream;
1111
1112 void error(yaml::Node *N, const Twine &Msg) { Stream.printError(N, Msg); }
1113
1114 // false on error
1115 bool parseScalarString(yaml::Node *N, StringRef &Result,
1116 SmallVectorImpl<char> &Storage) {
1117 const auto *S = dyn_cast<yaml::ScalarNode>(N);
1118
1119 if (!S) {
1120 error(N, "expected string");
1121 return false;
1122 }
1123 Result = S->getValue(Storage);
1124 return true;
1125 }
1126
1127 // false on error
1128 bool parseScalarBool(yaml::Node *N, bool &Result) {
1129 SmallString<5> Storage;
1130 StringRef Value;
1131 if (!parseScalarString(N, Value, Storage))
1132 return false;
1133
1134 if (Value.equals_lower("true") || Value.equals_lower("on") ||
1135 Value.equals_lower("yes") || Value == "1") {
1136 Result = true;
1137 return true;
1138 } else if (Value.equals_lower("false") || Value.equals_lower("off") ||
1139 Value.equals_lower("no") || Value == "0") {
1140 Result = false;
1141 return true;
1142 }
1143
1144 error(N, "expected boolean value");
1145 return false;
1146 }
1147
1148 struct KeyStatus {
1149 bool Required;
1150 bool Seen = false;
1151
1152 KeyStatus(bool Required = false) : Required(Required) {}
1153 };
1154
1155 using KeyStatusPair = std::pair<StringRef, KeyStatus>;
1156
1157 // false on error
1158 bool checkDuplicateOrUnknownKey(yaml::Node *KeyNode, StringRef Key,
1159 DenseMap<StringRef, KeyStatus> &Keys) {
1160 if (!Keys.count(Key)) {
1161 error(KeyNode, "unknown key");
1162 return false;
1163 }
1164 KeyStatus &S = Keys[Key];
1165 if (S.Seen) {
1166 error(KeyNode, Twine("duplicate key '") + Key + "'");
1167 return false;
1168 }
1169 S.Seen = true;
1170 return true;
1171 }
1172
1173 // false on error
1174 bool checkMissingKeys(yaml::Node *Obj, DenseMap<StringRef, KeyStatus> &Keys) {
1175 for (const auto &I : Keys) {
1176 if (I.second.Required && !I.second.Seen) {
1177 error(Obj, Twine("missing key '") + I.first + "'");
1178 return false;
1179 }
1180 }
1181 return true;
1182 }
1183
1184 RedirectingFileSystem::Entry *
1185 lookupOrCreateEntry(RedirectingFileSystem *FS, StringRef Name,
1186 RedirectingFileSystem::Entry *ParentEntry = nullptr) {
1187 if (!ParentEntry) { // Look for a existent root
1188 for (const auto &Root : FS->Roots) {
1189 if (Name.equals(Root->getName())) {
1190 ParentEntry = Root.get();
1191 return ParentEntry;
1192 }
1193 }
1194 } else { // Advance to the next component
1195 auto *DE = dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(
1196 ParentEntry);
1197 for (std::unique_ptr<RedirectingFileSystem::Entry> &Content :
1198 llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1199 auto *DirContent =
1200 dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(
1201 Content.get());
1202 if (DirContent && Name.equals(Content->getName()))
1203 return DirContent;
1204 }
1205 }
1206
1207 // ... or create a new one
1208 std::unique_ptr<RedirectingFileSystem::Entry> E =
1209 llvm::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1210 Name, Status("", getNextVirtualUniqueID(),
1211 std::chrono::system_clock::now(), 0, 0, 0,
1212 file_type::directory_file, sys::fs::all_all));
1213
1214 if (!ParentEntry) { // Add a new root to the overlay
1215 FS->Roots.push_back(std::move(E));
1216 ParentEntry = FS->Roots.back().get();
1217 return ParentEntry;
1218 }
1219
1220 auto *DE =
1221 dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(ParentEntry);
1222 DE->addContent(std::move(E));
1223 return DE->getLastContent();
1224 }
1225
1226 void uniqueOverlayTree(RedirectingFileSystem *FS,
1227 RedirectingFileSystem::Entry *SrcE,
1228 RedirectingFileSystem::Entry *NewParentE = nullptr) {
1229 StringRef Name = SrcE->getName();
1230 switch (SrcE->getKind()) {
1231 case RedirectingFileSystem::EK_Directory: {
1232 auto *DE =
1233 dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(SrcE);
1234 assert(DE && "Must be a directory")((DE && "Must be a directory") ? static_cast<void>
(0) : __assert_fail ("DE && \"Must be a directory\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1234, __PRETTY_FUNCTION__))
;
1235 // Empty directories could be present in the YAML as a way to
1236 // describe a file for a current directory after some of its subdir
1237 // is parsed. This only leads to redundant walks, ignore it.
1238 if (!Name.empty())
1239 NewParentE = lookupOrCreateEntry(FS, Name, NewParentE);
1240 for (std::unique_ptr<RedirectingFileSystem::Entry> &SubEntry :
1241 llvm::make_range(DE->contents_begin(), DE->contents_end()))
1242 uniqueOverlayTree(FS, SubEntry.get(), NewParentE);
1243 break;
1244 }
1245 case RedirectingFileSystem::EK_File: {
1246 auto *FE = dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(SrcE);
1247 assert(FE && "Must be a file")((FE && "Must be a file") ? static_cast<void> (
0) : __assert_fail ("FE && \"Must be a file\"", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1247, __PRETTY_FUNCTION__))
;
1248 assert(NewParentE && "Parent entry must exist")((NewParentE && "Parent entry must exist") ? static_cast
<void> (0) : __assert_fail ("NewParentE && \"Parent entry must exist\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1248, __PRETTY_FUNCTION__))
;
1249 auto *DE = dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(
1250 NewParentE);
1251 DE->addContent(
1252 llvm::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
1253 Name, FE->getExternalContentsPath(), FE->getUseName()));
1254 break;
1255 }
1256 }
1257 }
1258
1259 std::unique_ptr<RedirectingFileSystem::Entry>
1260 parseEntry(yaml::Node *N, RedirectingFileSystem *FS, bool IsRootEntry) {
1261 auto *M = dyn_cast<yaml::MappingNode>(N);
1262 if (!M) {
14
Assuming 'M' is non-null
15
Taking false branch
1263 error(N, "expected mapping node for file or directory entry");
1264 return nullptr;
1265 }
1266
1267 KeyStatusPair Fields[] = {
1268 KeyStatusPair("name", true),
1269 KeyStatusPair("type", true),
1270 KeyStatusPair("contents", false),
1271 KeyStatusPair("external-contents", false),
1272 KeyStatusPair("use-external-name", false),
1273 };
1274
1275 DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));
1276
1277 bool HasContents = false; // external or otherwise
1278 std::vector<std::unique_ptr<RedirectingFileSystem::Entry>>
1279 EntryArrayContents;
1280 std::string ExternalContentsPath;
1281 std::string Name;
1282 yaml::Node *NameValueNode = nullptr;
1283 auto UseExternalName =
1284 RedirectingFileSystem::RedirectingFileEntry::NK_NotSet;
1285 RedirectingFileSystem::EntryKind Kind;
16
'Kind' declared without an initial value
1286
1287 for (auto &I : *M) {
1288 StringRef Key;
1289 // Reuse the buffer for key and value, since we don't look at key after
1290 // parsing value.
1291 SmallString<256> Buffer;
1292 if (!parseScalarString(I.getKey(), Key, Buffer))
17
Taking false branch
1293 return nullptr;
1294
1295 if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
18
Taking false branch
1296 return nullptr;
1297
1298 StringRef Value;
1299 if (Key == "name") {
19
Assuming the condition is false
20
Taking false branch
1300 if (!parseScalarString(I.getValue(), Value, Buffer))
1301 return nullptr;
1302
1303 NameValueNode = I.getValue();
1304 if (FS->UseCanonicalizedPaths) {
1305 SmallString<256> Path(Value);
1306 // Guarantee that old YAML files containing paths with ".." and "."
1307 // are properly canonicalized before read into the VFS.
1308 Path = sys::path::remove_leading_dotslash(Path);
1309 sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
1310 Name = Path.str();
1311 } else {
1312 Name = Value;
1313 }
1314 } else if (Key == "type") {
21
Assuming the condition is false
22
Taking false branch
1315 if (!parseScalarString(I.getValue(), Value, Buffer))
1316 return nullptr;
1317 if (Value == "file")
1318 Kind = RedirectingFileSystem::EK_File;
1319 else if (Value == "directory")
1320 Kind = RedirectingFileSystem::EK_Directory;
1321 else {
1322 error(I.getValue(), "unknown value for 'type'");
1323 return nullptr;
1324 }
1325 } else if (Key == "contents") {
23
Assuming the condition is false
24
Taking false branch
1326 if (HasContents) {
1327 error(I.getKey(),
1328 "entry already has 'contents' or 'external-contents'");
1329 return nullptr;
1330 }
1331 HasContents = true;
1332 auto *Contents = dyn_cast<yaml::SequenceNode>(I.getValue());
1333 if (!Contents) {
1334 // FIXME: this is only for directories, what about files?
1335 error(I.getValue(), "expected array");
1336 return nullptr;
1337 }
1338
1339 for (auto &I : *Contents) {
1340 if (std::unique_ptr<RedirectingFileSystem::Entry> E =
1341 parseEntry(&I, FS, /*IsRootEntry*/ false))
1342 EntryArrayContents.push_back(std::move(E));
1343 else
1344 return nullptr;
1345 }
1346 } else if (Key == "external-contents") {
25
Assuming the condition is true
26
Taking true branch
1347 if (HasContents) {
27
Taking false branch
1348 error(I.getKey(),
1349 "entry already has 'contents' or 'external-contents'");
1350 return nullptr;
1351 }
1352 HasContents = true;
1353 if (!parseScalarString(I.getValue(), Value, Buffer))
28
Taking false branch
1354 return nullptr;
1355
1356 SmallString<256> FullPath;
1357 if (FS->IsRelativeOverlay) {
29
Taking false branch
1358 FullPath = FS->getExternalContentsPrefixDir();
1359 assert(!FullPath.empty() &&((!FullPath.empty() && "External contents prefix directory must exist"
) ? static_cast<void> (0) : __assert_fail ("!FullPath.empty() && \"External contents prefix directory must exist\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1360, __PRETTY_FUNCTION__))
1360 "External contents prefix directory must exist")((!FullPath.empty() && "External contents prefix directory must exist"
) ? static_cast<void> (0) : __assert_fail ("!FullPath.empty() && \"External contents prefix directory must exist\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1360, __PRETTY_FUNCTION__))
;
1361 llvm::sys::path::append(FullPath, Value);
1362 } else {
1363 FullPath = Value;
1364 }
1365
1366 if (FS->UseCanonicalizedPaths) {
30
Taking true branch
1367 // Guarantee that old YAML files containing paths with ".." and "."
1368 // are properly canonicalized before read into the VFS.
1369 FullPath = sys::path::remove_leading_dotslash(FullPath);
1370 sys::path::remove_dots(FullPath, /*remove_dot_dot=*/true);
1371 }
1372 ExternalContentsPath = FullPath.str();
1373 } else if (Key == "use-external-name") {
1374 bool Val;
1375 if (!parseScalarBool(I.getValue(), Val))
1376 return nullptr;
1377 UseExternalName =
1378 Val ? RedirectingFileSystem::RedirectingFileEntry::NK_External
1379 : RedirectingFileSystem::RedirectingFileEntry::NK_Virtual;
1380 } else {
1381 llvm_unreachable("key missing from Keys")::llvm::llvm_unreachable_internal("key missing from Keys", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1381)
;
1382 }
1383 }
1384
1385 if (Stream.failed())
31
Assuming the condition is false
32
Taking false branch
1386 return nullptr;
1387
1388 // check for missing keys
1389 if (!HasContents) {
33
Taking false branch
1390 error(N, "missing key 'contents' or 'external-contents'");
1391 return nullptr;
1392 }
1393 if (!checkMissingKeys(N, Keys))
34
Assuming the condition is false
35
Taking false branch
1394 return nullptr;
1395
1396 // check invalid configuration
1397 if (Kind == RedirectingFileSystem::EK_Directory &&
36
The left operand of '==' is a garbage value
1398 UseExternalName !=
1399 RedirectingFileSystem::RedirectingFileEntry::NK_NotSet) {
1400 error(N, "'use-external-name' is not supported for directories");
1401 return nullptr;
1402 }
1403
1404 if (IsRootEntry && !sys::path::is_absolute(Name)) {
1405 assert(NameValueNode && "Name presence should be checked earlier")((NameValueNode && "Name presence should be checked earlier"
) ? static_cast<void> (0) : __assert_fail ("NameValueNode && \"Name presence should be checked earlier\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1405, __PRETTY_FUNCTION__))
;
1406 error(NameValueNode,
1407 "entry with relative path at the root level is not discoverable");
1408 return nullptr;
1409 }
1410
1411 // Remove trailing slash(es), being careful not to remove the root path
1412 StringRef Trimmed(Name);
1413 size_t RootPathLen = sys::path::root_path(Trimmed).size();
1414 while (Trimmed.size() > RootPathLen &&
1415 sys::path::is_separator(Trimmed.back()))
1416 Trimmed = Trimmed.slice(0, Trimmed.size() - 1);
1417 // Get the last component
1418 StringRef LastComponent = sys::path::filename(Trimmed);
1419
1420 std::unique_ptr<RedirectingFileSystem::Entry> Result;
1421 switch (Kind) {
1422 case RedirectingFileSystem::EK_File:
1423 Result = llvm::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
1424 LastComponent, std::move(ExternalContentsPath), UseExternalName);
1425 break;
1426 case RedirectingFileSystem::EK_Directory:
1427 Result =
1428 llvm::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1429 LastComponent, std::move(EntryArrayContents),
1430 Status("", getNextVirtualUniqueID(),
1431 std::chrono::system_clock::now(), 0, 0, 0,
1432 file_type::directory_file, sys::fs::all_all));
1433 break;
1434 }
1435
1436 StringRef Parent = sys::path::parent_path(Trimmed);
1437 if (Parent.empty())
1438 return Result;
1439
1440 // if 'name' contains multiple components, create implicit directory entries
1441 for (sys::path::reverse_iterator I = sys::path::rbegin(Parent),
1442 E = sys::path::rend(Parent);
1443 I != E; ++I) {
1444 std::vector<std::unique_ptr<RedirectingFileSystem::Entry>> Entries;
1445 Entries.push_back(std::move(Result));
1446 Result =
1447 llvm::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1448 *I, std::move(Entries),
1449 Status("", getNextVirtualUniqueID(),
1450 std::chrono::system_clock::now(), 0, 0, 0,
1451 file_type::directory_file, sys::fs::all_all));
1452 }
1453 return Result;
1454 }
1455
1456public:
1457 RedirectingFileSystemParser(yaml::Stream &S) : Stream(S) {}
1458
1459 // false on error
1460 bool parse(yaml::Node *Root, RedirectingFileSystem *FS) {
1461 auto *Top = dyn_cast<yaml::MappingNode>(Root);
1462 if (!Top) {
7
Taking false branch
1463 error(Root, "expected mapping node");
1464 return false;
1465 }
1466
1467 KeyStatusPair Fields[] = {
1468 KeyStatusPair("version", true),
1469 KeyStatusPair("case-sensitive", false),
1470 KeyStatusPair("use-external-names", false),
1471 KeyStatusPair("overlay-relative", false),
1472 KeyStatusPair("fallthrough", false),
1473 KeyStatusPair("roots", true),
1474 };
1475
1476 DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));
1477 std::vector<std::unique_ptr<RedirectingFileSystem::Entry>> RootEntries;
1478
1479 // Parse configuration and 'roots'
1480 for (auto &I : *Top) {
1481 SmallString<10> KeyBuffer;
1482 StringRef Key;
1483 if (!parseScalarString(I.getKey(), Key, KeyBuffer))
8
Taking false branch
1484 return false;
1485
1486 if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
9
Taking false branch
1487 return false;
1488
1489 if (Key == "roots") {
10
Assuming the condition is true
11
Taking true branch
1490 auto *Roots = dyn_cast<yaml::SequenceNode>(I.getValue());
1491 if (!Roots) {
12
Taking false branch
1492 error(I.getValue(), "expected array");
1493 return false;
1494 }
1495
1496 for (auto &I : *Roots) {
1497 if (std::unique_ptr<RedirectingFileSystem::Entry> E =
1498 parseEntry(&I, FS, /*IsRootEntry*/ true))
13
Calling 'RedirectingFileSystemParser::parseEntry'
1499 RootEntries.push_back(std::move(E));
1500 else
1501 return false;
1502 }
1503 } else if (Key == "version") {
1504 StringRef VersionString;
1505 SmallString<4> Storage;
1506 if (!parseScalarString(I.getValue(), VersionString, Storage))
1507 return false;
1508 int Version;
1509 if (VersionString.getAsInteger<int>(10, Version)) {
1510 error(I.getValue(), "expected integer");
1511 return false;
1512 }
1513 if (Version < 0) {
1514 error(I.getValue(), "invalid version number");
1515 return false;
1516 }
1517 if (Version != 0) {
1518 error(I.getValue(), "version mismatch, expected 0");
1519 return false;
1520 }
1521 } else if (Key == "case-sensitive") {
1522 if (!parseScalarBool(I.getValue(), FS->CaseSensitive))
1523 return false;
1524 } else if (Key == "overlay-relative") {
1525 if (!parseScalarBool(I.getValue(), FS->IsRelativeOverlay))
1526 return false;
1527 } else if (Key == "use-external-names") {
1528 if (!parseScalarBool(I.getValue(), FS->UseExternalNames))
1529 return false;
1530 } else if (Key == "fallthrough") {
1531 if (!parseScalarBool(I.getValue(), FS->IsFallthrough))
1532 return false;
1533 } else {
1534 llvm_unreachable("key missing from Keys")::llvm::llvm_unreachable_internal("key missing from Keys", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1534)
;
1535 }
1536 }
1537
1538 if (Stream.failed())
1539 return false;
1540
1541 if (!checkMissingKeys(Top, Keys))
1542 return false;
1543
1544 // Now that we sucessefully parsed the YAML file, canonicalize the internal
1545 // representation to a proper directory tree so that we can search faster
1546 // inside the VFS.
1547 for (auto &E : RootEntries)
1548 uniqueOverlayTree(FS, E.get());
1549
1550 return true;
1551 }
1552};
1553
1554RedirectingFileSystem *
1555RedirectingFileSystem::create(std::unique_ptr<MemoryBuffer> Buffer,
1556 SourceMgr::DiagHandlerTy DiagHandler,
1557 StringRef YAMLFilePath, void *DiagContext,
1558 IntrusiveRefCntPtr<FileSystem> ExternalFS) {
1559 SourceMgr SM;
1560 yaml::Stream Stream(Buffer->getMemBufferRef(), SM);
1561
1562 SM.setDiagHandler(DiagHandler, DiagContext);
1563 yaml::document_iterator DI = Stream.begin();
1564 yaml::Node *Root = DI->getRoot();
1565 if (DI == Stream.end() || !Root) {
2
Assuming 'Root' is non-null
3
Taking false branch
1566 SM.PrintMessage(SMLoc(), SourceMgr::DK_Error, "expected root node");
1567 return nullptr;
1568 }
1569
1570 RedirectingFileSystemParser P(Stream);
1571
1572 std::unique_ptr<RedirectingFileSystem> FS(
1573 new RedirectingFileSystem(std::move(ExternalFS)));
1574
1575 if (!YAMLFilePath.empty()) {
4
Assuming the condition is false
5
Taking false branch
1576 // Use the YAML path from -ivfsoverlay to compute the dir to be prefixed
1577 // to each 'external-contents' path.
1578 //
1579 // Example:
1580 // -ivfsoverlay dummy.cache/vfs/vfs.yaml
1581 // yields:
1582 // FS->ExternalContentsPrefixDir => /<absolute_path_to>/dummy.cache/vfs
1583 //
1584 SmallString<256> OverlayAbsDir = sys::path::parent_path(YAMLFilePath);
1585 std::error_code EC = llvm::sys::fs::make_absolute(OverlayAbsDir);
1586 assert(!EC && "Overlay dir final path must be absolute")((!EC && "Overlay dir final path must be absolute") ?
static_cast<void> (0) : __assert_fail ("!EC && \"Overlay dir final path must be absolute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1586, __PRETTY_FUNCTION__))
;
1587 (void)EC;
1588 FS->setExternalContentsPrefixDir(OverlayAbsDir);
1589 }
1590
1591 if (!P.parse(Root, FS.get()))
6
Calling 'RedirectingFileSystemParser::parse'
1592 return nullptr;
1593
1594 return FS.release();
1595}
1596
1597ErrorOr<RedirectingFileSystem::Entry *>
1598RedirectingFileSystem::lookupPath(const Twine &Path_) const {
1599 SmallString<256> Path;
1600 Path_.toVector(Path);
1601
1602 // Handle relative paths
1603 if (std::error_code EC = makeAbsolute(Path))
1604 return EC;
1605
1606 // Canonicalize path by removing ".", "..", "./", etc components. This is
1607 // a VFS request, do bot bother about symlinks in the path components
1608 // but canonicalize in order to perform the correct entry search.
1609 if (UseCanonicalizedPaths) {
1610 Path = sys::path::remove_leading_dotslash(Path);
1611 sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
1612 }
1613
1614 if (Path.empty())
1615 return make_error_code(llvm::errc::invalid_argument);
1616
1617 sys::path::const_iterator Start = sys::path::begin(Path);
1618 sys::path::const_iterator End = sys::path::end(Path);
1619 for (const auto &Root : Roots) {
1620 ErrorOr<RedirectingFileSystem::Entry *> Result =
1621 lookupPath(Start, End, Root.get());
1622 if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
1623 return Result;
1624 }
1625 return make_error_code(llvm::errc::no_such_file_or_directory);
1626}
1627
1628ErrorOr<RedirectingFileSystem::Entry *>
1629RedirectingFileSystem::lookupPath(sys::path::const_iterator Start,
1630 sys::path::const_iterator End,
1631 RedirectingFileSystem::Entry *From) const {
1632#ifndef _WIN32
1633 assert(!isTraversalComponent(*Start) &&((!isTraversalComponent(*Start) && !isTraversalComponent
(From->getName()) && "Paths should not contain traversal components"
) ? static_cast<void> (0) : __assert_fail ("!isTraversalComponent(*Start) && !isTraversalComponent(From->getName()) && \"Paths should not contain traversal components\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1635, __PRETTY_FUNCTION__))
1634 !isTraversalComponent(From->getName()) &&((!isTraversalComponent(*Start) && !isTraversalComponent
(From->getName()) && "Paths should not contain traversal components"
) ? static_cast<void> (0) : __assert_fail ("!isTraversalComponent(*Start) && !isTraversalComponent(From->getName()) && \"Paths should not contain traversal components\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1635, __PRETTY_FUNCTION__))
1635 "Paths should not contain traversal components")((!isTraversalComponent(*Start) && !isTraversalComponent
(From->getName()) && "Paths should not contain traversal components"
) ? static_cast<void> (0) : __assert_fail ("!isTraversalComponent(*Start) && !isTraversalComponent(From->getName()) && \"Paths should not contain traversal components\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1635, __PRETTY_FUNCTION__))
;
1636#else
1637 // FIXME: this is here to support windows, remove it once canonicalized
1638 // paths become globally default.
1639 if (Start->equals("."))
1640 ++Start;
1641#endif
1642
1643 StringRef FromName = From->getName();
1644
1645 // Forward the search to the next component in case this is an empty one.
1646 if (!FromName.empty()) {
1647 if (CaseSensitive ? !Start->equals(FromName)
1648 : !Start->equals_lower(FromName))
1649 // failure to match
1650 return make_error_code(llvm::errc::no_such_file_or_directory);
1651
1652 ++Start;
1653
1654 if (Start == End) {
1655 // Match!
1656 return From;
1657 }
1658 }
1659
1660 auto *DE = dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(From);
1661 if (!DE)
1662 return make_error_code(llvm::errc::not_a_directory);
1663
1664 for (const std::unique_ptr<RedirectingFileSystem::Entry> &DirEntry :
1665 llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1666 ErrorOr<RedirectingFileSystem::Entry *> Result =
1667 lookupPath(Start, End, DirEntry.get());
1668 if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
1669 return Result;
1670 }
1671 return make_error_code(llvm::errc::no_such_file_or_directory);
1672}
1673
1674static Status getRedirectedFileStatus(const Twine &Path, bool UseExternalNames,
1675 Status ExternalStatus) {
1676 Status S = ExternalStatus;
1677 if (!UseExternalNames)
1678 S = Status::copyWithNewName(S, Path);
1679 S.IsVFSMapped = true;
1680 return S;
1681}
1682
1683ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path,
1684 RedirectingFileSystem::Entry *E) {
1685 assert(E != nullptr)((E != nullptr) ? static_cast<void> (0) : __assert_fail
("E != nullptr", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1685, __PRETTY_FUNCTION__))
;
1686 if (auto *F = dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(E)) {
1687 ErrorOr<Status> S = ExternalFS->status(F->getExternalContentsPath());
1688 assert(!S || S->getName() == F->getExternalContentsPath())((!S || S->getName() == F->getExternalContentsPath()) ?
static_cast<void> (0) : __assert_fail ("!S || S->getName() == F->getExternalContentsPath()"
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1688, __PRETTY_FUNCTION__))
;
1689 if (S)
1690 return getRedirectedFileStatus(Path, F->useExternalName(UseExternalNames),
1691 *S);
1692 return S;
1693 } else { // directory
1694 auto *DE = cast<RedirectingFileSystem::RedirectingDirectoryEntry>(E);
1695 return Status::copyWithNewName(DE->getStatus(), Path);
1696 }
1697}
1698
1699ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path) {
1700 ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
1701 if (!Result) {
1702 if (IsFallthrough &&
1703 Result.getError() == llvm::errc::no_such_file_or_directory) {
1704 return ExternalFS->status(Path);
1705 }
1706 return Result.getError();
1707 }
1708 return status(Path, *Result);
1709}
1710
1711namespace {
1712
1713/// Provide a file wrapper with an overriden status.
1714class FileWithFixedStatus : public File {
1715 std::unique_ptr<File> InnerFile;
1716 Status S;
1717
1718public:
1719 FileWithFixedStatus(std::unique_ptr<File> InnerFile, Status S)
1720 : InnerFile(std::move(InnerFile)), S(std::move(S)) {}
1721
1722 ErrorOr<Status> status() override { return S; }
1723 ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
1724
1725 getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
1726 bool IsVolatile) override {
1727 return InnerFile->getBuffer(Name, FileSize, RequiresNullTerminator,
1728 IsVolatile);
1729 }
1730
1731 std::error_code close() override { return InnerFile->close(); }
1732};
1733
1734} // namespace
1735
1736ErrorOr<std::unique_ptr<File>>
1737RedirectingFileSystem::openFileForRead(const Twine &Path) {
1738 ErrorOr<RedirectingFileSystem::Entry *> E = lookupPath(Path);
1739 if (!E) {
1740 if (IsFallthrough &&
1741 E.getError() == llvm::errc::no_such_file_or_directory) {
1742 return ExternalFS->openFileForRead(Path);
1743 }
1744 return E.getError();
1745 }
1746
1747 auto *F = dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(*E);
1748 if (!F) // FIXME: errc::not_a_file?
1749 return make_error_code(llvm::errc::invalid_argument);
1750
1751 auto Result = ExternalFS->openFileForRead(F->getExternalContentsPath());
1752 if (!Result)
1753 return Result;
1754
1755 auto ExternalStatus = (*Result)->status();
1756 if (!ExternalStatus)
1757 return ExternalStatus.getError();
1758
1759 // FIXME: Update the status with the name and VFSMapped.
1760 Status S = getRedirectedFileStatus(Path, F->useExternalName(UseExternalNames),
1761 *ExternalStatus);
1762 return std::unique_ptr<File>(
1763 llvm::make_unique<FileWithFixedStatus>(std::move(*Result), S));
1764}
1765
1766std::error_code
1767RedirectingFileSystem::getRealPath(const Twine &Path,
1768 SmallVectorImpl<char> &Output) const {
1769 ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
1770 if (!Result) {
1771 if (IsFallthrough &&
1772 Result.getError() == llvm::errc::no_such_file_or_directory) {
1773 return ExternalFS->getRealPath(Path, Output);
1774 }
1775 return Result.getError();
1776 }
1777
1778 if (auto *F =
1779 dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(*Result)) {
1780 return ExternalFS->getRealPath(F->getExternalContentsPath(), Output);
1781 }
1782 // Even if there is a directory entry, fall back to ExternalFS if allowed,
1783 // because directories don't have a single external contents path.
1784 return IsFallthrough ? ExternalFS->getRealPath(Path, Output)
1785 : llvm::errc::invalid_argument;
1786}
1787
1788IntrusiveRefCntPtr<FileSystem>
1789vfs::getVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
1790 SourceMgr::DiagHandlerTy DiagHandler,
1791 StringRef YAMLFilePath, void *DiagContext,
1792 IntrusiveRefCntPtr<FileSystem> ExternalFS) {
1793 return RedirectingFileSystem::create(std::move(Buffer), DiagHandler,
1794 YAMLFilePath, DiagContext,
1795 std::move(ExternalFS));
1796}
1797
1798static void getVFSEntries(RedirectingFileSystem::Entry *SrcE,
1799 SmallVectorImpl<StringRef> &Path,
1800 SmallVectorImpl<YAMLVFSEntry> &Entries) {
1801 auto Kind = SrcE->getKind();
1802 if (Kind == RedirectingFileSystem::EK_Directory) {
1803 auto *DE = dyn_cast<RedirectingFileSystem::RedirectingDirectoryEntry>(SrcE);
1804 assert(DE && "Must be a directory")((DE && "Must be a directory") ? static_cast<void>
(0) : __assert_fail ("DE && \"Must be a directory\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1804, __PRETTY_FUNCTION__))
;
1805 for (std::unique_ptr<RedirectingFileSystem::Entry> &SubEntry :
1806 llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1807 Path.push_back(SubEntry->getName());
1808 getVFSEntries(SubEntry.get(), Path, Entries);
1809 Path.pop_back();
1810 }
1811 return;
1812 }
1813
1814 assert(Kind == RedirectingFileSystem::EK_File && "Must be a EK_File")((Kind == RedirectingFileSystem::EK_File && "Must be a EK_File"
) ? static_cast<void> (0) : __assert_fail ("Kind == RedirectingFileSystem::EK_File && \"Must be a EK_File\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1814, __PRETTY_FUNCTION__))
;
1815 auto *FE = dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(SrcE);
1816 assert(FE && "Must be a file")((FE && "Must be a file") ? static_cast<void> (
0) : __assert_fail ("FE && \"Must be a file\"", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1816, __PRETTY_FUNCTION__))
;
1817 SmallString<128> VPath;
1818 for (auto &Comp : Path)
1819 llvm::sys::path::append(VPath, Comp);
1820 Entries.push_back(YAMLVFSEntry(VPath.c_str(), FE->getExternalContentsPath()));
1821}
1822
1823void vfs::collectVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
1824 SourceMgr::DiagHandlerTy DiagHandler,
1825 StringRef YAMLFilePath,
1826 SmallVectorImpl<YAMLVFSEntry> &CollectedEntries,
1827 void *DiagContext,
1828 IntrusiveRefCntPtr<FileSystem> ExternalFS) {
1829 RedirectingFileSystem *VFS = RedirectingFileSystem::create(
1
Calling 'RedirectingFileSystem::create'
1830 std::move(Buffer), DiagHandler, YAMLFilePath, DiagContext,
1831 std::move(ExternalFS));
1832 ErrorOr<RedirectingFileSystem::Entry *> RootE = VFS->lookupPath("/");
1833 if (!RootE)
1834 return;
1835 SmallVector<StringRef, 8> Components;
1836 Components.push_back("/");
1837 getVFSEntries(*RootE, Components, CollectedEntries);
1838}
1839
1840UniqueID vfs::getNextVirtualUniqueID() {
1841 static std::atomic<unsigned> UID;
1842 unsigned ID = ++UID;
1843 // The following assumes that uint64_t max will never collide with a real
1844 // dev_t value from the OS.
1845 return UniqueID(std::numeric_limits<uint64_t>::max(), ID);
1846}
1847
1848void YAMLVFSWriter::addFileMapping(StringRef VirtualPath, StringRef RealPath) {
1849 assert(sys::path::is_absolute(VirtualPath) && "virtual path not absolute")((sys::path::is_absolute(VirtualPath) && "virtual path not absolute"
) ? static_cast<void> (0) : __assert_fail ("sys::path::is_absolute(VirtualPath) && \"virtual path not absolute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1849, __PRETTY_FUNCTION__))
;
1850 assert(sys::path::is_absolute(RealPath) && "real path not absolute")((sys::path::is_absolute(RealPath) && "real path not absolute"
) ? static_cast<void> (0) : __assert_fail ("sys::path::is_absolute(RealPath) && \"real path not absolute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1850, __PRETTY_FUNCTION__))
;
1851 assert(!pathHasTraversal(VirtualPath) && "path traversal is not supported")((!pathHasTraversal(VirtualPath) && "path traversal is not supported"
) ? static_cast<void> (0) : __assert_fail ("!pathHasTraversal(VirtualPath) && \"path traversal is not supported\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1851, __PRETTY_FUNCTION__))
;
1852 Mappings.emplace_back(VirtualPath, RealPath);
1853}
1854
1855namespace {
1856
1857class JSONWriter {
1858 llvm::raw_ostream &OS;
1859 SmallVector<StringRef, 16> DirStack;
1860
1861 unsigned getDirIndent() { return 4 * DirStack.size(); }
1862 unsigned getFileIndent() { return 4 * (DirStack.size() + 1); }
1863 bool containedIn(StringRef Parent, StringRef Path);
1864 StringRef containedPart(StringRef Parent, StringRef Path);
1865 void startDirectory(StringRef Path);
1866 void endDirectory();
1867 void writeEntry(StringRef VPath, StringRef RPath);
1868
1869public:
1870 JSONWriter(llvm::raw_ostream &OS) : OS(OS) {}
1871
1872 void write(ArrayRef<YAMLVFSEntry> Entries, Optional<bool> UseExternalNames,
1873 Optional<bool> IsCaseSensitive, Optional<bool> IsOverlayRelative,
1874 StringRef OverlayDir);
1875};
1876
1877} // namespace
1878
1879bool JSONWriter::containedIn(StringRef Parent, StringRef Path) {
1880 using namespace llvm::sys;
1881
1882 // Compare each path component.
1883 auto IParent = path::begin(Parent), EParent = path::end(Parent);
1884 for (auto IChild = path::begin(Path), EChild = path::end(Path);
1885 IParent != EParent && IChild != EChild; ++IParent, ++IChild) {
1886 if (*IParent != *IChild)
1887 return false;
1888 }
1889 // Have we exhausted the parent path?
1890 return IParent == EParent;
1891}
1892
1893StringRef JSONWriter::containedPart(StringRef Parent, StringRef Path) {
1894 assert(!Parent.empty())((!Parent.empty()) ? static_cast<void> (0) : __assert_fail
("!Parent.empty()", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1894, __PRETTY_FUNCTION__))
;
1895 assert(containedIn(Parent, Path))((containedIn(Parent, Path)) ? static_cast<void> (0) : __assert_fail
("containedIn(Parent, Path)", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1895, __PRETTY_FUNCTION__))
;
1896 return Path.slice(Parent.size() + 1, StringRef::npos);
1897}
1898
1899void JSONWriter::startDirectory(StringRef Path) {
1900 StringRef Name =
1901 DirStack.empty() ? Path : containedPart(DirStack.back(), Path);
1902 DirStack.push_back(Path);
1903 unsigned Indent = getDirIndent();
1904 OS.indent(Indent) << "{\n";
1905 OS.indent(Indent + 2) << "'type': 'directory',\n";
1906 OS.indent(Indent + 2) << "'name': \"" << llvm::yaml::escape(Name) << "\",\n";
1907 OS.indent(Indent + 2) << "'contents': [\n";
1908}
1909
1910void JSONWriter::endDirectory() {
1911 unsigned Indent = getDirIndent();
1912 OS.indent(Indent + 2) << "]\n";
1913 OS.indent(Indent) << "}";
1914
1915 DirStack.pop_back();
1916}
1917
1918void JSONWriter::writeEntry(StringRef VPath, StringRef RPath) {
1919 unsigned Indent = getFileIndent();
1920 OS.indent(Indent) << "{\n";
1921 OS.indent(Indent + 2) << "'type': 'file',\n";
1922 OS.indent(Indent + 2) << "'name': \"" << llvm::yaml::escape(VPath) << "\",\n";
1923 OS.indent(Indent + 2) << "'external-contents': \""
1924 << llvm::yaml::escape(RPath) << "\"\n";
1925 OS.indent(Indent) << "}";
1926}
1927
1928void JSONWriter::write(ArrayRef<YAMLVFSEntry> Entries,
1929 Optional<bool> UseExternalNames,
1930 Optional<bool> IsCaseSensitive,
1931 Optional<bool> IsOverlayRelative,
1932 StringRef OverlayDir) {
1933 using namespace llvm::sys;
1934
1935 OS << "{\n"
1936 " 'version': 0,\n";
1937 if (IsCaseSensitive.hasValue())
1938 OS << " 'case-sensitive': '"
1939 << (IsCaseSensitive.getValue() ? "true" : "false") << "',\n";
1940 if (UseExternalNames.hasValue())
1941 OS << " 'use-external-names': '"
1942 << (UseExternalNames.getValue() ? "true" : "false") << "',\n";
1943 bool UseOverlayRelative = false;
1944 if (IsOverlayRelative.hasValue()) {
1945 UseOverlayRelative = IsOverlayRelative.getValue();
1946 OS << " 'overlay-relative': '" << (UseOverlayRelative ? "true" : "false")
1947 << "',\n";
1948 }
1949 OS << " 'roots': [\n";
1950
1951 if (!Entries.empty()) {
1952 const YAMLVFSEntry &Entry = Entries.front();
1953 startDirectory(path::parent_path(Entry.VPath));
1954
1955 StringRef RPath = Entry.RPath;
1956 if (UseOverlayRelative) {
1957 unsigned OverlayDirLen = OverlayDir.size();
1958 assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&((RPath.substr(0, OverlayDirLen) == OverlayDir && "Overlay dir must be contained in RPath"
) ? static_cast<void> (0) : __assert_fail ("RPath.substr(0, OverlayDirLen) == OverlayDir && \"Overlay dir must be contained in RPath\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1959, __PRETTY_FUNCTION__))
1959 "Overlay dir must be contained in RPath")((RPath.substr(0, OverlayDirLen) == OverlayDir && "Overlay dir must be contained in RPath"
) ? static_cast<void> (0) : __assert_fail ("RPath.substr(0, OverlayDirLen) == OverlayDir && \"Overlay dir must be contained in RPath\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1959, __PRETTY_FUNCTION__))
;
1960 RPath = RPath.slice(OverlayDirLen, RPath.size());
1961 }
1962
1963 writeEntry(path::filename(Entry.VPath), RPath);
1964
1965 for (const auto &Entry : Entries.slice(1)) {
1966 StringRef Dir = path::parent_path(Entry.VPath);
1967 if (Dir == DirStack.back())
1968 OS << ",\n";
1969 else {
1970 while (!DirStack.empty() && !containedIn(DirStack.back(), Dir)) {
1971 OS << "\n";
1972 endDirectory();
1973 }
1974 OS << ",\n";
1975 startDirectory(Dir);
1976 }
1977 StringRef RPath = Entry.RPath;
1978 if (UseOverlayRelative) {
1979 unsigned OverlayDirLen = OverlayDir.size();
1980 assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&((RPath.substr(0, OverlayDirLen) == OverlayDir && "Overlay dir must be contained in RPath"
) ? static_cast<void> (0) : __assert_fail ("RPath.substr(0, OverlayDirLen) == OverlayDir && \"Overlay dir must be contained in RPath\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1981, __PRETTY_FUNCTION__))
1981 "Overlay dir must be contained in RPath")((RPath.substr(0, OverlayDirLen) == OverlayDir && "Overlay dir must be contained in RPath"
) ? static_cast<void> (0) : __assert_fail ("RPath.substr(0, OverlayDirLen) == OverlayDir && \"Overlay dir must be contained in RPath\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 1981, __PRETTY_FUNCTION__))
;
1982 RPath = RPath.slice(OverlayDirLen, RPath.size());
1983 }
1984 writeEntry(path::filename(Entry.VPath), RPath);
1985 }
1986
1987 while (!DirStack.empty()) {
1988 OS << "\n";
1989 endDirectory();
1990 }
1991 OS << "\n";
1992 }
1993
1994 OS << " ]\n"
1995 << "}\n";
1996}
1997
1998void YAMLVFSWriter::write(llvm::raw_ostream &OS) {
1999 llvm::sort(Mappings, [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) {
2000 return LHS.VPath < RHS.VPath;
2001 });
2002
2003 JSONWriter(OS).write(Mappings, UseExternalNames, IsCaseSensitive,
2004 IsOverlayRelative, OverlayDir);
2005}
2006
2007VFSFromYamlDirIterImpl::VFSFromYamlDirIterImpl(
2008 const Twine &_Path,
2009 RedirectingFileSystem::RedirectingDirectoryEntry::iterator Begin,
2010 RedirectingFileSystem::RedirectingDirectoryEntry::iterator End,
2011 bool IterateExternalFS, FileSystem &ExternalFS, std::error_code &EC)
2012 : Dir(_Path.str()), Current(Begin), End(End),
2013 IterateExternalFS(IterateExternalFS), ExternalFS(ExternalFS) {
2014 EC = incrementImpl(/*IsFirstTime=*/true);
2015}
2016
2017std::error_code VFSFromYamlDirIterImpl::increment() {
2018 return incrementImpl(/*IsFirstTime=*/false);
2019}
2020
2021std::error_code VFSFromYamlDirIterImpl::incrementExternal() {
2022 assert(!(IsExternalFSCurrent && ExternalDirIter == directory_iterator()) &&((!(IsExternalFSCurrent && ExternalDirIter == directory_iterator
()) && "incrementing past end") ? static_cast<void
> (0) : __assert_fail ("!(IsExternalFSCurrent && ExternalDirIter == directory_iterator()) && \"incrementing past end\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 2023, __PRETTY_FUNCTION__))
2023 "incrementing past end")((!(IsExternalFSCurrent && ExternalDirIter == directory_iterator
()) && "incrementing past end") ? static_cast<void
> (0) : __assert_fail ("!(IsExternalFSCurrent && ExternalDirIter == directory_iterator()) && \"incrementing past end\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 2023, __PRETTY_FUNCTION__))
;
2024 std::error_code EC;
2025 if (IsExternalFSCurrent) {
2026 ExternalDirIter.increment(EC);
2027 } else if (IterateExternalFS) {
2028 ExternalDirIter = ExternalFS.dir_begin(Dir, EC);
2029 IsExternalFSCurrent = true;
2030 if (EC && EC != errc::no_such_file_or_directory)
2031 return EC;
2032 EC = {};
2033 }
2034 if (EC || ExternalDirIter == directory_iterator()) {
2035 CurrentEntry = directory_entry();
2036 } else {
2037 CurrentEntry = *ExternalDirIter;
2038 }
2039 return EC;
2040}
2041
2042std::error_code VFSFromYamlDirIterImpl::incrementContent(bool IsFirstTime) {
2043 assert((IsFirstTime || Current != End) && "cannot iterate past end")(((IsFirstTime || Current != End) && "cannot iterate past end"
) ? static_cast<void> (0) : __assert_fail ("(IsFirstTime || Current != End) && \"cannot iterate past end\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 2043, __PRETTY_FUNCTION__))
;
2044 if (!IsFirstTime)
2045 ++Current;
2046 while (Current != End) {
2047 SmallString<128> PathStr(Dir);
2048 llvm::sys::path::append(PathStr, (*Current)->getName());
2049 sys::fs::file_type Type;
2050 switch ((*Current)->getKind()) {
2051 case RedirectingFileSystem::EK_Directory:
2052 Type = sys::fs::file_type::directory_file;
2053 break;
2054 case RedirectingFileSystem::EK_File:
2055 Type = sys::fs::file_type::regular_file;
2056 break;
2057 }
2058 CurrentEntry = directory_entry(PathStr.str(), Type);
2059 return {};
2060 }
2061 return incrementExternal();
2062}
2063
2064std::error_code VFSFromYamlDirIterImpl::incrementImpl(bool IsFirstTime) {
2065 while (true) {
2066 std::error_code EC = IsExternalFSCurrent ? incrementExternal()
2067 : incrementContent(IsFirstTime);
2068 if (EC || CurrentEntry.path().empty())
2069 return EC;
2070 StringRef Name = llvm::sys::path::filename(CurrentEntry.path());
2071 if (SeenNames.insert(Name).second)
2072 return EC; // name not seen before
2073 }
2074 llvm_unreachable("returned above")::llvm::llvm_unreachable_internal("returned above", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 2074)
;
2075}
2076
2077vfs::recursive_directory_iterator::recursive_directory_iterator(
2078 FileSystem &FS_, const Twine &Path, std::error_code &EC)
2079 : FS(&FS_) {
2080 directory_iterator I = FS->dir_begin(Path, EC);
2081 if (I != directory_iterator()) {
2082 State = std::make_shared<detail::RecDirIterState>();
2083 State->Stack.push(I);
2084 }
2085}
2086
2087vfs::recursive_directory_iterator &
2088recursive_directory_iterator::increment(std::error_code &EC) {
2089 assert(FS && State && !State->Stack.empty() && "incrementing past end")((FS && State && !State->Stack.empty() &&
"incrementing past end") ? static_cast<void> (0) : __assert_fail
("FS && State && !State->Stack.empty() && \"incrementing past end\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 2089, __PRETTY_FUNCTION__))
;
2090 assert(!State->Stack.top()->path().empty() && "non-canonical end iterator")((!State->Stack.top()->path().empty() && "non-canonical end iterator"
) ? static_cast<void> (0) : __assert_fail ("!State->Stack.top()->path().empty() && \"non-canonical end iterator\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Support/VirtualFileSystem.cpp"
, 2090, __PRETTY_FUNCTION__))
;
2091 vfs::directory_iterator End;
2092
2093 if (State->HasNoPushRequest)
2094 State->HasNoPushRequest = false;
2095 else {
2096 if (State->Stack.top()->type() == sys::fs::file_type::directory_file) {
2097 vfs::directory_iterator I = FS->dir_begin(State->Stack.top()->path(), EC);
2098 if (I != End) {
2099 State->Stack.push(I);
2100 return *this;
2101 }
2102 }
2103 }
2104
2105 while (!State->Stack.empty() && State->Stack.top().increment(EC) == End)
2106 State->Stack.pop();
2107
2108 if (State->Stack.empty())
2109 State.reset(); // end iterator
2110
2111 return *this;
2112}