Index: lld/trunk/ELF/LTO.cpp =================================================================== --- lld/trunk/ELF/LTO.cpp +++ lld/trunk/ELF/LTO.cpp @@ -150,10 +150,11 @@ // specified, configure LTO to use it as the cache directory. lto::NativeObjectCache Cache; if (!Config->ThinLTOCacheDir.empty()) - Cache = check(lto::localCache( - Config->ThinLTOCacheDir, [&](size_t Task, StringRef Path) { - Files[Task] = check(MemoryBuffer::getFile(Path)); - })); + Cache = check( + lto::localCache(Config->ThinLTOCacheDir, + [&](size_t Task, std::unique_ptr MB) { + Files[Task] = std::move(MB); + })); checkError(LTOObj->run( [&](size_t Task) { Index: llvm/trunk/include/llvm/LTO/Caching.h =================================================================== --- llvm/trunk/include/llvm/LTO/Caching.h +++ llvm/trunk/include/llvm/LTO/Caching.h @@ -24,14 +24,19 @@ /// This type defines the callback to add a pre-existing native object file /// (e.g. in a cache). /// -/// File callbacks must be thread safe. -typedef std::function AddFileFn; +/// MB->getBufferIdentifier() is a valid path for the file at the time that it +/// was opened, but clients should prefer to access MB directly in order to +/// avoid a potential race condition. +/// +/// Buffer callbacks must be thread safe. +typedef std::function MB)> + AddBufferFn; /// Create a local file system cache which uses the given cache directory and /// file callback. This function also creates the cache directory if it does not /// already exist. Expected localCache(StringRef CacheDirectoryPath, - AddFileFn AddFile); + AddBufferFn AddBuffer); } // namespace lto } // namespace llvm Index: llvm/trunk/lib/LTO/Caching.cpp =================================================================== --- llvm/trunk/lib/LTO/Caching.cpp +++ llvm/trunk/lib/LTO/Caching.cpp @@ -22,7 +22,7 @@ using namespace llvm::lto; Expected lto::localCache(StringRef CacheDirectoryPath, - AddFileFn AddFile) { + AddBufferFn AddBuffer) { if (std::error_code EC = sys::fs::create_directories(CacheDirectoryPath)) return errorCodeToError(EC); @@ -30,34 +30,49 @@ // First, see if we have a cache hit. SmallString<64> EntryPath; sys::path::append(EntryPath, CacheDirectoryPath, Key); - if (sys::fs::exists(EntryPath)) { - AddFile(Task, EntryPath); + ErrorOr> MBOrErr = + MemoryBuffer::getFile(EntryPath); + if (MBOrErr) { + AddBuffer(Task, std::move(*MBOrErr)); return AddStreamFn(); } + if (MBOrErr.getError() != std::errc::no_such_file_or_directory) + report_fatal_error(Twine("Failed to open cache file ") + EntryPath + + ": " + MBOrErr.getError().message() + "\n"); + // This native object stream is responsible for commiting the resulting - // file to the cache and calling AddFile to add it to the link. + // file to the cache and calling AddBuffer to add it to the link. struct CacheStream : NativeObjectStream { - AddFileFn AddFile; + AddBufferFn AddBuffer; std::string TempFilename; std::string EntryPath; unsigned Task; - CacheStream(std::unique_ptr OS, AddFileFn AddFile, + CacheStream(std::unique_ptr OS, AddBufferFn AddBuffer, std::string TempFilename, std::string EntryPath, unsigned Task) - : NativeObjectStream(std::move(OS)), AddFile(std::move(AddFile)), + : NativeObjectStream(std::move(OS)), AddBuffer(std::move(AddBuffer)), TempFilename(std::move(TempFilename)), EntryPath(std::move(EntryPath)), Task(Task) {} ~CacheStream() { + // FIXME: This code could race with the cache pruner, but it is unlikely + // that the cache pruner will choose to remove a newly created file. + // Make sure the file is closed before committing it. OS.reset(); // This is atomic on POSIX systems. if (auto EC = sys::fs::rename(TempFilename, EntryPath)) report_fatal_error(Twine("Failed to rename temporary file ") + TempFilename + ": " + EC.message() + "\n"); - AddFile(Task, EntryPath); + + ErrorOr> MBOrErr = + MemoryBuffer::getFile(EntryPath); + if (!MBOrErr) + report_fatal_error(Twine("Failed to open cache file ") + EntryPath + + ": " + MBOrErr.getError().message() + "\n"); + AddBuffer(Task, std::move(*MBOrErr)); } }; @@ -77,7 +92,7 @@ // This CacheStream will move the temporary file into the cache when done. return llvm::make_unique( llvm::make_unique(TempFD, /* ShouldClose */ true), - AddFile, TempFilename.str(), EntryPath.str(), Task); + AddBuffer, TempFilename.str(), EntryPath.str(), Task); }; }; } Index: llvm/trunk/tools/gold/gold-plugin.cpp =================================================================== --- llvm/trunk/tools/gold/gold-plugin.cpp +++ llvm/trunk/tools/gold/gold-plugin.cpp @@ -831,11 +831,15 @@ llvm::make_unique(FD, true)); }; - auto AddFile = [&](size_t Task, StringRef Path) { Filenames[Task] = Path; }; + auto AddBuffer = [&](size_t Task, std::unique_ptr MB) { + // Note that this requires that the memory buffers provided to AddBuffer are + // backed by a file. + Filenames[Task] = MB->getBufferIdentifier(); + }; NativeObjectCache Cache; if (!options::cache_dir.empty()) - Cache = check(localCache(options::cache_dir, AddFile)); + Cache = check(localCache(options::cache_dir, AddBuffer)); check(Lto->run(AddStream, Cache)); Index: llvm/trunk/tools/llvm-lto2/llvm-lto2.cpp =================================================================== --- llvm/trunk/tools/llvm-lto2/llvm-lto2.cpp +++ llvm/trunk/tools/llvm-lto2/llvm-lto2.cpp @@ -275,18 +275,13 @@ return llvm::make_unique(std::move(S)); }; - auto AddFile = [&](size_t Task, StringRef Path) { - auto ReloadedBufferOrErr = MemoryBuffer::getFile(Path); - if (auto EC = ReloadedBufferOrErr.getError()) - report_fatal_error(Twine("Can't reload cached file '") + Path + "': " + - EC.message() + "\n"); - - *AddStream(Task)->OS << (*ReloadedBufferOrErr)->getBuffer(); + auto AddBuffer = [&](size_t Task, std::unique_ptr MB) { + *AddStream(Task)->OS << MB->getBuffer(); }; NativeObjectCache Cache; if (!CacheDir.empty()) - Cache = check(localCache(CacheDir, AddFile), "failed to create cache"); + Cache = check(localCache(CacheDir, AddBuffer), "failed to create cache"); check(Lto.run(AddStream, Cache), "LTO::run failed"); }