VirtualFileSystem.h Source File (original) (raw)

14#ifndef LLVM_SUPPORT_VIRTUALFILESYSTEM_H

15#define LLVM_SUPPORT_VIRTUALFILESYSTEM_H

30#include

31#include

32#include

33#include

34#include

35#include

36#include <system_error>

37#include

38#include

40namespace llvm {

46namespace vfs {

50 std::string Name;

59public:

82 const Twine &NewName);

84 const Twine &NewName);

100

101

109

110};

111

112

114public:

115

116

117

119

120

122

123

127 else

128 return Status.getError();

129 }

130

131

134 bool RequiresNullTerminator = true, bool IsVolatile = false) = 0;

135

136

137 virtual std::error_code close() = 0;

138

139

142

143protected:

144

146};

147

148

149

151 std::string Path;

153

154public:

157 : Path(std::move(Path)), Type(Type) {}

158

161};

162

178

179

180

182 std::shared_ptrdetail::DirIterImpl Impl;

183

184public:

187 assert(Impl.get() != nullptr && "requires non-null implementation");

188 if (Impl->CurrentEntry.path().empty())

189 Impl.reset();

190 }

191

192

194

195

197 assert(Impl && "attempting to increment past end");

198 EC = Impl->increment();

199 if (Impl->CurrentEntry.path().empty())

200 Impl.reset();

201 return *this;

202 }

203

206

208 if (Impl && RHS.Impl)

209 return Impl->CurrentEntry.path() == RHS.Impl->CurrentEntry.path();

210 return !Impl && RHS .Impl;

211 }

213 return !(*this == RHS);

214 }

215};

216

217class FileSystem;

218

220

221

223 std::vector<directory_iterator> Stack;

225};

226

227}

228

229

230

233 std::shared_ptrdetail::RecDirIterState

234 State;

235

236public:

238 std::error_code &EC);

239

240

242

243

245

248

250 return State == Other.State;

251 }

253 return !(*this == RHS);

254 }

255

256

258 assert(!State->Stack.empty() &&

259 "Cannot get level without any iteration state");

260 return State->Stack.size() - 1;

261 }

262

263 void no_push() { State->HasNoPushRequest = true; }

264};

265

266

268 public RTTIExtends<FileSystem, RTTIRoot> {

269public:

270 static const char ID;

272

273

275

276

279

280

281

282

283

284

289

290

291

292

293

295 getBufferForFile(const Twine &Name, int64_t FileSize = -1,

296 bool RequiresNullTerminator = true, bool IsVolatile = false,

297 bool IsText = true);

298

299

300

302 std::error_code &EC) = 0;

303

304

305

307

308

310

311

312

313

316

317

318

320

321

322 virtual std::error_code isLocal(const Twine &Path, bool &Result);

323

324

325

326

327

328

329

330

331

332

333

334

336

337

338

340

343 unsigned IndentLevel = 0) const {

345 }

346

350 Callback(*this);

352 }

353

354#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

356#endif

357

358protected:

360 unsigned IndentLevel) const {

362 OS << "FileSystem\n";

363 }

364

366 for (unsigned i = 0; i < IndentLevel; ++i)

367 OS << " ";

368 }

369};

370

371

372

373

374

376

377

378

379

380

382

383

384

385

386

387

388

389

390

391

392

394 : public RTTIExtends<OverlayFileSystem, FileSystem> {

396

397

398

399 FileSystemList FSList;

400

401public:

402 static const char ID;

404

405

407

415 std::error_code isLocal(const Twine &Path, bool &Result) override;

418

425

426

429

430

433

434

437

438

441

444

445protected:

447 unsigned IndentLevel) const override;

448 void visitChildFileSystems(VisitCallbackTy Callback) override;

449};

450

451

452

453

455 : public RTTIExtends<ProxyFileSystem, FileSystem> {

456public:

457 static const char ID;

460

462 return FS->status(Path);

463 }

464 bool exists(const Twine &Path) override { return FS->exists(Path); }

467 return FS->openFileForRead(Path);

