RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-26 04:32:44 +01:00
Code Issues Projects Releases Wiki Activity

Bitcode: Change getModuleSummaryIndex() to return an llvm::Expected.

Browse Source 
Differential Revision: https://reviews.llvm.org/D26539

llvm-svn: 286624
This commit is contained in:
Peter Collingbourne 2016-11-11 19:50:39 +00:00
parent 3a8f902dd8
commit a426ef0167
9 changed files with 60 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/Bitcode/BitcodeReader.h
View File

@ -32,9 +32,6 @@ namespace llvm {
// Remove these functions once no longer needed by the C and libLTO APIs.
std::error_code errorToErrorCodeAndEmitErrors(LLVMContext &Ctx, Error Err);
std::error_code
errorToErrorCodeAndEmitErrors(const DiagnosticHandlerFunction &DiagHandler,
Error Err);
template <typename T>
ErrorOr<T> expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected<T> Val) {
@ -80,9 +77,8 @@ namespace llvm {
Expected<bool> hasGlobalValueSummary(MemoryBufferRef Buffer);
/// Parse the specified bitcode buffer, returning the module summary index.
ErrorOr<std::unique_ptr<ModuleSummaryIndex>>
getModuleSummaryIndex(MemoryBufferRef Buffer,
const DiagnosticHandlerFunction &DiagnosticHandler);
Expected<std::unique_ptr<ModuleSummaryIndex>>
getModuleSummaryIndex(MemoryBufferRef Buffer);
/// isBitcodeWrapper - Return true if the given bytes are the magic bytes
/// for an LLVM IR bitcode wrapper.

9
include/llvm/Object/ModuleSummaryIndexObjectFile.h
View File

@ -82,16 +82,15 @@ public:
/// \brief Parse module summary index in the given memory buffer.
/// Return new ModuleSummaryIndexObjectFile instance containing parsed module
/// summary/index.
static ErrorOr<std::unique_ptr<ModuleSummaryIndexObjectFile>>
create(MemoryBufferRef Object,
const DiagnosticHandlerFunction &DiagnosticHandler);
static Expected<std::unique_ptr<ModuleSummaryIndexObjectFile>>
create(MemoryBufferRef Object);
};
}
/// Parse the module summary index out of an IR file and return the module
/// summary index object if found, or nullptr if not.
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> getModuleSummaryIndexForFile(
StringRef Path, const DiagnosticHandlerFunction &DiagnosticHandler);
Expected<std::unique_ptr<ModuleSummaryIndex>>
getModuleSummaryIndexForFile(StringRef Path);
}
#endif

