Caching.cpp Source File (original) (raw)

21#if !defined(_MSC_VER) && !defined(__MINGW32__)

22#include <unistd.h>

23#else

24#include <io.h>

25#endif

27using namespace llvm;

30 const Twine &TempFilePrefixRef,

31 const Twine &CacheDirectoryPathRef,

35 SmallString<64> CacheName, TempFilePrefix, CacheDirectoryPath;

36 CacheNameRef.toVector(CacheName);

37 TempFilePrefixRef.toVector(TempFilePrefix);

38 CacheDirectoryPathRef.toVector(CacheDirectoryPath);

50 std::error_code EC;

51 if (FDOrErr) {

54 -1,

55 false);

57 if (MBOrErr) {

58 AddBuffer(Task, ModuleName, std::move(*MBOrErr));

60 }

62 } else {

64 }

74 EntryPath + ": " + EC.message() + "\n");

82 unsigned Task;

84 CacheStream(std::unique_ptr<raw_pwrite_stream> OS, AddBufferFn AddBuffer,

86 std::string ModuleName, unsigned Task)

88 AddBuffer(std::move(AddBuffer)), TempFile(std::move(TempFile)),

93 if (E)

94 return E;

97 OS.reset();

103 -1, false);

104 if (!MBOrErr) {

105 std::error_code EC = MBOrErr.getError();

107 TempFile.TmpName + ": " +

108 EC.message() + "\n");

109 }

110

111

112

113

114

115

116

117

118

119

120 E = TempFile.keep(ObjectPathName);

122 std::error_code EC = E.convertToErrorCode();

125 EC, Twine("Failed to rename temporary file ") +

126 TempFile.TmpName + " to " + ObjectPathName + ": " +

127 EC.message() + "\n");

128

130 ObjectPathName);

131 MBOrErr = std::move(MBCopy);

132

133

135

137 });

138

139 if (E)

140 return E;

141

142 AddBuffer(Task, ModuleName, std::move(*MBOrErr));

144 }

145 };

146

148 -> Expected<std::unique_ptr> {

149

150

152 CacheDirectoryPath, true))

154 CacheDirectoryPath + ": " +

155 EC.message());

156

157

160 TempFilePrefix + "-%%%%%%.tmp.o");

163 if (!Temp)

166 ": Can't get a temporary file");

167

168

169 return std::make_unique(

170 std::make_unique<raw_fd_ostream>(Temp->FD, false),

171 AddBuffer, std::move(*Temp), std::string(EntryPath), ModuleName.str(),

172 Task);

173 };

174 };

175 return FileCache(Func, CacheDirectoryPathRef.str());

176}

This class wraps an output stream for a file.

CachedFileStream(std::unique_ptr< raw_pwrite_stream > OS, std::string OSPath="")

virtual Error commit()

Must be called exactly once after the writes to OS have been completed but before the CachedFileStrea...

This class wraps a std::error_code in a Error.

Represents either an error or a value T.

std::error_code getError() const

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)

Given an already-open file descriptor, read the file and return a MemoryBuffer.

static std::unique_ptr< MemoryBuffer > getMemBufferCopy(StringRef InputData, const Twine &BufferName="")

Open the specified memory range as a MemoryBuffer, copying the contents and taking ownership of it.

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

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

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

LLVM_ABI std::string str() const

Return the twine contents as a std::string.

LLVM_ABI void toVector(SmallVectorImpl< char > &Out) const

Append the concatenated string into the given SmallString or SmallVector.

Represents a temporary file.

static LLVM_ABI Expected< TempFile > create(const Twine &Model, unsigned Mode=all_read|all_write, OpenFlags ExtraFlags=OF_None)

This creates a temporary file with createUniqueFile and schedules it for deletion with sys::RemoveFil...

LLVM_ABI std::error_code closeFile(file_t &F)

Close the file object.

@ OF_UpdateAtime

Force files Atime to be updated on access.

LLVM_ABI Expected< file_t > openNativeFileForRead(const Twine &Name, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)

Opens the file with the given name in a read-only mode, returning its open file descriptor.

LLVM_ABI std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)

Create all the non-existent directories in path.

LLVM_ABI file_t convertFDToNativeFile(int FD)

Converts from a Posix file descriptor number to a native file handle.

LLVM_ABI void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")

Append to path.

This is an optimization pass for GlobalISel generic memory operations.

Error handleErrors(Error E, HandlerTs &&... Hs)

Pass the ErrorInfo(s) contained in E to their respective handlers.

Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)

Create formatted StringError object.

@ no_such_file_or_directory

std::function< void(unsigned Task, const Twine &ModuleName, std::unique_ptr< MemoryBuffer > MB)> AddBufferFn

This type defines the callback to add a pre-existing file (e.g.

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)

std::function< Expected< std::unique_ptr< CachedFileStream > >( unsigned Task, const Twine &ModuleName)> AddStreamFn

This type defines the callback to add a file that is generated on the fly.

LLVM_ABI std::error_code errorToErrorCode(Error Err)

Helper for converting an ECError to a std::error_code.

void consumeError(Error Err)

Consume a Error without doing anything.

LLVM_ABI Expected< FileCache > localCache(const Twine &CacheNameRef, const Twine &TempFilePrefixRef, const Twine &CacheDirectoryPathRef, AddBufferFn AddBuffer=[](size_t Task, const Twine &ModuleName, std::unique_ptr< MemoryBuffer > MB) {})

Create a local file system cache which uses the given cache name, temporary file prefix,...

Definition Caching.cpp:29

This type represents a file cache system that manages caching of files.