468 }

470 return FS->dir_begin(Dir, EC);

471 }

473 return FS->getCurrentWorkingDirectory();

474 }

476 return FS->setCurrentWorkingDirectory(Path);

477 }

480 return FS->getRealPath(Path, Output);

481 }

482 std::error_code isLocal(const Twine &Path, bool &Result) override {

483 return FS->isLocal(Path, Result);

484 }

485

486protected:

489 if (FS) {

490 Callback(*FS);

491 FS->visitChildFileSystems(Callback);

492 }

493 }

494

495private:

497

498 void anchor() override;

499};

500

502

503class InMemoryDirectory;

504class InMemoryNode;

505

511 std::unique_ptrllvm::MemoryBuffer Buffer;

516

518};

519

522 Value;

523

524public:

527 : Value(std::make_pair(Name, Node)) {}

530

532 explicit operator bool() const { return static_cast<bool>(Value); }

533 operator std::error_code() const { return Value.getError(); }

534 std::error_code getError() const { return Value.getError(); }

536};

537

538}

539

540

542 : public RTTIExtends<InMemoryFileSystem, FileSystem> {

543 std::unique_ptrdetail::InMemoryDirectory Root;

544 std::string WorkingDirectory;

545 bool UseNormalizedPaths = true;

546

547public:

548 static const char ID;

549

550private:

553

554

555 bool addFile(const Twine &Path, time_t ModificationTime,

556 std::unique_ptrllvm::MemoryBuffer Buffer,

557 std::optional<uint32_t> User, std::optional<uint32_t> Group,

558 std::optionalllvm::sys::fs::file\_type Type,

559 std::optionalllvm::sys::fs::perms Perms, MakeNodeFn MakeNode);

560

561

562

563

565 size_t SymlinkDepth = 0) const;

566

568

569public:

572

573

574

575

576

577

578

579 bool addFile(const Twine &Path, time_t ModificationTime,

580 std::unique_ptrllvm::MemoryBuffer Buffer,

581 std::optional<uint32_t> User = std::nullopt,

582 std::optional<uint32_t> Group = std::nullopt,

583 std::optionalllvm::sys::fs::file\_type Type = std::nullopt,

584 std::optionalllvm::sys::fs::perms Perms = std::nullopt);

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

601

602

603

605

606

607

608

609 bool

611 time_t ModificationTime,

612 std::optional<uint32_t> User = std::nullopt,

613 std::optional<uint32_t> Group = std::nullopt,

614 std::optionalllvm::sys::fs::perms Perms = std::nullopt);

615

616

617

618

619

620

621

624 std::optional<uint32_t> User = std::nullopt,

625 std::optional<uint32_t> Group = std::nullopt,

626 std::optionalllvm::sys::fs::file\_type Type = std::nullopt,

627 std::optionalllvm::sys::fs::perms Perms = std::nullopt);

628

629 std::string toString() const;

630

631

633

636 openFileForRead(const Twine &Path) override;

638

640 return WorkingDirectory;

641 }

642

643

644

645

646

647

648 std::error_code getRealPath(const Twine &Path,

650 std::error_code isLocal(const Twine &Path, bool &Result) override;

651 std::error_code setCurrentWorkingDirectory(const Twine &Path) override;

652

653protected:

655 unsigned IndentLevel) const override;

656};

657

658

660

661

662

663LLVM_ABI std::unique_ptr

666 StringRef YAMLFilePath, void *DiagContext = nullptr,

668

670 template <typename T1, typename T2>

677};

678

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

783 : public RTTIExtends<RedirectingFileSystem, vfs::FileSystem> {

784public:

785 static const char ID;

788

789

791

792

793

795

796

798

799

801 };

802

803

811

812

815 std::string Name;

816

817 public:

820

823 };

824

825

827 std::vector<std::unique_ptr> Contents;

829

830 public:

831

836

837

840

842

843 void addContent(std::unique_ptr Content) {

844 Contents.push_back(std::move(Content));

845 }

846

848

850

853

855 };

856

857

