LLVM  10.0.0svn
VirtualFileSystem.cpp
Go to the documentation of this file.
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 
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/DenseMap.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"
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"
33 #include "llvm/Support/ErrorOr.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"
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 
56 using namespace llvm;
57 using namespace llvm::vfs;
58 
65 
67  : UID(Status.getUniqueID()), MTime(Status.getLastModificationTime()),
68  User(Status.getUser()), Group(Status.getGroup()), Size(Status.getSize()),
69  Type(Status.type()), Perms(Status.permissions()) {}
70 
71 Status::Status(const Twine &Name, UniqueID UID, sys::TimePoint<> MTime,
72  uint32_t User, uint32_t Group, uint64_t Size, file_type Type,
73  perms Perms)
74  : Name(Name.str()), UID(UID), MTime(MTime), User(User), Group(Group),
75  Size(Size), Type(Type), Perms(Perms) {}
76 
77 Status Status::copyWithNewName(const Status &In, const Twine &NewName) {
78  return Status(NewName, In.getUniqueID(), In.getLastModificationTime(),
79  In.getUser(), In.getGroup(), In.getSize(), In.getType(),
80  In.getPermissions());
81 }
82 
84  return Status(NewName, In.getUniqueID(), In.getLastModificationTime(),
85  In.getUser(), In.getGroup(), In.getSize(), In.type(),
86  In.permissions());
87 }
88 
89 bool Status::equivalent(const Status &Other) const {
90  assert(isStatusKnown() && Other.isStatusKnown());
91  return getUniqueID() == Other.getUniqueID();
92 }
93 
94 bool Status::isDirectory() const { return Type == file_type::directory_file; }
95 
96 bool Status::isRegularFile() const { return Type == file_type::regular_file; }
97 
98 bool Status::isOther() const {
99  return exists() && !isRegularFile() && !isDirectory() && !isSymlink();
100 }
101 
102 bool Status::isSymlink() const { return Type == file_type::symlink_file; }
103 
104 bool Status::isStatusKnown() const { return Type != file_type::status_error; }
105 
106 bool Status::exists() const {
107  return isStatusKnown() && Type != file_type::file_not_found;
108 }
109 
110 File::~File() = default;
111 
112 FileSystem::~FileSystem() = default;
113 
115 FileSystem::getBufferForFile(const llvm::Twine &Name, int64_t FileSize,
116  bool RequiresNullTerminator, bool IsVolatile) {
117  auto F = openFileForRead(Name);
118  if (!F)
119  return F.getError();
120 
121  return (*F)->getBuffer(Name, FileSize, RequiresNullTerminator, IsVolatile);
122 }
123 
124 std::error_code FileSystem::makeAbsolute(SmallVectorImpl<char> &Path) const {
126  return {};
127 
128  auto WorkingDir = getCurrentWorkingDirectory();
129  if (!WorkingDir)
130  return WorkingDir.getError();
131 
132  llvm::sys::fs::make_absolute(WorkingDir.get(), Path);
133  return {};
134 }
135 
136 std::error_code FileSystem::getRealPath(const Twine &Path,
137  SmallVectorImpl<char> &Output) const {
139 }
140 
141 std::error_code FileSystem::isLocal(const Twine &Path, bool &Result) {
143 }
144 
145 bool FileSystem::exists(const Twine &Path) {
146  auto Status = status(Path);
147  return Status && Status->exists();
148 }
149 
150 #ifndef NDEBUG
151 static bool isTraversalComponent(StringRef Component) {
152  return Component.equals("..") || Component.equals(".");
153 }
154 
155 static bool pathHasTraversal(StringRef Path) {
156  using namespace llvm::sys;
157 
158  for (StringRef Comp : llvm::make_range(path::begin(Path), path::end(Path)))
159  if (isTraversalComponent(Comp))
160  return true;
161  return false;
162 }
163 #endif
164 
165 //===-----------------------------------------------------------------------===/
166 // RealFileSystem implementation
167 //===-----------------------------------------------------------------------===/
168 
169 namespace {
170 
171 /// Wrapper around a raw file descriptor.
172 class RealFile : public File {
173  friend class RealFileSystem;
174 
175  file_t FD;
176  Status S;
177  std::string RealName;
178 
179  RealFile(file_t FD, StringRef NewName, StringRef NewRealPathName)
180  : FD(FD), S(NewName, {}, {}, {}, {}, {},
182  RealName(NewRealPathName.str()) {
183  assert(FD != kInvalidFile && "Invalid or inactive file descriptor");
184  }
185 
186 public:
187  ~RealFile() override;
188 
189  ErrorOr<Status> status() override;
190  ErrorOr<std::string> getName() override;
191  ErrorOr<std::unique_ptr<MemoryBuffer>> getBuffer(const Twine &Name,
192  int64_t FileSize,
193  bool RequiresNullTerminator,
194  bool IsVolatile) override;
195  std::error_code close() override;
196 };
197 
198 } // namespace
199 
200 RealFile::~RealFile() { close(); }
201 
203  assert(FD != kInvalidFile && "cannot stat closed file");
204  if (!S.isStatusKnown()) {
205  file_status RealStatus;
206  if (std::error_code EC = sys::fs::status(FD, RealStatus))
207  return EC;
208  S = Status::copyWithNewName(RealStatus, S.getName());
209  }
210  return S;
211 }
212 
214  return RealName.empty() ? S.getName().str() : RealName;
215 }
216 
218 RealFile::getBuffer(const Twine &Name, int64_t FileSize,
219  bool RequiresNullTerminator, bool IsVolatile) {
220  assert(FD != kInvalidFile && "cannot get buffer for closed file");
221  return MemoryBuffer::getOpenFile(FD, Name, FileSize, RequiresNullTerminator,
222  IsVolatile);
223 }
224 
225 std::error_code RealFile::close() {
226  std::error_code EC = sys::fs::closeFile(FD);
227  FD = kInvalidFile;
228  return EC;
229 }
230 
231 namespace {
232 
233 /// A file system according to your operating system.
234 /// This may be linked to the process's working directory, or maintain its own.
235 ///
236 /// Currently, its own working directory is emulated by storing the path and
237 /// sending absolute paths to llvm::sys::fs:: functions.
238 /// A more principled approach would be to push this down a level, modelling
239 /// the working dir as an llvm::sys::fs::WorkingDir or similar.
240 /// This would enable the use of openat()-style functions on some platforms.
241 class RealFileSystem : public FileSystem {
242 public:
243  explicit RealFileSystem(bool LinkCWDToProcess) {
244  if (!LinkCWDToProcess) {
245  SmallString<128> PWD, RealPWD;
247  return; // Awful, but nothing to do here.
248  if (llvm::sys::fs::real_path(PWD, RealPWD))
249  WD = {PWD, PWD};
250  else
251  WD = {PWD, RealPWD};
252  }
253  }
254 
255  ErrorOr<Status> status(const Twine &Path) override;
256  ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
257  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
258 
259  llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override;
260  std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
261  std::error_code isLocal(const Twine &Path, bool &Result) override;
262  std::error_code getRealPath(const Twine &Path,
263  SmallVectorImpl<char> &Output) const override;
264 
265 private:
266  // If this FS has its own working dir, use it to make Path absolute.
267  // The returned twine is safe to use as long as both Storage and Path live.
268  Twine adjustPath(const Twine &Path, SmallVectorImpl<char> &Storage) const {
269  if (!WD)
270  return Path;
271  Path.toVector(Storage);
272  sys::fs::make_absolute(WD->Resolved, Storage);
273  return Storage;
274  }
275 
276  struct WorkingDirectory {
277  // The current working directory, without symlinks resolved. (echo $PWD).
278  SmallString<128> Specified;
279  // The current working directory, with links resolved. (readlink .).
280  SmallString<128> Resolved;
281  };
283 };
284 
285 } // namespace
286 
288  SmallString<256> Storage;
289  sys::fs::file_status RealStatus;
290  if (std::error_code EC =
291  sys::fs::status(adjustPath(Path, Storage), RealStatus))
292  return EC;
293  return Status::copyWithNewName(RealStatus, Path);
294 }
295 
298  SmallString<256> RealName, Storage;
300  adjustPath(Name, Storage), sys::fs::OF_None, &RealName);
301  if (!FDOrErr)
302  return errorToErrorCode(FDOrErr.takeError());
303  return std::unique_ptr<File>(
304  new RealFile(*FDOrErr, Name.str(), RealName.str()));
305 }
306 
307 llvm::ErrorOr<std::string> RealFileSystem::getCurrentWorkingDirectory() const {
308  if (WD)
309  return WD->Specified.str();
310 
311  SmallString<128> Dir;
312  if (std::error_code EC = llvm::sys::fs::current_path(Dir))
313  return EC;
314  return Dir.str();
315 }
316 
317 std::error_code RealFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
318  if (!WD)
319  return llvm::sys::fs::set_current_path(Path);
320 
321  SmallString<128> Absolute, Resolved, Storage;
322  adjustPath(Path, Storage).toVector(Absolute);
323  bool IsDir;
324  if (auto Err = llvm::sys::fs::is_directory(Absolute, IsDir))
325  return Err;
326  if (!IsDir)
327  return std::make_error_code(std::errc::not_a_directory);
328  if (auto Err = llvm::sys::fs::real_path(Absolute, Resolved))
329  return Err;
330  WD = {Absolute, Resolved};
331  return std::error_code();
332 }
333 
334 std::error_code RealFileSystem::isLocal(const Twine &Path, bool &Result) {
335  SmallString<256> Storage;
336  return llvm::sys::fs::is_local(adjustPath(Path, Storage), Result);
337 }
338 
339 std::error_code
340 RealFileSystem::getRealPath(const Twine &Path,
341  SmallVectorImpl<char> &Output) const {
342  SmallString<256> Storage;
343  return llvm::sys::fs::real_path(adjustPath(Path, Storage), Output);
344 }
345 
347  static IntrusiveRefCntPtr<FileSystem> FS(new RealFileSystem(true));
348  return FS;
349 }
350 
351 std::unique_ptr<FileSystem> vfs::createPhysicalFileSystem() {
352  return llvm::make_unique<RealFileSystem>(false);
353 }
354 
355 namespace {
356 
357 class RealFSDirIter : public llvm::vfs::detail::DirIterImpl {
359 
360 public:
361  RealFSDirIter(const Twine &Path, std::error_code &EC) : Iter(Path, EC) {
362  if (Iter != llvm::sys::fs::directory_iterator())
363  CurrentEntry = directory_entry(Iter->path(), Iter->type());
364  }
365 
366  std::error_code increment() override {
367  std::error_code EC;
368  Iter.increment(EC);
369  CurrentEntry = (Iter == llvm::sys::fs::directory_iterator())
370  ? directory_entry()
371  : directory_entry(Iter->path(), Iter->type());
372  return EC;
373  }
374 };
375 
376 } // namespace
377 
378 directory_iterator RealFileSystem::dir_begin(const Twine &Dir,
379  std::error_code &EC) {
380  SmallString<128> Storage;
381  return directory_iterator(
382  std::make_shared<RealFSDirIter>(adjustPath(Dir, Storage), EC));
383 }
384 
385 //===-----------------------------------------------------------------------===/
386 // OverlayFileSystem implementation
387 //===-----------------------------------------------------------------------===/
388 
390  FSList.push_back(std::move(BaseFS));
391 }
392 
394  FSList.push_back(FS);
395  // Synchronize added file systems by duplicating the working directory from
396  // the first one in the list.
397  FS->setCurrentWorkingDirectory(getCurrentWorkingDirectory().get());
398 }
399 
401  // FIXME: handle symlinks that cross file systems
402  for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
403  ErrorOr<Status> Status = (*I)->status(Path);
404  if (Status || Status.getError() != llvm::errc::no_such_file_or_directory)
405  return Status;
406  }
408 }
409 
412  // FIXME: handle symlinks that cross file systems
413  for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
414  auto Result = (*I)->openFileForRead(Path);
415  if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
416  return Result;
417  }
419 }
420 
423  // All file systems are synchronized, just take the first working directory.
424  return FSList.front()->getCurrentWorkingDirectory();
425 }
426 
427 std::error_code
429  for (auto &FS : FSList)
430  if (std::error_code EC = FS->setCurrentWorkingDirectory(Path))
431  return EC;
432  return {};
433 }
434 
435 std::error_code OverlayFileSystem::isLocal(const Twine &Path, bool &Result) {
436  for (auto &FS : FSList)
437  if (FS->exists(Path))
438  return FS->isLocal(Path, Result);
440 }
441 
442 std::error_code
444  SmallVectorImpl<char> &Output) const {
445  for (auto &FS : FSList)
446  if (FS->exists(Path))
447  return FS->getRealPath(Path, Output);
449 }
450 
452 
453 namespace {
454 
455 class OverlayFSDirIterImpl : public llvm::vfs::detail::DirIterImpl {
456  OverlayFileSystem &Overlays;
457  std::string Path;
458  OverlayFileSystem::iterator CurrentFS;
459  directory_iterator CurrentDirIter;
460  llvm::StringSet<> SeenNames;
461 
462  std::error_code incrementFS() {
463  assert(CurrentFS != Overlays.overlays_end() && "incrementing past end");
464  ++CurrentFS;
465  for (auto E = Overlays.overlays_end(); CurrentFS != E; ++CurrentFS) {
466  std::error_code EC;
467  CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
468  if (EC && EC != errc::no_such_file_or_directory)
469  return EC;
470  if (CurrentDirIter != directory_iterator())
471  break; // found
472  }
473  return {};
474  }
475 
476  std::error_code incrementDirIter(bool IsFirstTime) {
477  assert((IsFirstTime || CurrentDirIter != directory_iterator()) &&
478  "incrementing past end");
479  std::error_code EC;
480  if (!IsFirstTime)
481  CurrentDirIter.increment(EC);
482  if (!EC && CurrentDirIter == directory_iterator())
483  EC = incrementFS();
484  return EC;
485  }
486 
487  std::error_code incrementImpl(bool IsFirstTime) {
488  while (true) {
489  std::error_code EC = incrementDirIter(IsFirstTime);
490  if (EC || CurrentDirIter == directory_iterator()) {
491  CurrentEntry = directory_entry();
492  return EC;
493  }
494  CurrentEntry = *CurrentDirIter;
495  StringRef Name = llvm::sys::path::filename(CurrentEntry.path());
496  if (SeenNames.insert(Name).second)
497  return EC; // name not seen before
498  }
499  llvm_unreachable("returned above");
500  }
501 
502 public:
503  OverlayFSDirIterImpl(const Twine &Path, OverlayFileSystem &FS,
504  std::error_code &EC)
505  : Overlays(FS), Path(Path.str()), CurrentFS(Overlays.overlays_begin()) {
506  CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
507  EC = incrementImpl(true);
508  }
509 
510  std::error_code increment() override { return incrementImpl(false); }
511 };
512 
513 } // namespace
514 
516  std::error_code &EC) {
517  return directory_iterator(
518  std::make_shared<OverlayFSDirIterImpl>(Dir, *this, EC));
519 }
520 
521 void ProxyFileSystem::anchor() {}
522 
523 namespace llvm {
524 namespace vfs {
525 
526 namespace detail {
527 
529 
530 /// The in memory file system is a tree of Nodes. Every node can either be a
531 /// file , hardlink or a directory.
534  std::string FileName;
535 
536 public:
538  : Kind(Kind), FileName(llvm::sys::path::filename(FileName)) {}
539  virtual ~InMemoryNode() = default;
540 
541  /// Get the filename of this node (the name without the directory part).
542  StringRef getFileName() const { return FileName; }
543  InMemoryNodeKind getKind() const { return Kind; }
544  virtual std::string toString(unsigned Indent) const = 0;
545 };
546 
547 class InMemoryFile : public InMemoryNode {
548  Status Stat;
549  std::unique_ptr<llvm::MemoryBuffer> Buffer;
550 
551 public:
552  InMemoryFile(Status Stat, std::unique_ptr<llvm::MemoryBuffer> Buffer)
553  : InMemoryNode(Stat.getName(), IME_File), Stat(std::move(Stat)),
554  Buffer(std::move(Buffer)) {}
555 
556  /// Return the \p Status for this node. \p RequestedName should be the name
557  /// through which the caller referred to this node. It will override
558  /// \p Status::Name in the return value, to mimic the behavior of \p RealFile.
559  Status getStatus(const Twine &RequestedName) const {
560  return Status::copyWithNewName(Stat, RequestedName);
561  }
562  llvm::MemoryBuffer *getBuffer() const { return Buffer.get(); }
563 
564  std::string toString(unsigned Indent) const override {
565  return (std::string(Indent, ' ') + Stat.getName() + "\n").str();
566  }
567 
568  static bool classof(const InMemoryNode *N) {
569  return N->getKind() == IME_File;
570  }
571 };
572 
573 namespace {
574 
575 class InMemoryHardLink : public InMemoryNode {
576  const InMemoryFile &ResolvedFile;
577 
578 public:
579  InMemoryHardLink(StringRef Path, const InMemoryFile &ResolvedFile)
580  : InMemoryNode(Path, IME_HardLink), ResolvedFile(ResolvedFile) {}
581  const InMemoryFile &getResolvedFile() const { return ResolvedFile; }
582 
583  std::string toString(unsigned Indent) const override {
584  return std::string(Indent, ' ') + "HardLink to -> " +
585  ResolvedFile.toString(0);
586  }
587 
588  static bool classof(const InMemoryNode *N) {
589  return N->getKind() == IME_HardLink;
590  }
591 };
592 
593 /// Adapt a InMemoryFile for VFS' File interface. The goal is to make
594 /// \p InMemoryFileAdaptor mimic as much as possible the behavior of
595 /// \p RealFile.
596 class InMemoryFileAdaptor : public File {
597  const InMemoryFile &Node;
598  /// The name to use when returning a Status for this file.
599  std::string RequestedName;
600 
601 public:
602  explicit InMemoryFileAdaptor(const InMemoryFile &Node,
603  std::string RequestedName)
604  : Node(Node), RequestedName(std::move(RequestedName)) {}
605 
606  llvm::ErrorOr<Status> status() override {
607  return Node.getStatus(RequestedName);
608  }
609 
611  getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
612  bool IsVolatile) override {
613  llvm::MemoryBuffer *Buf = Node.getBuffer();
615  Buf->getBuffer(), Buf->getBufferIdentifier(), RequiresNullTerminator);
616  }
617 
618  std::error_code close() override { return {}; }
619 };
620 } // namespace
621 
623  Status Stat;
625 
626 public:
628  : InMemoryNode(Stat.getName(), IME_Directory), Stat(std::move(Stat)) {}
629 
630  /// Return the \p Status for this node. \p RequestedName should be the name
631  /// through which the caller referred to this node. It will override
632  /// \p Status::Name in the return value, to mimic the behavior of \p RealFile.
633  Status getStatus(const Twine &RequestedName) const {
634  return Status::copyWithNewName(Stat, RequestedName);
635  }
637  auto I = Entries.find(Name);
638  if (I != Entries.end())
639  return I->second.get();
640  return nullptr;
641  }
642 
643  InMemoryNode *addChild(StringRef Name, std::unique_ptr<InMemoryNode> Child) {
644  return Entries.insert(make_pair(Name, std::move(Child)))
645  .first->second.get();
646  }
647 
648  using const_iterator = decltype(Entries)::const_iterator;
649 
650  const_iterator begin() const { return Entries.begin(); }
651  const_iterator end() const { return Entries.end(); }
652 
653  std::string toString(unsigned Indent) const override {
654  std::string Result =
655  (std::string(Indent, ' ') + Stat.getName() + "\n").str();
656  for (const auto &Entry : Entries)
657  Result += Entry.second->toString(Indent + 2);
658  return Result;
659  }
660 
661  static bool classof(const InMemoryNode *N) {
662  return N->getKind() == IME_Directory;
663  }
664 };
665 
666 namespace {
667 Status getNodeStatus(const InMemoryNode *Node, const Twine &RequestedName) {
668  if (auto Dir = dyn_cast<detail::InMemoryDirectory>(Node))
669  return Dir->getStatus(RequestedName);
670  if (auto File = dyn_cast<detail::InMemoryFile>(Node))
671  return File->getStatus(RequestedName);
672  if (auto Link = dyn_cast<detail::InMemoryHardLink>(Node))
673  return Link->getResolvedFile().getStatus(RequestedName);
674  llvm_unreachable("Unknown node type");
675 }
676 } // namespace
677 } // namespace detail
678 
680  : Root(new detail::InMemoryDirectory(
681  Status("", getNextVirtualUniqueID(), llvm::sys::TimePoint<>(), 0, 0,
682  0, llvm::sys::fs::file_type::directory_file,
683  llvm::sys::fs::perms::all_all))),
684  UseNormalizedPaths(UseNormalizedPaths) {}
685 
687 
688 std::string InMemoryFileSystem::toString() const {
689  return Root->toString(/*Indent=*/0);
690 }
691 
692 bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime,
693  std::unique_ptr<llvm::MemoryBuffer> Buffer,
694  Optional<uint32_t> User,
695  Optional<uint32_t> Group,
698  const detail::InMemoryFile *HardLinkTarget) {
699  SmallString<128> Path;
700  P.toVector(Path);
701 
702  // Fix up relative paths. This just prepends the current working directory.
703  std::error_code EC = makeAbsolute(Path);
704  assert(!EC);
705  (void)EC;
706 
707  if (useNormalizedPaths())
708  llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
709 
710  if (Path.empty())
711  return false;
712 
713  detail::InMemoryDirectory *Dir = Root.get();
714  auto I = llvm::sys::path::begin(Path), E = sys::path::end(Path);
715  const auto ResolvedUser = User.getValueOr(0);
716  const auto ResolvedGroup = Group.getValueOr(0);
717  const auto ResolvedType = Type.getValueOr(sys::fs::file_type::regular_file);
718  const auto ResolvedPerms = Perms.getValueOr(sys::fs::all_all);
719  assert(!(HardLinkTarget && Buffer) && "HardLink cannot have a buffer");
720  // Any intermediate directories we create should be accessible by
721  // the owner, even if Perms says otherwise for the final path.
722  const auto NewDirectoryPerms = ResolvedPerms | sys::fs::owner_all;
723  while (true) {
724  StringRef Name = *I;
725  detail::InMemoryNode *Node = Dir->getChild(Name);
726  ++I;
727  if (!Node) {
728  if (I == E) {
729  // End of the path.
730  std::unique_ptr<detail::InMemoryNode> Child;
731  if (HardLinkTarget)
732  Child.reset(new detail::InMemoryHardLink(P.str(), *HardLinkTarget));
733  else {
734  // Create a new file or directory.
735  Status Stat(P.str(), getNextVirtualUniqueID(),
736  llvm::sys::toTimePoint(ModificationTime), ResolvedUser,
737  ResolvedGroup, Buffer->getBufferSize(), ResolvedType,
738  ResolvedPerms);
739  if (ResolvedType == sys::fs::file_type::directory_file) {
740  Child.reset(new detail::InMemoryDirectory(std::move(Stat)));
741  } else {
742  Child.reset(
743  new detail::InMemoryFile(std::move(Stat), std::move(Buffer)));
744  }
745  }
746  Dir->addChild(Name, std::move(Child));
747  return true;
748  }
749 
750  // Create a new directory. Use the path up to here.
751  Status Stat(
752  StringRef(Path.str().begin(), Name.end() - Path.str().begin()),
753  getNextVirtualUniqueID(), llvm::sys::toTimePoint(ModificationTime),
754  ResolvedUser, ResolvedGroup, 0, sys::fs::file_type::directory_file,
755  NewDirectoryPerms);
756  Dir = cast<detail::InMemoryDirectory>(Dir->addChild(
757  Name, llvm::make_unique<detail::InMemoryDirectory>(std::move(Stat))));
758  continue;
759  }
760 
761  if (auto *NewDir = dyn_cast<detail::InMemoryDirectory>(Node)) {
762  Dir = NewDir;
763  } else {
764  assert((isa<detail::InMemoryFile>(Node) ||
765  isa<detail::InMemoryHardLink>(Node)) &&
766  "Must be either file, hardlink or directory!");
767 
768  // Trying to insert a directory in place of a file.
769  if (I != E)
770  return false;
771 
772  // Return false only if the new file is different from the existing one.
773  if (auto Link = dyn_cast<detail::InMemoryHardLink>(Node)) {
774  return Link->getResolvedFile().getBuffer()->getBuffer() ==
775  Buffer->getBuffer();
776  }
777  return cast<detail::InMemoryFile>(Node)->getBuffer()->getBuffer() ==
778  Buffer->getBuffer();
779  }
780  }
781 }
782 
783 bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime,
784  std::unique_ptr<llvm::MemoryBuffer> Buffer,
785  Optional<uint32_t> User,
786  Optional<uint32_t> Group,
789  return addFile(P, ModificationTime, std::move(Buffer), User, Group, Type,
790  Perms, /*HardLinkTarget=*/nullptr);
791 }
792 
793 bool InMemoryFileSystem::addFileNoOwn(const Twine &P, time_t ModificationTime,
794  llvm::MemoryBuffer *Buffer,
795  Optional<uint32_t> User,
796  Optional<uint32_t> Group,
799  return addFile(P, ModificationTime,
801  Buffer->getBuffer(), Buffer->getBufferIdentifier()),
802  std::move(User), std::move(Group), std::move(Type),
803  std::move(Perms));
804 }
805 
808  const Twine &P) {
809  SmallString<128> Path;
810  P.toVector(Path);
811 
812  // Fix up relative paths. This just prepends the current working directory.
813  std::error_code EC = FS.makeAbsolute(Path);
814  assert(!EC);
815  (void)EC;
816 
817  if (FS.useNormalizedPaths())
818  llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
819 
820  if (Path.empty())
821  return Dir;
822 
823  auto I = llvm::sys::path::begin(Path), E = llvm::sys::path::end(Path);
824  while (true) {
825  detail::InMemoryNode *Node = Dir->getChild(*I);
826  ++I;
827  if (!Node)
829 
830  // Return the file if it's at the end of the path.
831  if (auto File = dyn_cast<detail::InMemoryFile>(Node)) {
832  if (I == E)
833  return File;
835  }
836 
837  // If Node is HardLink then return the resolved file.
838  if (auto File = dyn_cast<detail::InMemoryHardLink>(Node)) {
839  if (I == E)
840  return &File->getResolvedFile();
842  }
843  // Traverse directories.
844  Dir = cast<detail::InMemoryDirectory>(Node);
845  if (I == E)
846  return Dir;
847  }
848 }
849 
851  const Twine &ToPath) {
852  auto FromNode = lookupInMemoryNode(*this, Root.get(), FromPath);
853  auto ToNode = lookupInMemoryNode(*this, Root.get(), ToPath);
854  // FromPath must not have been added before. ToPath must have been added
855  // before. Resolved ToPath must be a File.
856  if (!ToNode || FromNode || !isa<detail::InMemoryFile>(*ToNode))
857  return false;
858  return this->addFile(FromPath, 0, nullptr, None, None, None, None,
859  cast<detail::InMemoryFile>(*ToNode));
860 }
861 
863  auto Node = lookupInMemoryNode(*this, Root.get(), Path);
864  if (Node)
865  return detail::getNodeStatus(*Node, Path);
866  return Node.getError();
867 }
868 
871  auto Node = lookupInMemoryNode(*this, Root.get(), Path);
872  if (!Node)
873  return Node.getError();
874 
875  // When we have a file provide a heap-allocated wrapper for the memory buffer
876  // to match the ownership semantics for File.
877  if (auto *F = dyn_cast<detail::InMemoryFile>(*Node))
878  return std::unique_ptr<File>(
879  new detail::InMemoryFileAdaptor(*F, Path.str()));
880 
881  // FIXME: errc::not_a_file?
883 }
884 
885 namespace {
886 
887 /// Adaptor from InMemoryDir::iterator to directory_iterator.
888 class InMemoryDirIterator : public llvm::vfs::detail::DirIterImpl {
891  std::string RequestedDirName;
892 
893  void setCurrentEntry() {
894  if (I != E) {
895  SmallString<256> Path(RequestedDirName);
896  llvm::sys::path::append(Path, I->second->getFileName());
897  sys::fs::file_type Type;
898  switch (I->second->getKind()) {
899  case detail::IME_File:
902  break;
905  break;
906  }
907  CurrentEntry = directory_entry(Path.str(), Type);
908  } else {
909  // When we're at the end, make CurrentEntry invalid and DirIterImpl will
910  // do the rest.
911  CurrentEntry = directory_entry();
912  }
913  }
914 
915 public:
916  InMemoryDirIterator() = default;
917 
918  explicit InMemoryDirIterator(const detail::InMemoryDirectory &Dir,
919  std::string RequestedDirName)
920  : I(Dir.begin()), E(Dir.end()),
921  RequestedDirName(std::move(RequestedDirName)) {
922  setCurrentEntry();
923  }
924 
925  std::error_code increment() override {
926  ++I;
927  setCurrentEntry();
928  return {};
929  }
930 };
931 
932 } // namespace
933 
935  std::error_code &EC) {
936  auto Node = lookupInMemoryNode(*this, Root.get(), Dir);
937  if (!Node) {
938  EC = Node.getError();
939  return directory_iterator(std::make_shared<InMemoryDirIterator>());
940  }
941 
942  if (auto *DirNode = dyn_cast<detail::InMemoryDirectory>(*Node))
943  return directory_iterator(
944  std::make_shared<InMemoryDirIterator>(*DirNode, Dir.str()));
945 
947  return directory_iterator(std::make_shared<InMemoryDirIterator>());
948 }
949 
951  SmallString<128> Path;
952  P.toVector(Path);
953 
954  // Fix up relative paths. This just prepends the current working directory.
955  std::error_code EC = makeAbsolute(Path);
956  assert(!EC);
957  (void)EC;
958 
959  if (useNormalizedPaths())
960  llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
961 
962  if (!Path.empty())
963  WorkingDirectory = Path.str();
964  return {};
965 }
966 
967 std::error_code
969  SmallVectorImpl<char> &Output) const {
970  auto CWD = getCurrentWorkingDirectory();
971  if (!CWD || CWD->empty())
973  Path.toVector(Output);
974  if (auto EC = makeAbsolute(Output))
975  return EC;
976  llvm::sys::path::remove_dots(Output, /*remove_dot_dot=*/true);
977  return {};
978 }
979 
980 std::error_code InMemoryFileSystem::isLocal(const Twine &Path, bool &Result) {
981  Result = false;
982  return {};
983 }
984 
985 } // namespace vfs
986 } // namespace llvm
987 
988 //===-----------------------------------------------------------------------===/
989 // RedirectingFileSystem implementation
990 //===-----------------------------------------------------------------------===/
991 
992 // FIXME: reuse implementation common with OverlayFSDirIterImpl as these
993 // iterators are conceptually similar.
996  std::string Dir;
998 
999  // To handle 'fallthrough' mode we need to iterate at first through
1000  // RedirectingDirectoryEntry and then through ExternalFS. These operations are
1001  // done sequentially, we just need to keep a track of what kind of iteration
1002  // we are currently performing.
1003 
1004  /// Flag telling if we should iterate through ExternalFS or stop at the last
1005  /// RedirectingDirectoryEntry::iterator.
1006  bool IterateExternalFS;
1007  /// Flag telling if we have switched to iterating through ExternalFS.
1008  bool IsExternalFSCurrent = false;
1009  FileSystem &ExternalFS;
1010  directory_iterator ExternalDirIter;
1011  llvm::StringSet<> SeenNames;
1012 
1013  /// To combine multiple iterations, different methods are responsible for
1014  /// different iteration steps.
1015  /// @{
1016 
1017  /// Responsible for dispatching between RedirectingDirectoryEntry iteration
1018  /// and ExternalFS iteration.
1019  std::error_code incrementImpl(bool IsFirstTime);
1020  /// Responsible for RedirectingDirectoryEntry iteration.
1021  std::error_code incrementContent(bool IsFirstTime);
1022  /// Responsible for ExternalFS iteration.
1023  std::error_code incrementExternal();
1024  /// @}
1025 
1026 public:
1028  const Twine &Path,
1031  bool IterateExternalFS, FileSystem &ExternalFS, std::error_code &EC);
1032 
1033  std::error_code increment() override;
1034 };
1035 
1038  return ExternalFS->getCurrentWorkingDirectory();
1039 }
1040 
1041 std::error_code
1043  return ExternalFS->setCurrentWorkingDirectory(Path);
1044 }
1045 
1046 std::error_code RedirectingFileSystem::isLocal(const Twine &Path,
1047  bool &Result) {
1048  return ExternalFS->isLocal(Path, Result);
1049 }
1050 
1052  std::error_code &EC) {
1053  ErrorOr<RedirectingFileSystem::Entry *> E = lookupPath(Dir);
1054  if (!E) {
1055  EC = E.getError();
1056  if (IsFallthrough && EC == errc::no_such_file_or_directory)
1057  return ExternalFS->dir_begin(Dir, EC);
1058  return {};
1059  }
1060  ErrorOr<Status> S = status(Dir, *E);
1061  if (!S) {
1062  EC = S.getError();
1063  return {};
1064  }
1065  if (!S->isDirectory()) {
1066  EC = std::error_code(static_cast<int>(errc::not_a_directory),
1067  std::system_category());
1068  return {};
1069  }
1070 
1071  auto *D = cast<RedirectingFileSystem::RedirectingDirectoryEntry>(*E);
1072  return directory_iterator(std::make_shared<VFSFromYamlDirIterImpl>(
1073  Dir, D->contents_begin(), D->contents_end(),
1074  /*IterateExternalFS=*/IsFallthrough, *ExternalFS, EC));
1075 }
1076 
1078  ExternalContentsPrefixDir = PrefixDir.str();
1079 }
1080 
1082  return ExternalContentsPrefixDir;
1083 }
1084 
1085 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1087  for (const auto &Root : Roots)
1088  dumpEntry(Root.get());
1089 }
1090 
1091 LLVM_DUMP_METHOD void
1093  int NumSpaces) const {
1094  StringRef Name = E->getName();
1095  for (int i = 0, e = NumSpaces; i < e; ++i)
1096  dbgs() << " ";
1097  dbgs() << "'" << Name.str().c_str() << "'"
1098  << "\n";
1099 
1102  assert(DE && "Should be a directory");
1103 
1104  for (std::unique_ptr<Entry> &SubEntry :
1105  llvm::make_range(DE->contents_begin(), DE->contents_end()))
1106  dumpEntry(SubEntry.get(), NumSpaces + 2);
1107  }
1108 }
1109 #endif
1110 
1111 /// A helper class to hold the common YAML parsing state.
1113  yaml::Stream &Stream;
1114 
1115  void error(yaml::Node *N, const Twine &Msg) { Stream.printError(N, Msg); }
1116 
1117  // false on error
1118  bool parseScalarString(yaml::Node *N, StringRef &Result,
1119  SmallVectorImpl<char> &Storage) {
1120  const auto *S = dyn_cast<yaml::ScalarNode>(N);
1121 
1122  if (!S) {
1123  error(N, "expected string");
1124  return false;
1125  }
1126  Result = S->getValue(Storage);
1127  return true;
1128  }
1129 
1130  // false on error
1131  bool parseScalarBool(yaml::Node *N, bool &Result) {
1132  SmallString<5> Storage;
1133  StringRef Value;
1134  if (!parseScalarString(N, Value, Storage))
1135  return false;
1136 
1137  if (Value.equals_lower("true") || Value.equals_lower("on") ||
1138  Value.equals_lower("yes") || Value == "1") {
1139  Result = true;
1140  return true;
1141  } else if (Value.equals_lower("false") || Value.equals_lower("off") ||
1142  Value.equals_lower("no") || Value == "0") {
1143  Result = false;
1144  return true;
1145  }
1146 
1147  error(N, "expected boolean value");
1148  return false;
1149  }
1150 
1151  struct KeyStatus {
1152  bool Required;
1153  bool Seen = false;
1154 
1155  KeyStatus(bool Required = false) : Required(Required) {}
1156  };
1157 
1158  using KeyStatusPair = std::pair<StringRef, KeyStatus>;
1159 
1160  // false on error
1161  bool checkDuplicateOrUnknownKey(yaml::Node *KeyNode, StringRef Key,
1163  if (!Keys.count(Key)) {
1164  error(KeyNode, "unknown key");
1165  return false;
1166  }
1167  KeyStatus &S = Keys[Key];
1168  if (S.Seen) {
1169  error(KeyNode, Twine("duplicate key '") + Key + "'");
1170  return false;
1171  }
1172  S.Seen = true;
1173  return true;
1174  }
1175 
1176  // false on error
1177  bool checkMissingKeys(yaml::Node *Obj, DenseMap<StringRef, KeyStatus> &Keys) {
1178  for (const auto &I : Keys) {
1179  if (I.second.Required && !I.second.Seen) {
1180  error(Obj, Twine("missing key '") + I.first + "'");
1181  return false;
1182  }
1183  }
1184  return true;
1185  }
1186 
1188  lookupOrCreateEntry(RedirectingFileSystem *FS, StringRef Name,
1189  RedirectingFileSystem::Entry *ParentEntry = nullptr) {
1190  if (!ParentEntry) { // Look for a existent root
1191  for (const auto &Root : FS->Roots) {
1192  if (Name.equals(Root->getName())) {
1193  ParentEntry = Root.get();
1194  return ParentEntry;
1195  }
1196  }
1197  } else { // Advance to the next component
1199  ParentEntry);
1200  for (std::unique_ptr<RedirectingFileSystem::Entry> &Content :
1201  llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1202  auto *DirContent =
1204  Content.get());
1205  if (DirContent && Name.equals(Content->getName()))
1206  return DirContent;
1207  }
1208  }
1209 
1210  // ... or create a new one
1211  std::unique_ptr<RedirectingFileSystem::Entry> E =
1212  llvm::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1214  std::chrono::system_clock::now(), 0, 0, 0,
1215  file_type::directory_file, sys::fs::all_all));
1216 
1217  if (!ParentEntry) { // Add a new root to the overlay
1218  FS->Roots.push_back(std::move(E));
1219  ParentEntry = FS->Roots.back().get();
1220  return ParentEntry;
1221  }
1222 
1223  auto *DE =
1225  DE->addContent(std::move(E));
1226  return DE->getLastContent();
1227  }
1228 
1229  void uniqueOverlayTree(RedirectingFileSystem *FS,
1231  RedirectingFileSystem::Entry *NewParentE = nullptr) {
1232  StringRef Name = SrcE->getName();
1233  switch (SrcE->getKind()) {
1235  auto *DE =
1237  assert(DE && "Must be a directory");
1238  // Empty directories could be present in the YAML as a way to
1239  // describe a file for a current directory after some of its subdir
1240  // is parsed. This only leads to redundant walks, ignore it.
1241  if (!Name.empty())
1242  NewParentE = lookupOrCreateEntry(FS, Name, NewParentE);
1243  for (std::unique_ptr<RedirectingFileSystem::Entry> &SubEntry :
1244  llvm::make_range(DE->contents_begin(), DE->contents_end()))
1245  uniqueOverlayTree(FS, SubEntry.get(), NewParentE);
1246  break;
1247  }
1250  assert(FE && "Must be a file");
1251  assert(NewParentE && "Parent entry must exist");
1253  NewParentE);
1254  DE->addContent(
1255  llvm::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
1256  Name, FE->getExternalContentsPath(), FE->getUseName()));
1257  break;
1258  }
1259  }
1260  }
1261 
1262  std::unique_ptr<RedirectingFileSystem::Entry>
1263  parseEntry(yaml::Node *N, RedirectingFileSystem *FS, bool IsRootEntry) {
1264  auto *M = dyn_cast<yaml::MappingNode>(N);
1265  if (!M) {
1266  error(N, "expected mapping node for file or directory entry");
1267  return nullptr;
1268  }
1269 
1270  KeyStatusPair Fields[] = {
1271  KeyStatusPair("name", true),
1272  KeyStatusPair("type", true),
1273  KeyStatusPair("contents", false),
1274  KeyStatusPair("external-contents", false),
1275  KeyStatusPair("use-external-name", false),
1276  };
1277 
1278  DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));
1279 
1280  bool HasContents = false; // external or otherwise
1281  std::vector<std::unique_ptr<RedirectingFileSystem::Entry>>
1282  EntryArrayContents;
1283  std::string ExternalContentsPath;
1284  std::string Name;
1285  yaml::Node *NameValueNode = nullptr;
1286  auto UseExternalName =
1289 
1290  for (auto &I : *M) {
1291  StringRef Key;
1292  // Reuse the buffer for key and value, since we don't look at key after
1293  // parsing value.
1294  SmallString<256> Buffer;
1295  if (!parseScalarString(I.getKey(), Key, Buffer))
1296  return nullptr;
1297 
1298  if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
1299  return nullptr;
1300 
1301  StringRef Value;
1302  if (Key == "name") {
1303  if (!parseScalarString(I.getValue(), Value, Buffer))
1304  return nullptr;
1305 
1306  NameValueNode = I.getValue();
1307  if (FS->UseCanonicalizedPaths) {
1308  SmallString<256> Path(Value);
1309  // Guarantee that old YAML files containing paths with ".." and "."
1310  // are properly canonicalized before read into the VFS.
1312  sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
1313  Name = Path.str();
1314  } else {
1315  Name = Value;
1316  }
1317  } else if (Key == "type") {
1318  if (!parseScalarString(I.getValue(), Value, Buffer))
1319  return nullptr;
1320  if (Value == "file")
1322  else if (Value == "directory")
1324  else {
1325  error(I.getValue(), "unknown value for 'type'");
1326  return nullptr;
1327  }
1328  } else if (Key == "contents") {
1329  if (HasContents) {
1330  error(I.getKey(),
1331  "entry already has 'contents' or 'external-contents'");
1332  return nullptr;
1333  }
1334  HasContents = true;
1335  auto *Contents = dyn_cast<yaml::SequenceNode>(I.getValue());
1336  if (!Contents) {
1337  // FIXME: this is only for directories, what about files?
1338  error(I.getValue(), "expected array");
1339  return nullptr;
1340  }
1341 
1342  for (auto &I : *Contents) {
1343  if (std::unique_ptr<RedirectingFileSystem::Entry> E =
1344  parseEntry(&I, FS, /*IsRootEntry*/ false))
1345  EntryArrayContents.push_back(std::move(E));
1346  else
1347  return nullptr;
1348  }
1349  } else if (Key == "external-contents") {
1350  if (HasContents) {
1351  error(I.getKey(),
1352  "entry already has 'contents' or 'external-contents'");
1353  return nullptr;
1354  }
1355  HasContents = true;
1356  if (!parseScalarString(I.getValue(), Value, Buffer))
1357  return nullptr;
1358 
1359  SmallString<256> FullPath;
1360  if (FS->IsRelativeOverlay) {
1361  FullPath = FS->getExternalContentsPrefixDir();
1362  assert(!FullPath.empty() &&
1363  "External contents prefix directory must exist");
1364  llvm::sys::path::append(FullPath, Value);
1365  } else {
1366  FullPath = Value;
1367  }
1368 
1369  if (FS->UseCanonicalizedPaths) {
1370  // Guarantee that old YAML files containing paths with ".." and "."
1371  // are properly canonicalized before read into the VFS.
1372  FullPath = sys::path::remove_leading_dotslash(FullPath);
1373  sys::path::remove_dots(FullPath, /*remove_dot_dot=*/true);
1374  }
1375  ExternalContentsPath = FullPath.str();
1376  } else if (Key == "use-external-name") {
1377  bool Val;
1378  if (!parseScalarBool(I.getValue(), Val))
1379  return nullptr;
1380  UseExternalName =
1383  } else {
1384  llvm_unreachable("key missing from Keys");
1385  }
1386  }
1387 
1388  if (Stream.failed())
1389  return nullptr;
1390 
1391  // check for missing keys
1392  if (!HasContents) {
1393  error(N, "missing key 'contents' or 'external-contents'");
1394  return nullptr;
1395  }
1396  if (!checkMissingKeys(N, Keys))
1397  return nullptr;
1398 
1399  // check invalid configuration
1401  UseExternalName !=
1403  error(N, "'use-external-name' is not supported for directories");
1404  return nullptr;
1405  }
1406 
1407  if (IsRootEntry && !sys::path::is_absolute(Name)) {
1408  assert(NameValueNode && "Name presence should be checked earlier");
1409  error(NameValueNode,
1410  "entry with relative path at the root level is not discoverable");
1411  return nullptr;
1412  }
1413 
1414  // Remove trailing slash(es), being careful not to remove the root path
1415  StringRef Trimmed(Name);
1416  size_t RootPathLen = sys::path::root_path(Trimmed).size();
1417  while (Trimmed.size() > RootPathLen &&
1418  sys::path::is_separator(Trimmed.back()))
1419  Trimmed = Trimmed.slice(0, Trimmed.size() - 1);
1420  // Get the last component
1421  StringRef LastComponent = sys::path::filename(Trimmed);
1422 
1423  std::unique_ptr<RedirectingFileSystem::Entry> Result;
1424  switch (Kind) {
1426  Result = llvm::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
1427  LastComponent, std::move(ExternalContentsPath), UseExternalName);
1428  break;
1430  Result =
1431  llvm::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1432  LastComponent, std::move(EntryArrayContents),
1434  std::chrono::system_clock::now(), 0, 0, 0,
1435  file_type::directory_file, sys::fs::all_all));
1436  break;
1437  }
1438 
1439  StringRef Parent = sys::path::parent_path(Trimmed);
1440  if (Parent.empty())
1441  return Result;
1442 
1443  // if 'name' contains multiple components, create implicit directory entries
1445  E = sys::path::rend(Parent);
1446  I != E; ++I) {
1447  std::vector<std::unique_ptr<RedirectingFileSystem::Entry>> Entries;
1448  Entries.push_back(std::move(Result));
1449  Result =
1450  llvm::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1451  *I, std::move(Entries),
1453  std::chrono::system_clock::now(), 0, 0, 0,
1454  file_type::directory_file, sys::fs::all_all));
1455  }
1456  return Result;
1457  }
1458 
1459 public:
1461 
1462  // false on error
1464  auto *Top = dyn_cast<yaml::MappingNode>(Root);
1465  if (!Top) {
1466  error(Root, "expected mapping node");
1467  return false;
1468  }
1469 
1470  KeyStatusPair Fields[] = {
1471  KeyStatusPair("version", true),
1472  KeyStatusPair("case-sensitive", false),
1473  KeyStatusPair("use-external-names", false),
1474  KeyStatusPair("overlay-relative", false),
1475  KeyStatusPair("fallthrough", false),
1476  KeyStatusPair("roots", true),
1477  };
1478 
1479  DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));
1480  std::vector<std::unique_ptr<RedirectingFileSystem::Entry>> RootEntries;
1481 
1482  // Parse configuration and 'roots'
1483  for (auto &I : *Top) {
1484  SmallString<10> KeyBuffer;
1485  StringRef Key;
1486  if (!parseScalarString(I.getKey(), Key, KeyBuffer))
1487  return false;
1488 
1489  if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
1490  return false;
1491 
1492  if (Key == "roots") {
1493  auto *Roots = dyn_cast<yaml::SequenceNode>(I.getValue());
1494  if (!Roots) {
1495  error(I.getValue(), "expected array");
1496  return false;
1497  }
1498 
1499  for (auto &I : *Roots) {
1500  if (std::unique_ptr<RedirectingFileSystem::Entry> E =
1501  parseEntry(&I, FS, /*IsRootEntry*/ true))
1502  RootEntries.push_back(std::move(E));
1503  else
1504  return false;
1505  }
1506  } else if (Key == "version") {
1507  StringRef VersionString;
1508  SmallString<4> Storage;
1509  if (!parseScalarString(I.getValue(), VersionString, Storage))
1510  return false;
1511  int Version;
1512  if (VersionString.getAsInteger<int>(10, Version)) {
1513  error(I.getValue(), "expected integer");
1514  return false;
1515  }
1516  if (Version < 0) {
1517  error(I.getValue(), "invalid version number");
1518  return false;
1519  }
1520  if (Version != 0) {
1521  error(I.getValue(), "version mismatch, expected 0");
1522  return false;
1523  }
1524  } else if (Key == "case-sensitive") {
1525  if (!parseScalarBool(I.getValue(), FS->CaseSensitive))
1526  return false;
1527  } else if (Key == "overlay-relative") {
1528  if (!parseScalarBool(I.getValue(), FS->IsRelativeOverlay))
1529  return false;
1530  } else if (Key == "use-external-names") {
1531  if (!parseScalarBool(I.getValue(), FS->UseExternalNames))
1532  return false;
1533  } else if (Key == "fallthrough") {
1534  if (!parseScalarBool(I.getValue(), FS->IsFallthrough))
1535  return false;
1536  } else {
1537  llvm_unreachable("key missing from Keys");
1538  }
1539  }
1540 
1541  if (Stream.failed())
1542  return false;
1543 
1544  if (!checkMissingKeys(Top, Keys))
1545  return false;
1546 
1547  // Now that we sucessefully parsed the YAML file, canonicalize the internal
1548  // representation to a proper directory tree so that we can search faster
1549  // inside the VFS.
1550  for (auto &E : RootEntries)
1551  uniqueOverlayTree(FS, E.get());
1552 
1553  return true;
1554  }
1555 };
1556 
1558 RedirectingFileSystem::create(std::unique_ptr<MemoryBuffer> Buffer,
1560  StringRef YAMLFilePath, void *DiagContext,
1561  IntrusiveRefCntPtr<FileSystem> ExternalFS) {
1562  SourceMgr SM;
1563  yaml::Stream Stream(Buffer->getMemBufferRef(), SM);
1564 
1565  SM.setDiagHandler(DiagHandler, DiagContext);
1566  yaml::document_iterator DI = Stream.begin();
1567  yaml::Node *Root = DI->getRoot();
1568  if (DI == Stream.end() || !Root) {
1569  SM.PrintMessage(SMLoc(), SourceMgr::DK_Error, "expected root node");
1570  return nullptr;
1571  }
1572 
1574 
1575  std::unique_ptr<RedirectingFileSystem> FS(
1576  new RedirectingFileSystem(std::move(ExternalFS)));
1577 
1578  if (!YAMLFilePath.empty()) {
1579  // Use the YAML path from -ivfsoverlay to compute the dir to be prefixed
1580  // to each 'external-contents' path.
1581  //
1582  // Example:
1583  // -ivfsoverlay dummy.cache/vfs/vfs.yaml
1584  // yields:
1585  // FS->ExternalContentsPrefixDir => /<absolute_path_to>/dummy.cache/vfs
1586  //
1587  SmallString<256> OverlayAbsDir = sys::path::parent_path(YAMLFilePath);
1588  std::error_code EC = llvm::sys::fs::make_absolute(OverlayAbsDir);
1589  assert(!EC && "Overlay dir final path must be absolute");
1590  (void)EC;
1591  FS->setExternalContentsPrefixDir(OverlayAbsDir);
1592  }
1593 
1594  if (!P.parse(Root, FS.get()))
1595  return nullptr;
1596 
1597  return FS.release();
1598 }
1599 
1601 RedirectingFileSystem::lookupPath(const Twine &Path_) const {
1602  SmallString<256> Path;
1603  Path_.toVector(Path);
1604 
1605  // Handle relative paths
1606  if (std::error_code EC = makeAbsolute(Path))
1607  return EC;
1608 
1609  // Canonicalize path by removing ".", "..", "./", etc components. This is
1610  // a VFS request, do bot bother about symlinks in the path components
1611  // but canonicalize in order to perform the correct entry search.
1612  if (UseCanonicalizedPaths) {
1614  sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
1615  }
1616 
1617  if (Path.empty())
1619 
1622  for (const auto &Root : Roots) {
1624  lookupPath(Start, End, Root.get());
1625  if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
1626  return Result;
1627  }
1629 }
1630 
1632 RedirectingFileSystem::lookupPath(sys::path::const_iterator Start,
1635 #ifndef _WIN32
1636  assert(!isTraversalComponent(*Start) &&
1637  !isTraversalComponent(From->getName()) &&
1638  "Paths should not contain traversal components");
1639 #else
1640  // FIXME: this is here to support windows, remove it once canonicalized
1641  // paths become globally default.
1642  if (Start->equals("."))
1643  ++Start;
1644 #endif
1645 
1646  StringRef FromName = From->getName();
1647 
1648  // Forward the search to the next component in case this is an empty one.
1649  if (!FromName.empty()) {
1650  if (CaseSensitive ? !Start->equals(FromName)
1651  : !Start->equals_lower(FromName))
1652  // failure to match
1654 
1655  ++Start;
1656 
1657  if (Start == End) {
1658  // Match!
1659  return From;
1660  }
1661  }
1662 
1664  if (!DE)
1666 
1667  for (const std::unique_ptr<RedirectingFileSystem::Entry> &DirEntry :
1668  llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1670  lookupPath(Start, End, DirEntry.get());
1671  if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
1672  return Result;
1673  }
1675 }
1676 
1677 static Status getRedirectedFileStatus(const Twine &Path, bool UseExternalNames,
1678  Status ExternalStatus) {
1679  Status S = ExternalStatus;
1680  if (!UseExternalNames)
1681  S = Status::copyWithNewName(S, Path);
1682  S.IsVFSMapped = true;
1683  return S;
1684 }
1685 
1686 ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path,
1688  assert(E != nullptr);
1689  if (auto *F = dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(E)) {
1690  ErrorOr<Status> S = ExternalFS->status(F->getExternalContentsPath());
1691  assert(!S || S->getName() == F->getExternalContentsPath());
1692  if (S)
1693  return getRedirectedFileStatus(Path, F->useExternalName(UseExternalNames),
1694  *S);
1695  return S;
1696  } else { // directory
1697  auto *DE = cast<RedirectingFileSystem::RedirectingDirectoryEntry>(E);
1698  return Status::copyWithNewName(DE->getStatus(), Path);
1699  }
1700 }
1701 
1702 ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path) {
1703  ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
1704  if (!Result) {
1705  if (IsFallthrough &&
1707  return ExternalFS->status(Path);
1708  }
1709  return Result.getError();
1710  }
1711  return status(Path, *Result);
1712 }
1713 
1714 namespace {
1715 
1716 /// Provide a file wrapper with an overriden status.
1717 class FileWithFixedStatus : public File {
1718  std::unique_ptr<File> InnerFile;
1719  Status S;
1720 
1721 public:
1722  FileWithFixedStatus(std::unique_ptr<File> InnerFile, Status S)
1723  : InnerFile(std::move(InnerFile)), S(std::move(S)) {}
1724 
1725  ErrorOr<Status> status() override { return S; }
1727 
1728  getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
1729  bool IsVolatile) override {
1730  return InnerFile->getBuffer(Name, FileSize, RequiresNullTerminator,
1731  IsVolatile);
1732  }
1733 
1734  std::error_code close() override { return InnerFile->close(); }
1735 };
1736 
1737 } // namespace
1738 
1741  ErrorOr<RedirectingFileSystem::Entry *> E = lookupPath(Path);
1742  if (!E) {
1743  if (IsFallthrough &&
1745  return ExternalFS->openFileForRead(Path);
1746  }
1747  return E.getError();
1748  }
1749 
1751  if (!F) // FIXME: errc::not_a_file?
1753 
1754  auto Result = ExternalFS->openFileForRead(F->getExternalContentsPath());
1755  if (!Result)
1756  return Result;
1757 
1758  auto ExternalStatus = (*Result)->status();
1759  if (!ExternalStatus)
1760  return ExternalStatus.getError();
1761 
1762  // FIXME: Update the status with the name and VFSMapped.
1763  Status S = getRedirectedFileStatus(Path, F->useExternalName(UseExternalNames),
1764  *ExternalStatus);
1765  return std::unique_ptr<File>(
1766  llvm::make_unique<FileWithFixedStatus>(std::move(*Result), S));
1767 }
1768 
1769 std::error_code
1771  SmallVectorImpl<char> &Output) const {
1772  ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
1773  if (!Result) {
1774  if (IsFallthrough &&
1776  return ExternalFS->getRealPath(Path, Output);
1777  }
1778  return Result.getError();
1779  }
1780 
1781  if (auto *F =
1782  dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(*Result)) {
1783  return ExternalFS->getRealPath(F->getExternalContentsPath(), Output);
1784  }
1785  // Even if there is a directory entry, fall back to ExternalFS if allowed,
1786  // because directories don't have a single external contents path.
1787  return IsFallthrough ? ExternalFS->getRealPath(Path, Output)
1789 }
1790 
1792 vfs::getVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
1794  StringRef YAMLFilePath, void *DiagContext,
1795  IntrusiveRefCntPtr<FileSystem> ExternalFS) {
1796  return RedirectingFileSystem::create(std::move(Buffer), DiagHandler,
1797  YAMLFilePath, DiagContext,
1798  std::move(ExternalFS));
1799 }
1800 
1803  SmallVectorImpl<YAMLVFSEntry> &Entries) {
1804  auto Kind = SrcE->getKind();
1807  assert(DE && "Must be a directory");
1808  for (std::unique_ptr<RedirectingFileSystem::Entry> &SubEntry :
1809  llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1810  Path.push_back(SubEntry->getName());
1811  getVFSEntries(SubEntry.get(), Path, Entries);
1812  Path.pop_back();
1813  }
1814  return;
1815  }
1816 
1817  assert(Kind == RedirectingFileSystem::EK_File && "Must be a EK_File");
1819  assert(FE && "Must be a file");
1820  SmallString<128> VPath;
1821  for (auto &Comp : Path)
1822  llvm::sys::path::append(VPath, Comp);
1823  Entries.push_back(YAMLVFSEntry(VPath.c_str(), FE->getExternalContentsPath()));
1824 }
1825 
1826 void vfs::collectVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
1827  SourceMgr::DiagHandlerTy DiagHandler,
1828  StringRef YAMLFilePath,
1829  SmallVectorImpl<YAMLVFSEntry> &CollectedEntries,
1830  void *DiagContext,
1831  IntrusiveRefCntPtr<FileSystem> ExternalFS) {
1833  std::move(Buffer), DiagHandler, YAMLFilePath, DiagContext,
1834  std::move(ExternalFS));
1835  ErrorOr<RedirectingFileSystem::Entry *> RootE = VFS->lookupPath("/");
1836  if (!RootE)
1837  return;
1838  SmallVector<StringRef, 8> Components;
1839  Components.push_back("/");
1840  getVFSEntries(*RootE, Components, CollectedEntries);
1841 }
1842 
1844  static std::atomic<unsigned> UID;
1845  unsigned ID = ++UID;
1846  // The following assumes that uint64_t max will never collide with a real
1847  // dev_t value from the OS.
1849 }
1850 
1852  assert(sys::path::is_absolute(VirtualPath) && "virtual path not absolute");
1853  assert(sys::path::is_absolute(RealPath) && "real path not absolute");
1854  assert(!pathHasTraversal(VirtualPath) && "path traversal is not supported");
1855  Mappings.emplace_back(VirtualPath, RealPath);
1856 }
1857 
1858 namespace {
1859 
1860 class JSONWriter {
1861  llvm::raw_ostream &OS;
1862  SmallVector<StringRef, 16> DirStack;
1863 
1864  unsigned getDirIndent() { return 4 * DirStack.size(); }
1865  unsigned getFileIndent() { return 4 * (DirStack.size() + 1); }
1866  bool containedIn(StringRef Parent, StringRef Path);
1867  StringRef containedPart(StringRef Parent, StringRef Path);
1868  void startDirectory(StringRef Path);
1869  void endDirectory();
1870  void writeEntry(StringRef VPath, StringRef RPath);
1871 
1872 public:
1873  JSONWriter(llvm::raw_ostream &OS) : OS(OS) {}
1874 
1875  void write(ArrayRef<YAMLVFSEntry> Entries, Optional<bool> UseExternalNames,
1876  Optional<bool> IsCaseSensitive, Optional<bool> IsOverlayRelative,
1877  StringRef OverlayDir);
1878 };
1879 
1880 } // namespace
1881 
1882 bool JSONWriter::containedIn(StringRef Parent, StringRef Path) {
1883  using namespace llvm::sys;
1884 
1885  // Compare each path component.
1886  auto IParent = path::begin(Parent), EParent = path::end(Parent);
1887  for (auto IChild = path::begin(Path), EChild = path::end(Path);
1888  IParent != EParent && IChild != EChild; ++IParent, ++IChild) {
1889  if (*IParent != *IChild)
1890  return false;
1891  }
1892  // Have we exhausted the parent path?
1893  return IParent == EParent;
1894 }
1895 
1896 StringRef JSONWriter::containedPart(StringRef Parent, StringRef Path) {
1897  assert(!Parent.empty());
1898  assert(containedIn(Parent, Path));
1899  return Path.slice(Parent.size() + 1, StringRef::npos);
1900 }
1901 
1902 void JSONWriter::startDirectory(StringRef Path) {
1903  StringRef Name =
1904  DirStack.empty() ? Path : containedPart(DirStack.back(), Path);
1905  DirStack.push_back(Path);
1906  unsigned Indent = getDirIndent();
1907  OS.indent(Indent) << "{\n";
1908  OS.indent(Indent + 2) << "'type': 'directory',\n";
1909  OS.indent(Indent + 2) << "'name': \"" << llvm::yaml::escape(Name) << "\",\n";
1910  OS.indent(Indent + 2) << "'contents': [\n";
1911 }
1912 
1913 void JSONWriter::endDirectory() {
1914  unsigned Indent = getDirIndent();
1915  OS.indent(Indent + 2) << "]\n";
1916  OS.indent(Indent) << "}";
1917 
1918  DirStack.pop_back();
1919 }
1920 
1921 void JSONWriter::writeEntry(StringRef VPath, StringRef RPath) {
1922  unsigned Indent = getFileIndent();
1923  OS.indent(Indent) << "{\n";
1924  OS.indent(Indent + 2) << "'type': 'file',\n";
1925  OS.indent(Indent + 2) << "'name': \"" << llvm::yaml::escape(VPath) << "\",\n";
1926  OS.indent(Indent + 2) << "'external-contents': \""
1927  << llvm::yaml::escape(RPath) << "\"\n";
1928  OS.indent(Indent) << "}";
1929 }
1930 
1932  Optional<bool> UseExternalNames,
1933  Optional<bool> IsCaseSensitive,
1934  Optional<bool> IsOverlayRelative,
1935  StringRef OverlayDir) {
1936  using namespace llvm::sys;
1937 
1938  OS << "{\n"
1939  " 'version': 0,\n";
1940  if (IsCaseSensitive.hasValue())
1941  OS << " 'case-sensitive': '"
1942  << (IsCaseSensitive.getValue() ? "true" : "false") << "',\n";
1943  if (UseExternalNames.hasValue())
1944  OS << " 'use-external-names': '"
1945  << (UseExternalNames.getValue() ? "true" : "false") << "',\n";
1946  bool UseOverlayRelative = false;
1947  if (IsOverlayRelative.hasValue()) {
1948  UseOverlayRelative = IsOverlayRelative.getValue();
1949  OS << " 'overlay-relative': '" << (UseOverlayRelative ? "true" : "false")
1950  << "',\n";
1951  }
1952  OS << " 'roots': [\n";
1953 
1954  if (!Entries.empty()) {
1955  const YAMLVFSEntry &Entry = Entries.front();
1956  startDirectory(path::parent_path(Entry.VPath));
1957 
1958  StringRef RPath = Entry.RPath;
1959  if (UseOverlayRelative) {
1960  unsigned OverlayDirLen = OverlayDir.size();
1961  assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&
1962  "Overlay dir must be contained in RPath");
1963  RPath = RPath.slice(OverlayDirLen, RPath.size());
1964  }
1965 
1966  writeEntry(path::filename(Entry.VPath), RPath);
1967 
1968  for (const auto &Entry : Entries.slice(1)) {
1969  StringRef Dir = path::parent_path(Entry.VPath);
1970  if (Dir == DirStack.back())
1971  OS << ",\n";
1972  else {
1973  while (!DirStack.empty() && !containedIn(DirStack.back(), Dir)) {
1974  OS << "\n";
1975  endDirectory();
1976  }
1977  OS << ",\n";
1978  startDirectory(Dir);
1979  }
1980  StringRef RPath = Entry.RPath;
1981  if (UseOverlayRelative) {
1982  unsigned OverlayDirLen = OverlayDir.size();
1983  assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&
1984  "Overlay dir must be contained in RPath");
1985  RPath = RPath.slice(OverlayDirLen, RPath.size());
1986  }
1987  writeEntry(path::filename(Entry.VPath), RPath);
1988  }
1989 
1990  while (!DirStack.empty()) {
1991  OS << "\n";
1992  endDirectory();
1993  }
1994  OS << "\n";
1995  }
1996 
1997  OS << " ]\n"
1998  << "}\n";
1999 }
2000 
2002  llvm::sort(Mappings, [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) {
2003  return LHS.VPath < RHS.VPath;
2004  });
2005 
2006  JSONWriter(OS).write(Mappings, UseExternalNames, IsCaseSensitive,
2007  IsOverlayRelative, OverlayDir);
2008 }
2009 
2011  const Twine &_Path,
2014  bool IterateExternalFS, FileSystem &ExternalFS, std::error_code &EC)
2015  : Dir(_Path.str()), Current(Begin), End(End),
2016  IterateExternalFS(IterateExternalFS), ExternalFS(ExternalFS) {
2017  EC = incrementImpl(/*IsFirstTime=*/true);
2018 }
2019 
2021  return incrementImpl(/*IsFirstTime=*/false);
2022 }
2023 
2024 std::error_code VFSFromYamlDirIterImpl::incrementExternal() {
2025  assert(!(IsExternalFSCurrent && ExternalDirIter == directory_iterator()) &&
2026  "incrementing past end");
2027  std::error_code EC;
2028  if (IsExternalFSCurrent) {
2029  ExternalDirIter.increment(EC);
2030  } else if (IterateExternalFS) {
2031  ExternalDirIter = ExternalFS.dir_begin(Dir, EC);
2032  IsExternalFSCurrent = true;
2033  if (EC && EC != errc::no_such_file_or_directory)
2034  return EC;
2035  EC = {};
2036  }
2037  if (EC || ExternalDirIter == directory_iterator()) {
2039  } else {
2040  CurrentEntry = *ExternalDirIter;
2041  }
2042  return EC;
2043 }
2044 
2045 std::error_code VFSFromYamlDirIterImpl::incrementContent(bool IsFirstTime) {
2046  assert((IsFirstTime || Current != End) && "cannot iterate past end");
2047  if (!IsFirstTime)
2048  ++Current;
2049  while (Current != End) {
2050  SmallString<128> PathStr(Dir);
2051  llvm::sys::path::append(PathStr, (*Current)->getName());
2053  switch ((*Current)->getKind()) {
2056  break;
2059  break;
2060  }
2061  CurrentEntry = directory_entry(PathStr.str(), Type);
2062  return {};
2063  }
2064  return incrementExternal();
2065 }
2066 
2067 std::error_code VFSFromYamlDirIterImpl::incrementImpl(bool IsFirstTime) {
2068  while (true) {
2069  std::error_code EC = IsExternalFSCurrent ? incrementExternal()
2070  : incrementContent(IsFirstTime);
2071  if (EC || CurrentEntry.path().empty())
2072  return EC;
2074  if (SeenNames.insert(Name).second)
2075  return EC; // name not seen before
2076  }
2077  llvm_unreachable("returned above");
2078 }
2079 
2081  FileSystem &FS_, const Twine &Path, std::error_code &EC)
2082  : FS(&FS_) {
2083  directory_iterator I = FS->dir_begin(Path, EC);
2084  if (I != directory_iterator()) {
2085  State = std::make_shared<detail::RecDirIterState>();
2086  State->Stack.push(I);
2087  }
2088 }
2089 
2092  assert(FS && State && !State->Stack.empty() && "incrementing past end");
2093  assert(!State->Stack.top()->path().empty() && "non-canonical end iterator");
2095 
2096  if (State->HasNoPushRequest)
2097  State->HasNoPushRequest = false;
2098  else {
2099  if (State->Stack.top()->type() == sys::fs::file_type::directory_file) {
2100  vfs::directory_iterator I = FS->dir_begin(State->Stack.top()->path(), EC);
2101  if (I != End) {
2102  State->Stack.push(I);
2103  return *this;
2104  }
2105  }
2106  }
2107 
2108  while (!State->Stack.empty() && State->Stack.top().increment(EC) == End)
2109  State->Stack.pop();
2110 
2111  if (State->Stack.empty())
2112  State.reset(); // end iterator
2113 
2114  return *this;
2115 }
An input iterator over the recursive contents of a virtual path, similar to llvm::sys::fs::recursive_...
const file_t kInvalidFile
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:151
const NoneType None
Definition: None.h:23
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
Definition: MemoryBuffer.h:69
A file system that allows overlaying one AbstractFileSystem on top of another.
static Status getRedirectedFileStatus(const Twine &Path, bool UseExternalNames, Status ExternalStatus)
iterator overlays_begin()
Get an iterator pointing to the most recently added file system.
bool is_separator(char value, Style style=Style::native)
Check whether the given char is a path separator on the host OS.
Definition: Path.cpp:593
llvm::MemoryBuffer * getBuffer() const
An interface for virtual file systems to provide an iterator over the (non-recursive) contents of a d...
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
llvm::StringRef path() const
Represents either an error or a value T.
Definition: ErrorOr.h:56
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:218
InMemoryNode * getChild(StringRef Name)
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:224
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the &#39;real&#39; file system, as seen by the operating system.
StringRef getBuffer() const
Definition: MemoryBuffer.h:63
std::string toString(unsigned Indent) const override
This class represents lattice values for constants.
Definition: AllocatorList.h:23
std::error_code openFileForRead(const Twine &Name, int &ResultFD, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:473
FileSystemList::reverse_iterator iterator
LLVM_NODISCARD bool equals_lower(StringRef RHS) const
equals_lower - Check for string equality, ignoring case.
Definition: StringRef.h:167
constexpr char IsVolatile[]
Key for Kernel::Arg::Metadata::mIsVolatile.
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
Status getStatus(const Twine &RequestedName) const
Return the Status for this node.
llvm::sys::fs::UniqueID getNextVirtualUniqueID()
Get a globally unique ID for a virtual file or directory.
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
void push_back(const T &Elt)
Definition: SmallVector.h:211
static void getVFSEntries(RedirectingFileSystem::Entry *SrcE, SmallVectorImpl< StringRef > &Path, SmallVectorImpl< YAMLVFSEntry > &Entries)
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
uint32_t getUser() const
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:266
Represents a YAML sequence created from either a block sequence for a flow sequence.
Definition: YAMLParser.h:452
iterator find(StringRef Key)
Definition: StringMap.h:332
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const Twine &Name, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
This is a convenience method that opens a file, gets its content and then closes the file...
std::error_code current_path(SmallVectorImpl< char > &result)
Get the current path.
The result of a status operation.
bool is_directory(const basic_file_status &status)
Does status represent a directory?
Definition: Path.cpp:1040
The in memory file system is a tree of Nodes.
#define error(X)
std::string escape(StringRef Input, bool EscapePrintable=true)
Escape Input for a double quoted scalar; if EscapePrintable is true, all UTF8 sequences will be escap...
Definition: YAMLParser.cpp:690
F(f)
StringRef remove_leading_dotslash(StringRef path, Style style=Style::native)
Remove redundant leading "./" pieces and consecutive separators.
Definition: Path.cpp:678
Error takeError()
Take ownership of the stored error.
Definition: Error.h:552
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
Represents the result of a call to sys::fs::status().
Definition: FileSystem.h:246
Represents an open file.
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:455
void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges=None, ArrayRef< SMFixIt > FixIts=None, bool ShowColors=true) const
Emit a message about the specified location with the specified string.
Definition: SourceMgr.cpp:242
Definition: BitVector.h:937
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:966
reverse_iterator rbegin(StringRef path, Style style=Style::native)
Get reverse begin iterator over path.
Definition: Path.cpp:295
InMemoryFileSystem(bool UseNormalizedPaths=true)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
void write(llvm::raw_ostream &OS)
void make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
Definition: Path.cpp:853
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator=true, bool IsVolatile=false)
Given an already-open file descriptor, read the file and return a MemoryBuffer.
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Canonicalizes Path by combining with the current working directory and normalizing the path (e...
std::error_code make_error_code(BitcodeError E)
static StringRef getName(Value *V)
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:663
recursive_directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
StringRef getName() const
Returns the name that should be used for this file or directory.
static Status copyWithNewName(const Status &In, const Twine &NewName)
Get a copy of a Status with a different name.
llvm::ErrorOr< Status > status(const Twine &Path) override
Get the status of the entry at Path, if one exists.
LLVM_NODISCARD StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:679
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
Tagged union holding either a T or a Error.
Definition: CachePruning.h:22
StringRef root_path(StringRef path, Style style=Style::native)
Get root path.
Definition: Path.cpp:346
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:578
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:611
InMemoryNode(llvm::StringRef FileName, InMemoryNodeKind Kind)
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:266
static bool classof(const InMemoryNode *N)
Key
PAL metadata keys.
std::error_code makeAbsolute(SmallVectorImpl< char > &Path) const
Make Path an absolute path.
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:255
virtual std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const
Gets real path of Path e.g.
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
std::error_code is_local(const Twine &path, bool &result)
Is the file mounted on a local filesystem?
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
InMemoryNode * addChild(StringRef Name, std::unique_ptr< InMemoryNode > Child)
llvm::sys::fs::file_type getType() const
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
std::error_code setCurrentWorkingDirectory(const Twine &Path) override
Set the working directory.
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
void addFileMapping(StringRef VirtualPath, StringRef RealPath)
std::error_code real_path(const Twine &path, SmallVectorImpl< char > &output, bool expand_tilde=false)
Collapse all .
virtual std::error_code isLocal(const Twine &Path, bool &Result)
Is the file mounted on a local filesystem?
llvm::sys::TimePoint getLastModificationTime() const
#define P(N)
void setDiagHandler(DiagHandlerTy DH, void *Ctx=nullptr)
Specify a diagnostic handler to be invoked every time PrintMessage is called.
Definition: SourceMgr.h:119
bool isRegularFile() const
A virtual file system parsed from a YAML file.
static RedirectingFileSystem * create(std::unique_ptr< MemoryBuffer > Buffer, SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, void *DiagContext, IntrusiveRefCntPtr< FileSystem > ExternalFS)
Parses Buffer, which is expected to be in YAML format and returns a virtual file system representing ...
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
void printError(Node *N, const Twine &Msg)
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
UniqueID getUniqueID() const
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Gets real path of Path e.g.
Instrumentation for Order File
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::ErrorOr< Status > status(const Twine &Path) override
Get the status of the entry at Path, if one exists.
static bool classof(const InMemoryNode *N)
std::error_code getError() const
Definition: ErrorOr.h:159
llvm::sys::fs::perms getPermissions() const
TimePoint getLastModificationTime() const
The file modification time as reported from the underlying file system.
virtual std::error_code setCurrentWorkingDirectory(const Twine &Path)=0
Set the working directory.
bool addHardLink(const Twine &From, const Twine &To)
Add a hard link to a file.
static sys::TimePoint< std::chrono::seconds > now(bool Deterministic)
InMemoryFile(Status Stat, std::unique_ptr< llvm::MemoryBuffer > Buffer)
static bool pathHasTraversal(StringRef Path)
static ErrorOr< const detail::InMemoryNode * > lookupInMemoryNode(const InMemoryFileSystem &FS, detail::InMemoryDirectory *Dir, const Twine &P)
std::unique_ptr< FileSystem > createPhysicalFileSystem()
Create an vfs::FileSystem for the &#39;real&#39; file system, as seen by the operating system.
std::error_code getUniqueID(const Twine Path, UniqueID &Result)
Definition: Path.cpp:732
static bool isTraversalComponent(StringRef Component)
std::error_code isLocal(const Twine &Path, bool &Result) override
Is the file mounted on a local filesystem?
A single file or directory in the VFS.
StringRef parent_path(StringRef path, Style style=Style::native)
Get parent path.
Definition: Path.cpp:466
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:41
void toVector(SmallVectorImpl< char > &Out) const
Append the concatenated string into the given SmallString or SmallVector.
Definition: Twine.cpp:32
void(*)(const SMDiagnostic &, void *Context) DiagHandlerTy
Clients that want to handle their own diagnostics in a custom way can register a function pointer+con...
Definition: SourceMgr.h:53
static void write(bool isBE, void *P, T V)
bool isStatusKnown() const
size_t size() const
Definition: SmallVector.h:52
LLVM_NODISCARD char back() const
back - Get the last character in the string.
Definition: StringRef.h:141
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
A member of a directory, yielded by a directory_iterator.
std::pair< typename base::iterator, bool > insert(StringRef Key)
Definition: StringSet.h:38
A scalar node is an opaque datum that can be presented as a series of zero or more Unicode scalar val...
Definition: YAMLParser.h:206
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
virtual ~File()
Destroy the file after closing it (if open).
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1122
ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
std::enable_if< std::numeric_limits< T >::is_signed, bool >::type getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:478
uint64_t getSize() const
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
BlockVerifier::State From
bool useNormalizedPaths() const
Return true if this file system normalizes . and .. in paths.
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
VFSFromYamlDirIterImpl(const Twine &Path, RedirectingFileSystem::RedirectingDirectoryEntry::iterator Begin, RedirectingFileSystem::RedirectingDirectoryEntry::iterator End, bool IterateExternalFS, FileSystem &ExternalFS, std::error_code &EC)
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
This class represents a YAML stream potentially containing multiple documents.
Definition: YAMLParser.h:83
bool remove_dots(SmallVectorImpl< char > &path, bool remove_dot_dot=false, Style style=Style::native)
In-place remove any &#39;.
Definition: Path.cpp:716
bool equivalent(const Status &Other) const
The virtual file system interface.
OverlayFileSystem(IntrusiveRefCntPtr< FileSystem > Base)
Expected< file_t > openNativeFileForRead(const Twine &Name, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)
Opens the file with the given name in a read-only mode, returning its open file descriptor.
std::string toString(unsigned Indent) const override
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
std::error_code closeFile(file_t &F)
Close the file object.
virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC)=0
Get a directory_iterator for Dir.
recursive_directory_iterator()=default
Construct an &#39;end&#39; iterator.
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:370
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:41
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
uint32_t getGroup() const
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:219
InMemoryNodeKind getKind() const
LLVM_DUMP_METHOD void dumpEntry(Entry *E, int NumSpaces=0) const
An in-memory file system.
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:178
std::error_code set_current_path(const Twine &path)
Set the current path.
Path iterator.
Definition: Path.h:52
iterator begin() const
Definition: StringRef.h:101
Reverse path iterator.
Definition: Path.h:78
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:160
Defines the virtual file system interface vfs::FileSystem.
bool hasValue() const
Definition: Optional.h:259
IntrusiveRefCntPtr< FileSystem > getVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())
Gets a FileSystem for a virtual file system described in YAML format.
directory_iterator - Iterates through the entries in path.
Definition: FileSystem.h:1282
Provides a library for accessing information about this process and other processes on the operating ...
static const size_t npos
Definition: StringRef.h:50
iterator begin()
Definition: StringMap.h:314
file_type
An enumeration for the file system&#39;s view of the type.
Definition: FileSystem.h:66
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:565
directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override
Get a directory_iterator for Dir.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
const char * c_str()
Definition: SmallString.h:269
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
uint32_t Size
Definition: Profile.cpp:46
Represents a YAML map created from either a block map for a flow map.
Definition: YAMLParser.h:404
void pushOverlay(IntrusiveRefCntPtr< FileSystem > FS)
Pushes a file system on top of the stack.
reverse_iterator rend(StringRef path)
Get reverse end iterator over path.
Definition: Path.cpp:304
llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override
Get a File object for the file at Path, if one exists.
StringRef getFileName() const
Get the filename of this node (the name without the directory part).
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:171
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
void setExternalContentsPrefixDir(StringRef PrefixDir)
bool isDirectory() const
Provides ErrorOr<T> smart pointer.
std::error_code increment() override
Sets CurrentEntry to the next entry in the directory on success, to directory_entry() at end...
Status getStatus(const Twine &RequestedName) const
Return the Status for this node.
Iterator abstraction for Documents over a Stream.
Definition: YAMLParser.h:579
void collectVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, SmallVectorImpl< YAMLVFSEntry > &CollectedEntries, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())
Collect all pairs of <virtual path, real path> entries from the YAMLFilePath.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A helper class to hold the common YAML parsing state.
llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override
Get the working directory of this file system.
LLVM_DUMP_METHOD void dump() const
bool addFileNoOwn(const Twine &Path, time_t ModificationTime, llvm::MemoryBuffer *Buffer, Optional< uint32_t > User=None, Optional< uint32_t > Group=None, Optional< llvm::sys::fs::file_type > Type=None, Optional< llvm::sys::fs::perms > Perms=None)
Add a buffer to the VFS with a path.
llvm::sys::fs::UniqueID getUniqueID() const
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:27
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
decltype(Entries)::const_iterator const_iterator
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) const override
Gets real path of Path e.g.
Represents a location in source code.
Definition: SMLoc.h:23
iterator end() const
Definition: StringRef.h:103
iterator overlays_end()
Get an iterator pointing one-past the least recently added file system.
const uint64_t Version
Definition: InstrProf.h:984
std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition: Error.cpp:93
iterator end()
Definition: StringMap.h:317
TimePoint< std::chrono::seconds > toTimePoint(std::time_t T)
Convert a std::time_t to a TimePoint.
Definition: Chrono.h:44
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:143
std::chrono::time_point< std::chrono::system_clock, D > TimePoint
A time point on the system clock.
Definition: Chrono.h:33
Abstract base class for all Nodes.
Definition: YAMLParser.h:113
bool parse(yaml::Node *Root, RedirectingFileSystem *FS)