LLVM  9.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 
63 
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 
69 Status::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 
75 Status 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 
82  return Status(NewName, In.getUniqueID(), In.getLastModificationTime(),
83  In.getUser(), In.getGroup(), In.getSize(), In.type(),
84  In.permissions());
85 }
86 
87 bool Status::equivalent(const Status &Other) const {
88  assert(isStatusKnown() && Other.isStatusKnown());
89  return getUniqueID() == Other.getUniqueID();
90 }
91 
92 bool Status::isDirectory() const { return Type == file_type::directory_file; }
93 
94 bool Status::isRegularFile() const { return Type == file_type::regular_file; }
95 
96 bool Status::isOther() const {
97  return exists() && !isRegularFile() && !isDirectory() && !isSymlink();
98 }
99 
100 bool Status::isSymlink() const { return Type == file_type::symlink_file; }
101 
102 bool Status::isStatusKnown() const { return Type != file_type::status_error; }
103 
104 bool Status::exists() const {
105  return isStatusKnown() && Type != file_type::file_not_found;
106 }
107 
108 File::~File() = default;
109 
110 FileSystem::~FileSystem() = default;
111 
113 FileSystem::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 
122 std::error_code FileSystem::makeAbsolute(SmallVectorImpl<char> &Path) const {
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 
134 std::error_code FileSystem::getRealPath(const Twine &Path,
135  SmallVectorImpl<char> &Output) const {
137 }
138 
139 std::error_code FileSystem::isLocal(const Twine &Path, bool &Result) {
141 }
142 
143 bool FileSystem::exists(const Twine &Path) {
144  auto Status = status(Path);
145  return Status && Status->exists();
146 }
147 
148 #ifndef NDEBUG
149 static bool isTraversalComponent(StringRef Component) {
150  return Component.equals("..") || Component.equals(".");
151 }
152 
153 static 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 
167 namespace {
168 
169 /// Wrapper around a raw file descriptor.
170 class 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, {}, {}, {}, {}, {},
180  RealName(NewRealPathName.str()) {
181  assert(FD >= 0 && "Invalid or inactive file descriptor");
182  }
183 
184 public:
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 
198 RealFile::~RealFile() { close(); }
199 
201  assert(FD != -1 && "cannot stat closed file");
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 
212  return RealName.empty() ? S.getName().str() : RealName;
213 }
214 
216 RealFile::getBuffer(const Twine &Name, int64_t FileSize,
217  bool RequiresNullTerminator, bool IsVolatile) {
218  assert(FD != -1 && "cannot get buffer for closed file");
219  return MemoryBuffer::getOpenFile(FD, Name, FileSize, RequiresNullTerminator,
220  IsVolatile);
221 }
222 
223 std::error_code RealFile::close() {
224  std::error_code EC = sys::Process::SafelyCloseFileDescriptor(FD);
225  FD = -1;
226  return EC;
227 }
228 
229 namespace {
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.
239 class RealFileSystem : public FileSystem {
240 public:
241  explicit RealFileSystem(bool LinkCWDToProcess) {
242  if (!LinkCWDToProcess) {
243  SmallString<128> PWD, RealPWD;
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 
263 private:
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  };
281 };
282 
283 } // namespace
284 
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 
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 
304 llvm::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 
314 std::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 
331 std::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 
336 std::error_code
337 RealFileSystem::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 
344  static IntrusiveRefCntPtr<FileSystem> FS(new RealFileSystem(true));
345  return FS;
346 }
347 
348 std::unique_ptr<FileSystem> vfs::createPhysicalFileSystem() {
349  return llvm::make_unique<RealFileSystem>(false);
350 }
351 
352 namespace {
353 
354 class RealFSDirIter : public llvm::vfs::detail::DirIterImpl {
356 
357 public:
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 
375 directory_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 
387  FSList.push_back(std::move(BaseFS));
388 }
389 
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 
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  }
405 }
406 
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  }
416 }
417 
420  // All file systems are synchronized, just take the first working directory.
421  return FSList.front()->getCurrentWorkingDirectory();
422 }
423 
424 std::error_code
426  for (auto &FS : FSList)
427  if (std::error_code EC = FS->setCurrentWorkingDirectory(Path))
428  return EC;
429  return {};
430 }
431 
432 std::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);
437 }
438 
439 std::error_code
441  SmallVectorImpl<char> &Output) const {
442  for (auto &FS : FSList)
443  if (FS->exists(Path))
444  return FS->getRealPath(Path, Output);
446 }
447 
449 
450 namespace {
451 
452 class 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");
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()) &&
475  "incrementing past end");
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");
497  }
498 
499 public:
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 
513  std::error_code &EC) {
514  return directory_iterator(
515  std::make_shared<OverlayFSDirIterImpl>(Dir, *this, EC));
516 }
517 
518 void ProxyFileSystem::anchor() {}
519 
520 namespace llvm {
521 namespace vfs {
522 
523 namespace detail {
524 
526 
527 /// The in memory file system is a tree of Nodes. Every node can either be a
528 /// file , hardlink or a directory.
531  std::string FileName;
532 
533 public:
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 
544 class InMemoryFile : public InMemoryNode {
545  Status Stat;
546  std::unique_ptr<llvm::MemoryBuffer> Buffer;
547 
548 public:
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 
570 namespace {
571 
572 class InMemoryHardLink : public InMemoryNode {
573  const InMemoryFile &ResolvedFile;
574 
575 public:
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.
593 class InMemoryFileAdaptor : public File {
594  const InMemoryFile &Node;
595  /// The name to use when returning a Status for this file.
596  std::string RequestedName;
597 
598 public:
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 
608  getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
609  bool IsVolatile) override {
610  llvm::MemoryBuffer *Buf = Node.getBuffer();
612  Buf->getBuffer(), Buf->getBufferIdentifier(), RequiresNullTerminator);
613  }
614 
615  std::error_code close() override { return {}; }
616 };
617 } // namespace
618 
620  Status Stat;
622 
623 public:
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  }
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 
663 namespace {
664 Status 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");
672 }
673 } // namespace
674 } // namespace detail
675 
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 
684 
685 std::string InMemoryFileSystem::toString() const {
686  return Root->toString(/*Indent=*/0);
687 }
688 
689 bool 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,
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);
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");
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) ||
762  isa<detail::InMemoryHardLink>(Node)) &&
763  "Must be either file, hardlink or directory!");
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 
780 bool 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,
786  return addFile(P, ModificationTime, std::move(Buffer), User, Group, Type,
787  Perms, /*HardLinkTarget=*/nullptr);
788 }
789 
790 bool InMemoryFileSystem::addFileNoOwn(const Twine &P, time_t ModificationTime,
791  llvm::MemoryBuffer *Buffer,
792  Optional<uint32_t> User,
793  Optional<uint32_t> Group,
796  return addFile(P, ModificationTime,
798  Buffer->getBuffer(), Buffer->getBufferIdentifier()),
799  std::move(User), std::move(Group), std::move(Type),
800  std::move(Perms));
801 }
802 
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);
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)
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;
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();
839  }
840  // Traverse directories.
841  Dir = cast<detail::InMemoryDirectory>(Node);
842  if (I == E)
843  return Dir;
844  }
845 }
846 
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 
860  auto Node = lookupInMemoryNode(*this, Root.get(), Path);
861  if (Node)
862  return detail::getNodeStatus(*Node, Path);
863  return Node.getError();
864 }
865 
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?
880 }
881 
882 namespace {
883 
884 /// Adaptor from InMemoryDir::iterator to directory_iterator.
885 class InMemoryDirIterator : public llvm::vfs::detail::DirIterImpl {
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:
899  break;
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 
912 public:
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 
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 
944  return directory_iterator(std::make_shared<InMemoryDirIterator>());
945 }
946 
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);
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 
964 std::error_code
966  SmallVectorImpl<char> &Output) const {
967  auto CWD = getCurrentWorkingDirectory();
968  if (!CWD || CWD->empty())
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 
977 std::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.
993  std::string Dir;
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 
1023 public:
1025  const Twine &Path,
1028  bool IterateExternalFS, FileSystem &ExternalFS, std::error_code &EC);
1029 
1030  std::error_code increment() override;
1031 };
1032 
1035  return ExternalFS->getCurrentWorkingDirectory();
1036 }
1037 
1038 std::error_code
1040  return ExternalFS->setCurrentWorkingDirectory(Path);
1041 }
1042 
1043 std::error_code RedirectingFileSystem::isLocal(const Twine &Path,
1044  bool &Result) {
1045  return ExternalFS->isLocal(Path, Result);
1046 }
1047 
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 
1075  ExternalContentsPrefixDir = PrefixDir.str();
1076 }
1077 
1079  return ExternalContentsPrefixDir;
1080 }
1081 
1082 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1084  for (const auto &Root : Roots)
1085  dumpEntry(Root.get());
1086 }
1087 
1088 LLVM_DUMP_METHOD void
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 
1099  assert(DE && "Should be a directory");
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.
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,
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 
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
1196  ParentEntry);
1197  for (std::unique_ptr<RedirectingFileSystem::Entry> &Content :
1198  llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1199  auto *DirContent =
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>(
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 =
1222  DE->addContent(std::move(E));
1223  return DE->getLastContent();
1224  }
1225 
1226  void uniqueOverlayTree(RedirectingFileSystem *FS,
1228  RedirectingFileSystem::Entry *NewParentE = nullptr) {
1229  StringRef Name = SrcE->getName();
1230  switch (SrcE->getKind()) {
1232  auto *DE =
1234  assert(DE && "Must be a directory");
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  }
1247  assert(FE && "Must be a file");
1248  assert(NewParentE && "Parent entry must exist");
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) {
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 =
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))
1293  return nullptr;
1294 
1295  if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
1296  return nullptr;
1297 
1298  StringRef Value;
1299  if (Key == "name") {
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.
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") {
1315  if (!parseScalarString(I.getValue(), Value, Buffer))
1316  return nullptr;
1317  if (Value == "file")
1319  else if (Value == "directory")
1321  else {
1322  error(I.getValue(), "unknown value for 'type'");
1323  return nullptr;
1324  }
1325  } else if (Key == "contents") {
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") {
1347  if (HasContents) {
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))
1354  return nullptr;
1355 
1356  SmallString<256> FullPath;
1357  if (FS->IsRelativeOverlay) {
1358  FullPath = FS->getExternalContentsPrefixDir();
1359  assert(!FullPath.empty() &&
1360  "External contents prefix directory must exist");
1361  llvm::sys::path::append(FullPath, Value);
1362  } else {
1363  FullPath = Value;
1364  }
1365 
1366  if (FS->UseCanonicalizedPaths) {
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 =
1380  } else {
1381  llvm_unreachable("key missing from Keys");
1382  }
1383  }
1384 
1385  if (Stream.failed())
1386  return nullptr;
1387 
1388  // check for missing keys
1389  if (!HasContents) {
1390  error(N, "missing key 'contents' or 'external-contents'");
1391  return nullptr;
1392  }
1393  if (!checkMissingKeys(N, Keys))
1394  return nullptr;
1395 
1396  // check invalid configuration
1398  UseExternalName !=
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");
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) {
1423  Result = llvm::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
1424  LastComponent, std::move(ExternalContentsPath), UseExternalName);
1425  break;
1427  Result =
1428  llvm::make_unique<RedirectingFileSystem::RedirectingDirectoryEntry>(
1429  LastComponent, std::move(EntryArrayContents),
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
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),
1450  std::chrono::system_clock::now(), 0, 0, 0,
1451  file_type::directory_file, sys::fs::all_all));
1452  }
1453  return Result;
1454  }
1455 
1456 public:
1458 
1459  // false on error
1461  auto *Top = dyn_cast<yaml::MappingNode>(Root);
1462  if (!Top) {
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))
1484  return false;
1485 
1486  if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
1487  return false;
1488 
1489  if (Key == "roots") {
1490  auto *Roots = dyn_cast<yaml::SequenceNode>(I.getValue());
1491  if (!Roots) {
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))
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");
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 
1555 RedirectingFileSystem::create(std::unique_ptr<MemoryBuffer> Buffer,
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) {
1566  SM.PrintMessage(SMLoc(), SourceMgr::DK_Error, "expected root node");
1567  return nullptr;
1568  }
1569 
1571 
1572  std::unique_ptr<RedirectingFileSystem> FS(
1573  new RedirectingFileSystem(std::move(ExternalFS)));
1574 
1575  if (!YAMLFilePath.empty()) {
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");
1587  (void)EC;
1588  FS->setExternalContentsPrefixDir(OverlayAbsDir);
1589  }
1590 
1591  if (!P.parse(Root, FS.get()))
1592  return nullptr;
1593 
1594  return FS.release();
1595 }
1596 
1598 RedirectingFileSystem::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) {
1611  sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
1612  }
1613 
1614  if (Path.empty())
1616 
1619  for (const auto &Root : Roots) {
1621  lookupPath(Start, End, Root.get());
1622  if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
1623  return Result;
1624  }
1626 }
1627 
1629 RedirectingFileSystem::lookupPath(sys::path::const_iterator Start,
1632 #ifndef _WIN32
1633  assert(!isTraversalComponent(*Start) &&
1634  !isTraversalComponent(From->getName()) &&
1635  "Paths should not contain traversal components");
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
1651 
1652  ++Start;
1653 
1654  if (Start == End) {
1655  // Match!
1656  return From;
1657  }
1658  }
1659 
1661  if (!DE)
1663 
1664  for (const std::unique_ptr<RedirectingFileSystem::Entry> &DirEntry :
1665  llvm::make_range(DE->contents_begin(), DE->contents_end())) {
1667  lookupPath(Start, End, DirEntry.get());
1668  if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
1669  return Result;
1670  }
1672 }
1673 
1674 static 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 
1683 ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path,
1685  assert(E != nullptr);
1686  if (auto *F = dyn_cast<RedirectingFileSystem::RedirectingFileEntry>(E)) {
1687  ErrorOr<Status> S = ExternalFS->status(F->getExternalContentsPath());
1688  assert(!S || S->getName() == F->getExternalContentsPath());
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 
1699 ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path) {
1700  ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
1701  if (!Result) {
1702  if (IsFallthrough &&
1704  return ExternalFS->status(Path);
1705  }
1706  return Result.getError();
1707  }
1708  return status(Path, *Result);
1709 }
1710 
1711 namespace {
1712 
1713 /// Provide a file wrapper with an overriden status.
1714 class FileWithFixedStatus : public File {
1715  std::unique_ptr<File> InnerFile;
1716  Status S;
1717 
1718 public:
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; }
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 
1738  ErrorOr<RedirectingFileSystem::Entry *> E = lookupPath(Path);
1739  if (!E) {
1740  if (IsFallthrough &&
1742  return ExternalFS->openFileForRead(Path);
1743  }
1744  return E.getError();
1745  }
1746 
1748  if (!F) // FIXME: errc::not_a_file?
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 
1766 std::error_code
1768  SmallVectorImpl<char> &Output) const {
1769  ErrorOr<RedirectingFileSystem::Entry *> Result = lookupPath(Path);
1770  if (!Result) {
1771  if (IsFallthrough &&
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)
1786 }
1787 
1789 vfs::getVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
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 
1800  SmallVectorImpl<YAMLVFSEntry> &Entries) {
1801  auto Kind = SrcE->getKind();
1804  assert(DE && "Must be a directory");
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");
1816  assert(FE && "Must be a file");
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 
1823 void 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) {
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 
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.
1846 }
1847 
1849  assert(sys::path::is_absolute(VirtualPath) && "virtual path not absolute");
1850  assert(sys::path::is_absolute(RealPath) && "real path not absolute");
1851  assert(!pathHasTraversal(VirtualPath) && "path traversal is not supported");
1852  Mappings.emplace_back(VirtualPath, RealPath);
1853 }
1854 
1855 namespace {
1856 
1857 class 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 
1869 public:
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 
1879 bool 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 
1893 StringRef JSONWriter::containedPart(StringRef Parent, StringRef Path) {
1894  assert(!Parent.empty());
1895  assert(containedIn(Parent, Path));
1896  return Path.slice(Parent.size() + 1, StringRef::npos);
1897 }
1898 
1899 void 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 
1910 void JSONWriter::endDirectory() {
1911  unsigned Indent = getDirIndent();
1912  OS.indent(Indent + 2) << "]\n";
1913  OS.indent(Indent) << "}";
1914 
1915  DirStack.pop_back();
1916 }
1917 
1918 void 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 
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 &&
1959  "Overlay dir must be contained in RPath");
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 &&
1981  "Overlay dir must be contained in RPath");
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 
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 
2008  const Twine &_Path,
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 
2018  return incrementImpl(/*IsFirstTime=*/false);
2019 }
2020 
2021 std::error_code VFSFromYamlDirIterImpl::incrementExternal() {
2022  assert(!(IsExternalFSCurrent && ExternalDirIter == directory_iterator()) &&
2023  "incrementing past end");
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()) {
2036  } else {
2037  CurrentEntry = *ExternalDirIter;
2038  }
2039  return EC;
2040 }
2041 
2042 std::error_code VFSFromYamlDirIterImpl::incrementContent(bool IsFirstTime) {
2043  assert((IsFirstTime || Current != End) && "cannot iterate past end");
2044  if (!IsFirstTime)
2045  ++Current;
2046  while (Current != End) {
2047  SmallString<128> PathStr(Dir);
2048  llvm::sys::path::append(PathStr, (*Current)->getName());
2050  switch ((*Current)->getKind()) {
2053  break;
2056  break;
2057  }
2058  CurrentEntry = directory_entry(PathStr.str(), Type);
2059  return {};
2060  }
2061  return incrementExternal();
2062 }
2063 
2064 std::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;
2071  if (SeenNames.insert(Name).second)
2072  return EC; // name not seen before
2073  }
2074  llvm_unreachable("returned above");
2075 }
2076 
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 
2089  assert(FS && State && !State->Stack.empty() && "incrementing past end");
2090  assert(!State->Stack.top()->path().empty() && "non-canonical end iterator");
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 }
An input iterator over the recursive contents of a virtual path, similar to llvm::sys::fs::recursive_...
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
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:247
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
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?
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:117
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:1115
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:841
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)
std::string toString(unsigned Indent) const override
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
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:365
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:1217
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 Value Representation.
Definition: Value.h:72
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
static std::error_code SafelyCloseFileDescriptor(int FD)
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
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFile(int 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.
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
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)