858

860 std::string ExternalContentsPath;

862

863 protected:

866 : Entry(K, Name), ExternalContentsPath(ExternalContentsPath),

867 UseName(UseName) {}

868

869 public:

871

872

874 return UseName == NK_NotSet ? GlobalUseExternalName

876 }

877

879

881 switch (E->getKind()) {

883 [[fallthrough]];

885 return true;

887 return false;

888 }

890 }

891 };

892

893

894

905

906

914

915

917

919

920

922

923 private:

924

925

926

927 std::optionalstd::string ExternalRedirect;

928

929 public:

932

933

934

935

938 return StringRef(*ExternalRedirect);

940 return FE->getExternalContentsPath();

941 return std::nullopt;

942 }

943

944

945

947 };

948

949private:

952

953

954

955

957

958

959

960

962 const Twine &OriginalPath) const;

963

964

965

966

967

968

969

970

971

972

973

974

975

978

979

980

981

982

983

986 return true;

987 return (lhs == "/" && rhs == "\\") || (lhs == "\\" && rhs == "/");

988 }

989

990

991 std::vector<std::unique_ptr> Roots;

992

993

994 std::string WorkingDirectory;

995

996

998

999

1000

1001

1002

1003 std::string OverlayFileDir;

1004

1005

1006

1007

1008

1009

1010

1012

1013

1014

1015 bool IsRelativeOverlay = false;

1016

1017

1018

1019 bool UseExternalNames = true;

1020

1021

1022

1023 mutable bool HasBeenUsed = false;

1024

1025

1026 bool UsageTrackingActive = false;

1027

1028

1029

1030 RedirectKind Redirection = RedirectKind::Fallthrough;

1031

1032

1033

1034 RootRelativeKind RootRelative = RootRelativeKind::CWD;

1035

1036

1038

1039

1042

1043

1044

1045

1046

1051

1052

1054 const LookupResult &Result);

1055

1056public:

1057

1058

1059

1061

1062

1063

1064 static std::unique_ptr

1065 create(std::unique_ptr Buffer,

1068

1069

1070 static std::unique_ptr

1071 create(ArrayRef<std::pair<std::string, std::string>> RemappedFiles,

1073

1075 bool exists(const Twine &Path) override;

1077

1078 std::error_code getRealPath(const Twine &Path,

1080

1082

1083 std::error_code setCurrentWorkingDirectory(const Twine &Path) override;

1084

1085 std::error_code isLocal(const Twine &Path, bool &Result) override;

1086

1088

1090

1091 void setOverlayFileDir(StringRef PrefixDir);

1092

1093 StringRef getOverlayFileDir() const;

1094

1095

1096

1097 void setFallthrough(bool Fallthrough);

1098

1100

1101 std::vectorllvm::StringRef getRoots() const;

1102

1105

1107

1108 void printEntry(raw_ostream &OS, Entry *E, unsigned IndentLevel = 0) const;

1109

1110protected:

1112 unsigned IndentLevel) const override;

1113 void visitChildFileSystems(VisitCallbackTy Callback) override;

1114};

1115

1116

1117

1118

1122

1124 std::vector Mappings;

1125 std::optional IsCaseSensitive;

1126 std::optional IsOverlayRelative;

1127 std::optional UseExternalNames;

1128 std::string OverlayDir;

1129

1130 void addEntry(StringRef VirtualPath, StringRef RealPath, bool IsDirectory);

1131

1132public:

1134

1137

1139 IsCaseSensitive = CaseSensitive;

1140 }

1141

1143

1145 IsOverlayRelative = true;

1146 OverlayDir.assign(OverlayDirectory.str());

1147 }

1148

1149 const std::vector &getMappings() const { return Mappings; }

1150

1152};

1153

1154

1155

1156

1158 : public llvm::RTTIExtends<TracingFileSystem, ProxyFileSystem> {

1159public:

1160 static const char ID;

1161

1168

1171

1176

1181

1186

1192

1197

1202

1203protected:

1205 unsigned IndentLevel) const override;

