mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-26 04:32:44 +01:00
ff87ac19c3
After the call to sys::fs::exists succeeds, indicating a cache hit, we call AddFile and the client will open the file using the supplied path. If the client is using cache pruning, there is a potential race between the pruner and the client. To avoid this, change the caching API so that it provides a MemoryBuffer to the client, and have clients use that MemoryBuffer where possible. This scheme won't work with the gold plugin because the plugin API expects a file path. So we have the gold plugin use the buffer identifier as a path and live with the race for now. (Note that the gold plugin isn't actually affected by the problem at the moment because it doesn't support cache pruning.) This effectively reverts r279883 modulo the change to use the existing path in the gold plugin. Differential Revision: https://reviews.llvm.org/D31063 llvm-svn: 298020
99 lines
3.9 KiB
C++
99 lines
3.9 KiB
C++
//===-Caching.cpp - LLVM Link Time Optimizer Cache Handling ---------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the Caching for ThinLTO.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/LTO/Caching.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::lto;
|
|
|
|
Expected<NativeObjectCache> lto::localCache(StringRef CacheDirectoryPath,
|
|
AddBufferFn AddBuffer) {
|
|
if (std::error_code EC = sys::fs::create_directories(CacheDirectoryPath))
|
|
return errorCodeToError(EC);
|
|
|
|
return [=](unsigned Task, StringRef Key) -> AddStreamFn {
|
|
// First, see if we have a cache hit.
|
|
SmallString<64> EntryPath;
|
|
sys::path::append(EntryPath, CacheDirectoryPath, Key);
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> 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 AddBuffer to add it to the link.
|
|
struct CacheStream : NativeObjectStream {
|
|
AddBufferFn AddBuffer;
|
|
std::string TempFilename;
|
|
std::string EntryPath;
|
|
unsigned Task;
|
|
|
|
CacheStream(std::unique_ptr<raw_pwrite_stream> OS, AddBufferFn AddBuffer,
|
|
std::string TempFilename, std::string EntryPath,
|
|
unsigned Task)
|
|
: 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");
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> 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));
|
|
}
|
|
};
|
|
|
|
return [=](size_t Task) -> std::unique_ptr<NativeObjectStream> {
|
|
// Write to a temporary to avoid race condition
|
|
int TempFD;
|
|
SmallString<64> TempFilenameModel, TempFilename;
|
|
sys::path::append(TempFilenameModel, CacheDirectoryPath, "Thin-%%%%%%.tmp.o");
|
|
std::error_code EC =
|
|
sys::fs::createUniqueFile(TempFilenameModel, TempFD, TempFilename,
|
|
sys::fs::owner_read | sys::fs::owner_write);
|
|
if (EC) {
|
|
errs() << "Error: " << EC.message() << "\n";
|
|
report_fatal_error("ThinLTO: Can't get a temporary file");
|
|
}
|
|
|
|
// This CacheStream will move the temporary file into the cache when done.
|
|
return llvm::make_unique<CacheStream>(
|
|
llvm::make_unique<raw_fd_ostream>(TempFD, /* ShouldClose */ true),
|
|
AddBuffer, TempFilename.str(), EntryPath.str(), Task);
|
|
};
|
|
};
|
|
}
|