28
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -841,19 +841,6 @@ std::error_code llvm::errorToErrorCodeAndEmitErrors(LLVMContext &Ctx,
return std::error_code();
}
std::error_code llvm::errorToErrorCodeAndEmitErrors(
const DiagnosticHandlerFunction &DiagHandler, Error Err) {
if (Err) {
std::error_code EC;
handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
EC = EIB.convertToErrorCode();
DiagHandler(DiagnosticInfoInlineAsm(EIB.message()));
});
return EC;
}
return std::error_code();
}
BitcodeReader::BitcodeReader(BitstreamCursor Stream, LLVMContext &Context)
: BitcodeReaderBase(std::move(Stream)), Context(Context), ValueList(Context),
MetadataList(Context) {}
@ -6663,22 +6650,19 @@ Expected<std::string> llvm::getBitcodeProducerString(MemoryBufferRef Buffer) {
}
// Parse the specified bitcode buffer, returning the function info index.
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> llvm::getModuleSummaryIndex(
MemoryBufferRef Buffer,
const DiagnosticHandlerFunction &DiagnosticHandler) {
Expected<std::unique_ptr<ModuleSummaryIndex>>
llvm::getModuleSummaryIndex(MemoryBufferRef Buffer) {
Expected<BitstreamCursor> StreamOrErr = initStream(Buffer);
if (!StreamOrErr)
return errorToErrorCodeAndEmitErrors(DiagnosticHandler,
StreamOrErr.takeError());
return StreamOrErr.takeError();
ModuleSummaryIndexBitcodeReader R(std::move(*StreamOrErr));
auto Index = llvm::make_unique<ModuleSummaryIndex>();
if (std::error_code EC = errorToErrorCodeAndEmitErrors(
DiagnosticHandler,
R.parseSummaryIndexInto(Index.get(), Buffer.getBufferIdentifier())))
return EC;
if (Error Err =
R.parseSummaryIndexInto(Index.get(), Buffer.getBufferIdentifier()))
return std::move(Err);
return std::move(Index);
}

7
lib/LTO/LTO.cpp
View File

@ -417,11 +417,10 @@ Error LTO::addThinLTO(std::unique_ptr<InputFile> Input,
collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
MemoryBufferRef MBRef = Input->Obj->getMemoryBufferRef();
ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>>
SummaryObjOrErr =
object::ModuleSummaryIndexObjectFile::create(MBRef, Conf.DiagHandler);
Expected<std::unique_ptr<object::ModuleSummaryIndexObjectFile>>
SummaryObjOrErr = object::ModuleSummaryIndexObjectFile::create(MBRef);
if (!SummaryObjOrErr)
return errorCodeToError(SummaryObjOrErr.getError());
return SummaryObjOrErr.takeError();
ThinLTO.CombinedIndex.mergeFrom((*SummaryObjOrErr)->takeIndex(),
ThinLTO.ModuleMap.size());

18
lib/LTO/ThinLTOCodeGenerator.cpp
View File

@ -69,12 +69,6 @@ namespace {
static cl::opt<int>
ThreadCount("threads", cl::init(llvm::heavyweight_hardware_concurrency()));
static void diagnosticHandler(const DiagnosticInfo &DI) {
DiagnosticPrinterRawOStream DP(errs());
DI.print(DP);
errs() << '\n';
}
// Simple helper to save temporary files for debug.
static void saveTempBitcode(const Module &TheModule, StringRef TempDir,
unsigned count, StringRef Suffix) {
@ -513,13 +507,13 @@ std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
std::unique_ptr<ModuleSummaryIndex> CombinedIndex;
uint64_t NextModuleId = 0;
for (auto &ModuleBuffer : Modules) {
ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr =
object::ModuleSummaryIndexObjectFile::create(ModuleBuffer,
diagnosticHandler);
if (std::error_code EC = ObjOrErr.getError()) {
Expected<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr =
object::ModuleSummaryIndexObjectFile::create(ModuleBuffer);
if (!ObjOrErr) {
// FIXME diagnose
errs() << "error: can't create ModuleSummaryIndexObjectFile for buffer: "
<< EC.message() << "\n";
logAllUnhandledErrors(
ObjOrErr.takeError(), errs(),
"error: can't create ModuleSummaryIndexObjectFile for buffer: ");
return nullptr;
}
auto Index = (*ObjOrErr)->takeIndex();

37
lib/Object/ModuleSummaryIndexObjectFile.cpp
View File

@ -70,44 +70,37 @@ ModuleSummaryIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
// Parse module summary index in the given memory buffer.
// Return new ModuleSummaryIndexObjectFile instance containing parsed
// module summary/index.
ErrorOr<std::unique_ptr<ModuleSummaryIndexObjectFile>>
ModuleSummaryIndexObjectFile::create(
MemoryBufferRef Object,
const DiagnosticHandlerFunction &DiagnosticHandler) {
std::unique_ptr<ModuleSummaryIndex> Index;
Expected<std::unique_ptr<ModuleSummaryIndexObjectFile>>
ModuleSummaryIndexObjectFile::create(MemoryBufferRef Object) {
ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
if (!BCOrErr)
return BCOrErr.getError();
return errorCodeToError(BCOrErr.getError());
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IOrErr =
getModuleSummaryIndex(BCOrErr.get(), DiagnosticHandler);
Expected<std::unique_ptr<ModuleSummaryIndex>> IOrErr =
getModuleSummaryIndex(BCOrErr.get());
if (std::error_code EC = IOrErr.getError())
return EC;
Index = std::move(IOrErr.get());
if (!IOrErr)
return std::move(IOrErr.takeError());
std::unique_ptr<ModuleSummaryIndex> Index = std::move(IOrErr.get());
return llvm::make_unique<ModuleSummaryIndexObjectFile>(Object,
std::move(Index));
}
// Parse the module summary index out of an IR file and return the summary
// index object if found, or nullptr if not.
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> llvm::getModuleSummaryIndexForFile(
StringRef Path, const DiagnosticHandlerFunction &DiagnosticHandler) {
Expected<std::unique_ptr<ModuleSummaryIndex>>
llvm::getModuleSummaryIndexForFile(StringRef Path) {
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
MemoryBuffer::getFileOrSTDIN(Path);
std::error_code EC = FileOrErr.getError();
if (EC)
return EC;
return errorCodeToError(EC);
MemoryBufferRef BufferRef = (FileOrErr.get())->getMemBufferRef();
ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr =
object::ModuleSummaryIndexObjectFile::create(BufferRef,
DiagnosticHandler);
EC = ObjOrErr.getError();
if (EC)
return EC;
Expected<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr =
object::ModuleSummaryIndexObjectFile::create(BufferRef);
if (!ObjOrErr)
return ObjOrErr.takeError();
object::ModuleSummaryIndexObjectFile &Obj = **ObjOrErr;
return Obj.takeIndex();

41
lib/Transforms/IPO/FunctionImport.cpp
View File

@ -739,36 +739,6 @@ static cl::opt<std::string>
SummaryFile("summary-file",
cl::desc("The summary file to use for function importing."));
static void diagnosticHandler(const DiagnosticInfo &DI) {
raw_ostream &OS = errs();
DiagnosticPrinterRawOStream DP(OS);
DI.print(DP);
OS << '\n';
}
/// Parse the summary index out of an IR file and return the summary
/// index object if found, or nullptr if not.
static std::unique_ptr<ModuleSummaryIndex> getModuleSummaryIndexForFile(
StringRef Path, std::string &Error,
const DiagnosticHandlerFunction &DiagnosticHandler) {
std::unique_ptr<MemoryBuffer> Buffer;
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
MemoryBuffer::getFile(Path);
if (std::error_code EC = BufferOrErr.getError()) {
Error = EC.message();
return nullptr;
}
Buffer = std::move(BufferOrErr.get());
ErrorOr<std::unique_ptr<object::ModuleSummaryIndexObjectFile>> ObjOrErr =
object::ModuleSummaryIndexObjectFile::create(Buffer->getMemBufferRef(),
DiagnosticHandler);
if (std::error_code EC = ObjOrErr.getError()) {
Error = EC.message();
return nullptr;
}
return (*ObjOrErr)->takeIndex();
}
static bool doImportingForModule(Module &M, const ModuleSummaryIndex *Index) {
if (SummaryFile.empty() && !Index)
report_fatal_error("error: -function-import requires -summary-file or "
@ -777,13 +747,14 @@ static bool doImportingForModule(Module &M, const ModuleSummaryIndex *Index) {
if (!SummaryFile.empty()) {
if (Index)
report_fatal_error("error: -summary-file and index from frontend\n");
std::string Error;
IndexPtr =
getModuleSummaryIndexForFile(SummaryFile, Error, diagnosticHandler);
if (!IndexPtr) {
errs() << "Error loading file '" << SummaryFile << "': " << Error << "\n";
Expected<std::unique_ptr<ModuleSummaryIndex>> IndexPtrOrErr =
getModuleSummaryIndexForFile(SummaryFile);
if (!IndexPtrOrErr) {
logAllUnhandledErrors(IndexPtrOrErr.takeError(), errs(),
"Error loading file '" + SummaryFile + "': ");
return false;
}
IndexPtr = std::move(*IndexPtrOrErr);
Index = IndexPtr.get();
}

28
tools/llvm-link/llvm-link.cpp
View File

@ -180,7 +180,7 @@ Module &ModuleLazyLoaderCache::operator()(const char *argv0,
}
} // anonymous namespace
static void diagnosticHandler(const DiagnosticInfo &DI) {
static void diagnosticHandler(const DiagnosticInfo &DI, void *C) {
unsigned Severity = DI.getSeverity();
switch (Severity) {
case DS_Error:
@ -201,23 +201,13 @@ static void diagnosticHandler(const DiagnosticInfo &DI) {
errs() << '\n';
}
static void diagnosticHandlerWithContext(const DiagnosticInfo &DI, void *C) {
diagnosticHandler(DI);
}
/// Import any functions requested via the -import option.
static bool importFunctions(const char *argv0, LLVMContext &Context,
Linker &L) {
if (SummaryIndex.empty())
return true;
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
llvm::getModuleSummaryIndexForFile(SummaryIndex, diagnosticHandler);
std::error_code EC = IndexOrErr.getError();
if (EC) {
errs() << EC.message() << '\n';
return false;
}
auto Index = std::move(IndexOrErr.get());
std::unique_ptr<ModuleSummaryIndex> Index =
ExitOnErr(llvm::getModuleSummaryIndexForFile(SummaryIndex));
// Map of Module -> List of globals to import from the Module
std::map<StringRef, DenseSet<const GlobalValue *>> ModuleToGlobalsToImportMap;
@ -319,14 +309,8 @@ static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L,
// If a module summary index is supplied, load it so linkInModule can treat
// local functions/variables as exported and promote if necessary.
if (!SummaryIndex.empty()) {
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
llvm::getModuleSummaryIndexForFile(SummaryIndex, diagnosticHandler);
std::error_code EC = IndexOrErr.getError();
if (EC) {
errs() << EC.message() << '\n';
return false;
}
auto Index = std::move(IndexOrErr.get());
std::unique_ptr<ModuleSummaryIndex> Index =
ExitOnErr(llvm::getModuleSummaryIndexForFile(SummaryIndex));
// Promotion
if (renameModuleForThinLTO(*M, *Index))
@ -353,7 +337,7 @@ int main(int argc, char **argv) {
ExitOnErr.setBanner(std::string(argv[0]) + ": ");
LLVMContext Context;
Context.setDiagnosticHandler(diagnosticHandlerWithContext, nullptr, true);
Context.setDiagnosticHandler(diagnosticHandler, nullptr, true);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");

37
tools/llvm-lto/llvm-lto.cpp
View File

@ -197,7 +197,7 @@ static void handleDiagnostics(lto_codegen_diagnostic_severity_t Severity,
}
static std::string CurrentActivity;
static void diagnosticHandler(const DiagnosticInfo &DI) {
static void diagnosticHandler(const DiagnosticInfo &DI, void *Context) {
raw_ostream &OS = errs();
OS << "llvm-lto: ";
switch (DI.getSeverity()) {
@ -226,11 +226,6 @@ static void diagnosticHandler(const DiagnosticInfo &DI) {
exit(1);
}
static void diagnosticHandlerWithContext(const DiagnosticInfo &DI,
void *Context) {
diagnosticHandler(DI);
}
static void error(const Twine &Msg) {
errs() << "llvm-lto: " << Msg << '\n';
exit(1);
@ -260,7 +255,7 @@ getLocalLTOModule(StringRef Path, std::unique_ptr<MemoryBuffer> &Buffer,
Buffer = std::move(BufferOrErr.get());
CurrentActivity = ("loading file '" + Path + "'").str();
std::unique_ptr<LLVMContext> Context = llvm::make_unique<LLVMContext>();
Context->setDiagnosticHandler(diagnosticHandlerWithContext, nullptr, true);
Context->setDiagnosticHandler(diagnosticHandler, nullptr, true);
ErrorOr<std::unique_ptr<LTOModule>> Ret = LTOModule::createInLocalContext(
std::move(Context), Buffer->getBufferStart(), Buffer->getBufferSize(),
Options, Path);
@ -272,12 +267,9 @@ getLocalLTOModule(StringRef Path, std::unique_ptr<MemoryBuffer> &Buffer,
/// Print some statistics on the index for each input files.
void printIndexStats() {
for (auto &Filename : InputFilenames) {
CurrentActivity = "loading file '" + Filename + "'";
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
llvm::getModuleSummaryIndexForFile(Filename, diagnosticHandler);
error(IndexOrErr, "error " + CurrentActivity);
std::unique_ptr<ModuleSummaryIndex> Index = std::move(IndexOrErr.get());
CurrentActivity = "";
ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename + "': ");
std::unique_ptr<ModuleSummaryIndex> Index =
ExitOnErr(llvm::getModuleSummaryIndexForFile(Filename));
// Skip files without a module summary.
if (!Index)
report_fatal_error(Filename + " does not contain an index");
@ -330,12 +322,9 @@ static void createCombinedModuleSummaryIndex() {
ModuleSummaryIndex CombinedIndex;
uint64_t NextModuleId = 0;
for (auto &Filename : InputFilenames) {
CurrentActivity = "loading file '" + Filename + "'";
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
llvm::getModuleSummaryIndexForFile(Filename, diagnosticHandler);
error(IndexOrErr, "error " + CurrentActivity);
std::unique_ptr<ModuleSummaryIndex> Index = std::move(IndexOrErr.get());
CurrentActivity = "";
ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename + "': ");
std::unique_ptr<ModuleSummaryIndex> Index =
ExitOnErr(llvm::getModuleSummaryIndexForFile(Filename));
// Skip files without a module summary.
if (!Index)
continue;
@ -400,11 +389,9 @@ loadAllFilesForIndex(const ModuleSummaryIndex &Index) {
std::unique_ptr<ModuleSummaryIndex> loadCombinedIndex() {
if (ThinLTOIndex.empty())
report_fatal_error("Missing -thinlto-index for ThinLTO promotion stage");
auto CurrentActivity = "loading file '" + ThinLTOIndex + "'";
ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
llvm::getModuleSummaryIndexForFile(ThinLTOIndex, diagnosticHandler);
error(IndexOrErr, "error " + CurrentActivity);
return std::move(IndexOrErr.get());
ExitOnError ExitOnErr("llvm-lto: error loading file '" + ThinLTOIndex +
"': ");
return ExitOnErr(llvm::getModuleSummaryIndexForFile(ThinLTOIndex));
}
static std::unique_ptr<Module> loadModule(StringRef Filename,
@ -802,7 +789,7 @@ int main(int argc, char **argv) {
unsigned BaseArg = 0;
LLVMContext Context;
Context.setDiagnosticHandler(diagnosticHandlerWithContext, nullptr, true);
Context.setDiagnosticHandler(diagnosticHandler, nullptr, true);
LTOCodeGenerator CodeGen(Context);