1206};

1207

1208}

1209}

1210

1211#endif

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

Provides ErrorOr smart pointer.

static void makeAbsolute(vfs::FileSystem &VFS, SmallVectorImpl< char > &Path)

Make Path absolute.

This file defines the RefCountedBase, ThreadSafeRefCountedBase, and IntrusiveRefCntPtr classes.

static const char * toString(MIToken::TokenKind TokenKind)

static void printImpl(const MCAsmInfo &MAI, raw_ostream &OS, const MCSpecifierExpr &Expr)

This file defines the SmallVector class.

static void DiagHandler(const SMDiagnostic &Diag, void *Context)

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Represents either an error or a value T.

A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...

This interface provides simple read-only access to a block of memory, and provides simple methods for...

Inheritance utility for extensible RTTI.

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

std::reverse_iterator< const_iterator > const_reverse_iterator

std::reverse_iterator< iterator > reverse_iterator

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

void(*)(const SMDiagnostic &, void *Context) DiagHandlerTy

Clients that want to handle their own diagnostics in a custom way can register a function pointer+con...

StringRef - Represent a constant reference to a string, i.e.

std::string str() const

str - Get the contents as an std::string.

bool equals_insensitive(StringRef RHS) const

Check for string equality, ignoring case.

Target - Wrapper for Target specific information.

A thread-safe version of RefCountedBase.

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

The instances of the Type class are immutable: once they are created, they are never changed.

An efficient, type-erasing, non-owning reference to a callable.

A range adaptor for a pair of iterators.

This class implements an extremely fast bulk output stream that can only output to a stream.

Represents the result of a call to sys::fs::status().

The virtual file system interface.

Definition VirtualFileSystem.h:268

llvm::function_ref< void(FileSystem &)> VisitCallbackTy

Definition VirtualFileSystem.h:347

virtual llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const =0

Get the working directory of this file system.

virtual bool exists(const Twine &Path)

Check whether Path exists.

virtual llvm::ErrorOr< std::unique_ptr< File > > openFileForReadBinary(const Twine &Path)

Get a File object for the binary file at Path, if one exists.

Definition VirtualFileSystem.h:286

PrintType

Definition VirtualFileSystem.h:341

@ Summary

Definition VirtualFileSystem.h:341

@ RecursiveContents

Definition VirtualFileSystem.h:341

@ Contents

Definition VirtualFileSystem.h:341

virtual std::error_code setCurrentWorkingDirectory(const Twine &Path)=0

Set the working directory.

virtual void printImpl(raw_ostream &OS, PrintType Type, unsigned IndentLevel) const

Definition VirtualFileSystem.h:359

static const char ID

Definition VirtualFileSystem.h:270

virtual llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path)=0

Get a File object for the text file at Path, if one exists.

virtual std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output)

Gets real path of Path e.g.

virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC)=0

Get a directory_iterator for Dir.

void printIndent(raw_ostream &OS, unsigned IndentLevel) const

Definition VirtualFileSystem.h:365

void print(raw_ostream &OS, PrintType Type=PrintType::Contents, unsigned IndentLevel=0) const

Definition VirtualFileSystem.h:342

virtual void visitChildFileSystems(VisitCallbackTy Callback)

Definition VirtualFileSystem.h:348

void visit(VisitCallbackTy Callback)

Definition VirtualFileSystem.h:349

llvm::ErrorOr< bool > equivalent(const Twine &A, const Twine &B)

virtual std::error_code isLocal(const Twine &Path, bool &Result)

Is the file mounted on a local filesystem?

virtual llvm::ErrorOr< Status > status(const Twine &Path)=0

Get the status of the entry at Path, if one exists.

Represents an open file.

Definition VirtualFileSystem.h:113

static ErrorOr< std::unique_ptr< File > > getWithPath(ErrorOr< std::unique_ptr< File > > Result, const Twine &P)

virtual llvm::ErrorOr< Status > status()=0

Get the status of the file.

virtual llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBuffer(const Twine &Name, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)=0

Get the contents of the file as a MemoryBuffer.

virtual llvm::ErrorOr< std::string > getName()

Get the name of the file.

Definition VirtualFileSystem.h:124

virtual void setPath(const Twine &Path)

Definition VirtualFileSystem.h:145

virtual ~File()

Destroy the file after closing it (if open).

virtual std::error_code close()=0

Closes the file.

Adaptor from InMemoryDir::iterator to directory_iterator.

~InMemoryFileSystem() override

static const char ID

Definition VirtualFileSystem.h:548

static constexpr size_t MaxSymlinkDepth

Arbitrary max depth to search through symlinks.

Definition VirtualFileSystem.h:604

InMemoryFileSystem(bool UseNormalizedPaths=true)

bool useNormalizedPaths() const

Return true if this file system normalizes . and .. in paths.

Definition VirtualFileSystem.h:632

llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override

Definition VirtualFileSystem.h:639

bool addHardLink(const Twine &NewLink, const Twine &Target)

Add a hard link to a file.

bool addFileNoOwn(const Twine &Path, time_t ModificationTime, const llvm::MemoryBufferRef &Buffer, std::optional< uint32_t > User=std::nullopt, std::optional< uint32_t > Group=std::nullopt, std::optional< llvm::sys::fs::file_type > Type=std::nullopt, std::optional< llvm::sys::fs::perms > Perms=std::nullopt)

Add a buffer to the VFS with a path.

bool addSymbolicLink(const Twine &NewLink, const Twine &Target, time_t ModificationTime, std::optional< uint32_t > User=std::nullopt, std::optional< uint32_t > Group=std::nullopt, std::optional< llvm::sys::fs::perms > Perms=std::nullopt)

Add a symbolic link.

const_iterator overlays_end() const

Definition VirtualFileSystem.h:432

const_iterator overlays_begin() const

Definition VirtualFileSystem.h:428

directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override

reverse_iterator overlays_rbegin()

Get an iterator pointing to the least recently added file system.

Definition VirtualFileSystem.h:435

const_range overlays_range() const

Definition VirtualFileSystem.h:443

const_reverse_iterator overlays_rend() const

Definition VirtualFileSystem.h:440

iterator_range< iterator > range

Definition VirtualFileSystem.h:423

llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override

reverse_iterator overlays_rend()

Get an iterator pointing one-past the most recently added file system.

Definition VirtualFileSystem.h:439

std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) override

std::error_code setCurrentWorkingDirectory(const Twine &Path) override

void pushOverlay(IntrusiveRefCntPtr< FileSystem > FS)

Pushes a file system on top of the stack.

FileSystemList::const_reverse_iterator const_iterator

Definition VirtualFileSystem.h:420

OverlayFileSystem(IntrusiveRefCntPtr< FileSystem > Base)

FileSystemList::const_iterator const_reverse_iterator

Definition VirtualFileSystem.h:422

llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override

iterator overlays_end()

Get an iterator pointing one-past the least recently added file system.

Definition VirtualFileSystem.h:431

std::error_code isLocal(const Twine &Path, bool &Result) override

range overlays_range()

Definition VirtualFileSystem.h:442

FileSystemList::iterator reverse_iterator

Definition VirtualFileSystem.h:421

bool exists(const Twine &Path) override

llvm::ErrorOr< Status > status(const Twine &Path) override

iterator overlays_begin()

Get an iterator pointing to the most recently added file system.

Definition VirtualFileSystem.h:427

iterator_range< const_iterator > const_range

Definition VirtualFileSystem.h:424

const_reverse_iterator overlays_rbegin() const

Definition VirtualFileSystem.h:436

static const char ID

Definition VirtualFileSystem.h:402

FileSystemList::reverse_iterator iterator

Definition VirtualFileSystem.h:419

llvm::ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override

Definition VirtualFileSystem.h:466

void visitChildFileSystems(VisitCallbackTy Callback) override

Definition VirtualFileSystem.h:488

std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) override

Definition VirtualFileSystem.h:478

directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override

Definition VirtualFileSystem.h:469

llvm::ErrorOr< Status > status(const Twine &Path) override

Definition VirtualFileSystem.h:461

bool exists(const Twine &Path) override

Definition VirtualFileSystem.h:464

std::error_code setCurrentWorkingDirectory(const Twine &Path) override

Definition VirtualFileSystem.h:475

std::error_code isLocal(const Twine &Path, bool &Result) override

Definition VirtualFileSystem.h:482

static const char ID

Definition VirtualFileSystem.h:457

ProxyFileSystem(IntrusiveRefCntPtr< FileSystem > FS)

Definition VirtualFileSystem.h:458

llvm::ErrorOr< std::string > getCurrentWorkingDirectory() const override

Definition VirtualFileSystem.h:472

FileSystem & getUnderlyingFS() const

Definition VirtualFileSystem.h:487

Directory iterator implementation for RedirectingFileSystem's directory entries.

A helper class to hold the common YAML parsing state.

iterator contents_begin()

Definition VirtualFileSystem.h:851

Status getStatus()

Definition VirtualFileSystem.h:841

static bool classof(const Entry *E)

Definition VirtualFileSystem.h:854

iterator contents_end()

Definition VirtualFileSystem.h:852

DirectoryEntry(StringRef Name, Status S)

Constructs an empty directory entry.

Definition VirtualFileSystem.h:838

DirectoryEntry(StringRef Name, std::vector< std::unique_ptr< Entry > > Contents, Status S)

Constructs a directory entry with explicitly specified contents.

Definition VirtualFileSystem.h:832

decltype(Contents)::iterator iterator

Definition VirtualFileSystem.h:849

void addContent(std::unique_ptr< Entry > Content)

Definition VirtualFileSystem.h:843

Entry * getLastContent() const

Definition VirtualFileSystem.h:847

DirectoryRemapEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)

Definition VirtualFileSystem.h:897

static bool classof(const Entry *E)

Definition VirtualFileSystem.h:901

A single file or directory in the VFS.

Definition VirtualFileSystem.h:813

StringRef getName() const

Definition VirtualFileSystem.h:821

EntryKind getKind() const

Definition VirtualFileSystem.h:822

Entry(EntryKind K, StringRef Name)

Definition VirtualFileSystem.h:818

static bool classof(const Entry *E)

Definition VirtualFileSystem.h:912

FileEntry(StringRef Name, StringRef ExternalContentsPath, NameKind UseName)

Definition VirtualFileSystem.h:909

StringRef getExternalContentsPath() const

Definition VirtualFileSystem.h:870

NameKind getUseName() const

Definition VirtualFileSystem.h:878

RemapEntry(EntryKind K, StringRef Name, StringRef ExternalContentsPath, NameKind UseName)

Definition VirtualFileSystem.h:864

bool useExternalName(bool GlobalUseExternalName) const

Whether to use the external path as the name for this file or directory.

Definition VirtualFileSystem.h:873

static bool classof(const Entry *E)

Definition VirtualFileSystem.h:880

A virtual file system parsed from a YAML file.

Definition VirtualFileSystem.h:783

void setUsageTrackingActive(bool Active)

Definition VirtualFileSystem.h:1106

RootRelativeKind

The type of relative path used by Roots.

Definition VirtualFileSystem.h:804

@ OverlayDir

The roots are relative to the directory where the Overlay YAML file.

Definition VirtualFileSystem.h:809

@ CWD

The roots are relative to the current working directory.

Definition VirtualFileSystem.h:806

friend class RedirectingFileSystemParser

Definition VirtualFileSystem.h:951

RedirectKind

The type of redirection to perform.

Definition VirtualFileSystem.h:790

@ Fallthrough

Lookup the redirected path first (ie.

Definition VirtualFileSystem.h:794

@ Fallback

Lookup the provided path first and if that fails, "fallback" to a lookup of the redirected path.

Definition VirtualFileSystem.h:797

@ RedirectOnly

Only lookup the redirected path, do not lookup the originally provided path.

Definition VirtualFileSystem.h:800

NameKind

Definition VirtualFileSystem.h:787

@ NK_Virtual

Definition VirtualFileSystem.h:787

@ NK_External

Definition VirtualFileSystem.h:787

@ NK_NotSet

Definition VirtualFileSystem.h:787

EntryKind

Definition VirtualFileSystem.h:786

@ EK_File

Definition VirtualFileSystem.h:786

@ EK_DirectoryRemap

Definition VirtualFileSystem.h:786

@ EK_Directory

Definition VirtualFileSystem.h:786

friend class RedirectingFSDirIterImpl

Definition VirtualFileSystem.h:950

bool hasBeenUsed() const

Definition VirtualFileSystem.h:1103

static const char ID

Definition VirtualFileSystem.h:785

void clearHasBeenUsed()

Definition VirtualFileSystem.h:1104

The result of a status operation.

Definition VirtualFileSystem.h:49

llvm::sys::fs::perms getPermissions() const

Definition VirtualFileSystem.h:92

llvm::sys::fs::UniqueID getUniqueID() const

Definition VirtualFileSystem.h:94

uint32_t getUser() const

Definition VirtualFileSystem.h:95

LLVM_ABI bool equivalent(const Status &Other) const

static LLVM_ABI Status copyWithNewName(const Status &In, const Twine &NewName)

Get a copy of a Status with a different name.

uint64_t getSize() const

Definition VirtualFileSystem.h:97

LLVM_ABI bool isStatusKnown() const

LLVM_ABI bool exists() const

bool ExposesExternalVFSPath

Whether this entity has an external path different from the virtual path, and the external path is ex...

Definition VirtualFileSystem.h:69

uint32_t getGroup() const

Definition VirtualFileSystem.h:96

static LLVM_ABI Status copyWithNewSize(const Status &In, uint64_t NewSize)

Get a copy of a Status with a different size.

LLVM_ABI bool isOther() const

LLVM_ABI bool isSymlink() const

llvm::sys::TimePoint getLastModificationTime() const

Definition VirtualFileSystem.h:93

llvm::sys::fs::file_type getType() const

Definition VirtualFileSystem.h:91

LLVM_ABI bool isRegularFile() const

LLVM_ABI bool isDirectory() const

StringRef getName() const

Returns the name that should be used for this file or directory.

Definition VirtualFileSystem.h:87

bool exists(const Twine &Path) override

Definition VirtualFileSystem.h:1193

TracingFileSystem(llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)

Definition VirtualFileSystem.h:1169

static const char ID

Definition VirtualFileSystem.h:1160

ErrorOr< std::unique_ptr< File > > openFileForRead(const Twine &Path) override

Definition VirtualFileSystem.h:1177

std::size_t NumOpenFileForReadCalls

Definition VirtualFileSystem.h:1163

std::size_t NumIsLocalCalls

Definition VirtualFileSystem.h:1167

directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override

Definition VirtualFileSystem.h:1182

std::size_t NumExistsCalls

Definition VirtualFileSystem.h:1166

ErrorOr< Status > status(const Twine &Path) override

Definition VirtualFileSystem.h:1172

std::error_code isLocal(const Twine &Path, bool &Result) override

Definition VirtualFileSystem.h:1198

std::size_t NumDirBeginCalls

Definition VirtualFileSystem.h:1164

std::size_t NumGetRealPathCalls

Definition VirtualFileSystem.h:1165

std::size_t NumStatusCalls

Definition VirtualFileSystem.h:1162

std::error_code getRealPath(const Twine &Path, SmallVectorImpl< char > &Output) override

Definition VirtualFileSystem.h:1187

LLVM_ABI void addFileMapping(StringRef VirtualPath, StringRef RealPath)

void setCaseSensitivity(bool CaseSensitive)

Definition VirtualFileSystem.h:1138

void setOverlayDir(StringRef OverlayDirectory)

Definition VirtualFileSystem.h:1144

const std::vector< YAMLVFSEntry > & getMappings() const

Definition VirtualFileSystem.h:1149

LLVM_ABI void write(llvm::raw_ostream &OS)

LLVM_ABI void addDirectoryMapping(StringRef VirtualPath, StringRef RealPath)

void setUseExternalNames(bool UseExtNames)

Definition VirtualFileSystem.h:1142

The in memory file system is a tree of Nodes.

std::error_code getError() const

Definition VirtualFileSystem.h:534

NamedNodeOrError(std::error_code EC)

Definition VirtualFileSystem.h:528

const detail::InMemoryNode * operator*() const

Definition VirtualFileSystem.h:535

StringRef getName() const

Definition VirtualFileSystem.h:531

NamedNodeOrError(llvm::errc EC)

Definition VirtualFileSystem.h:529

NamedNodeOrError(llvm::SmallString< 128 > Name, const detail::InMemoryNode *Node)

Definition VirtualFileSystem.h:525

A member of a directory, yielded by a directory_iterator.

Definition VirtualFileSystem.h:150

directory_entry()=default

directory_entry(std::string Path, llvm::sys::fs::file_type Type)

Definition VirtualFileSystem.h:156

llvm::StringRef path() const

Definition VirtualFileSystem.h:159

llvm::sys::fs::file_type type() const

Definition VirtualFileSystem.h:160

An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.

Definition VirtualFileSystem.h:181

directory_iterator(std::shared_ptr< detail::DirIterImpl > I)

Definition VirtualFileSystem.h:185

bool operator==(const directory_iterator &RHS) const

Definition VirtualFileSystem.h:207

const directory_entry * operator->() const

Definition VirtualFileSystem.h:205

const directory_entry & operator*() const

Definition VirtualFileSystem.h:204

directory_iterator & increment(std::error_code &EC)

Equivalent to operator++, with an error code.

Definition VirtualFileSystem.h:196

bool operator!=(const directory_iterator &RHS) const

Definition VirtualFileSystem.h:212

directory_iterator()=default

Construct an 'end' iterator.

const directory_entry & operator*() const

Definition VirtualFileSystem.h:246

LLVM_ABI recursive_directory_iterator(FileSystem &FS, const Twine &Path, std::error_code &EC)

void no_push()

Definition VirtualFileSystem.h:263

recursive_directory_iterator()=default

Construct an 'end' iterator.

bool operator!=(const recursive_directory_iterator &RHS) const

Definition VirtualFileSystem.h:252

bool operator==(const recursive_directory_iterator &Other) const

Definition VirtualFileSystem.h:249

int level() const

Gets the current level. Starting path is at level 0.

Definition VirtualFileSystem.h:257

LLVM_ABI recursive_directory_iterator & increment(std::error_code &EC)

Equivalent to operator++, with an error code.

const directory_entry * operator->() const

Definition VirtualFileSystem.h:247

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

file_type

An enumeration for the file system's view of the type.

std::chrono::time_point< std::chrono::system_clock, D > TimePoint

A time point on the system clock.

LLVM_ABI void collectVFSEntries(RedirectingFileSystem &VFS, SmallVectorImpl< YAMLVFSEntry > &CollectedEntries)

Collect all pairs of <virtual path, real path> entries from the VFS.

LLVM_ABI std::unique_ptr< FileSystem > createPhysicalFileSystem()

Create an vfs::FileSystem for the 'real' file system, as seen by the operating system.

LLVM_ABI llvm::sys::fs::UniqueID getNextVirtualUniqueID()

Get a globally unique ID for a virtual file or directory.

LLVM_ABI IntrusiveRefCntPtr< FileSystem > getRealFileSystem()

Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.

LLVM_ABI std::unique_ptr< FileSystem > getVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())

Gets a FileSystem for a virtual file system described in YAML format.

This is an optimization pass for GlobalISel generic memory operations.

void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

auto reverse(ContainerTy &&C)

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

OutputIt move(R &&Range, OutputIt Out)

Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.

Implement std::hash so that hash_code can be used in STL containers.

std::optional< StringRef > getExternalRedirect() const