RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-20 21:14:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Return a std::unique_ptr from the IRReader.h functions. NFC.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216466 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2014-08-26 17:29:46 +00:00
parent 1bfd87a150
commit 81e49922a8
10 changed files with 51 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
include/llvm/IRReader/IRReader.h
View File

@ -15,6 +15,8 @@
#ifndef LLVM_IRREADER_IRREADER_H
#define LLVM_IRREADER_IRREADER_H
#include "llvm/ADT/StringRef.h"
#include <memory>
#include <string>
namespace llvm {
@ -28,20 +30,21 @@ class LLVMContext;
/// for it which does lazy deserialization of function bodies. Otherwise,
/// attempt to parse it as LLVM Assembly and return a fully populated
/// Module.
Module *getLazyIRFileModule(const std::string &Filename, SMDiagnostic &Err,
LLVMContext &Context);
std::unique_ptr<Module> getLazyIRFileModule(StringRef Filename,
SMDiagnostic &Err,
LLVMContext &Context);
/// If the given MemoryBuffer holds a bitcode image, return a Module
/// for it. Otherwise, attempt to parse it as LLVM Assembly and return
/// a Module for it. This function *never* takes ownership of Buffer.
Module *ParseIR(MemoryBuffer *Buffer, SMDiagnostic &Err, LLVMContext &Context);
std::unique_ptr<Module> parseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
LLVMContext &Context);
/// If the given file holds a bitcode image, return a Module for it.
/// Otherwise, attempt to parse it as LLVM Assembly and return a Module
/// for it.
Module *ParseIRFile(const std::string &Filename, SMDiagnostic &Err,
LLVMContext &Context);
std::unique_ptr<Module> parseIRFile(StringRef Filename, SMDiagnostic &Err,
LLVMContext &Context);
}
#endif

31
lib/IRReader/IRReader.cpp
View File

@ -49,8 +49,9 @@ getLazyIRModule(std::unique_ptr<MemoryBuffer> Buffer, SMDiagnostic &Err,
return parseAssembly(std::move(Buffer), Err, Context);
}
Module *llvm::getLazyIRFileModule(const std::string &Filename,
SMDiagnostic &Err, LLVMContext &Context) {
std::unique_ptr<Module> llvm::getLazyIRFileModule(StringRef Filename,
SMDiagnostic &Err,
LLVMContext &Context) {
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
MemoryBuffer::getFileOrSTDIN(Filename);
if (std::error_code EC = FileOrErr.getError()) {
@ -59,33 +60,31 @@ Module *llvm::getLazyIRFileModule(const std::string &Filename,
return nullptr;
}
return getLazyIRModule(std::move(FileOrErr.get()), Err, Context).release();
return getLazyIRModule(std::move(FileOrErr.get()), Err, Context);
}
Module *llvm::ParseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
LLVMContext &Context) {
std::unique_ptr<Module> llvm::parseIR(MemoryBuffer *Buffer, SMDiagnostic &Err,
LLVMContext &Context) {
NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName,
TimePassesIsEnabled);
if (isBitcode((const unsigned char *)Buffer->getBufferStart(),
(const unsigned char *)Buffer->getBufferEnd())) {
ErrorOr<Module *> ModuleOrErr = parseBitcodeFile(Buffer, Context);
Module *M = nullptr;
if (std::error_code EC = ModuleOrErr.getError())
if (std::error_code EC = ModuleOrErr.getError()) {
Err = SMDiagnostic(Buffer->getBufferIdentifier(), SourceMgr::DK_Error,
EC.message());
else
M = ModuleOrErr.get();
// parseBitcodeFile does not take ownership of the Buffer.
return M;
return nullptr;
}
return std::unique_ptr<Module>(ModuleOrErr.get());
}
return parseAssembly(std::unique_ptr<MemoryBuffer>(MemoryBuffer::getMemBuffer(
Buffer->getBuffer(), Buffer->getBufferIdentifier())),
Err, Context).release();
Err, Context);
}
Module *llvm::ParseIRFile(const std::string &Filename, SMDiagnostic &Err,
LLVMContext &Context) {
std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
LLVMContext &Context) {
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
MemoryBuffer::getFileOrSTDIN(Filename);
if (std::error_code EC = FileOrErr.getError()) {
@ -94,7 +93,7 @@ Module *llvm::ParseIRFile(const std::string &Filename, SMDiagnostic &Err,
return nullptr;
}
return ParseIR(FileOrErr.get().get(), Err, Context);
return parseIR(FileOrErr.get().get(), Err, Context);
}
//===----------------------------------------------------------------------===//
@ -107,7 +106,7 @@ LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
SMDiagnostic Diag;
std::unique_ptr<MemoryBuffer> MB(unwrap(MemBuf));
*OutM = wrap(ParseIR(MB.get(), Diag, *unwrap(ContextRef)));
*OutM = wrap(parseIR(MB.get(), Diag, *unwrap(ContextRef)).release());
if(!*OutM) {
if (OutMessage) {

2
tools/bugpoint/BugDriver.cpp
View File

@ -85,7 +85,7 @@ BugDriver::~BugDriver() {
std::unique_ptr<Module> llvm::parseInputFile(StringRef Filename,
LLVMContext &Ctxt) {
SMDiagnostic Err;
std::unique_ptr<Module> Result (ParseIRFile(Filename, Err, Ctxt));
std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt);
if (!Result)
Err.print("bugpoint", errs());

2
tools/llc/llc.cpp
View File

@ -231,7 +231,7 @@ static int compileModule(char **argv, LLVMContext &Context) {
// If user just wants to list available options, skip module loading
if (!SkipModule) {
M.reset(ParseIRFile(InputFilename, Err, Context));
M = parseIRFile(InputFilename, Err, Context);
mod = M.get();
if (mod == nullptr) {
Err.print(argv[0], errs());

4
tools/lli/lli.cpp
View File

@ -399,7 +399,7 @@ int main(int argc, char **argv, char * const *envp) {
// Load the bitcode...
SMDiagnostic Err;
std::unique_ptr<Module> Owner(ParseIRFile(InputFile, Err, Context));
std::unique_ptr<Module> Owner = parseIRFile(InputFile, Err, Context);
Module *Mod = Owner.get();
if (!Mod) {
Err.print(argv[0], errs());
@ -513,7 +513,7 @@ int main(int argc, char **argv, char * const *envp) {
// Load any additional modules specified on the command line.
for (unsigned i = 0, e = ExtraModules.size(); i != e; ++i) {
std::unique_ptr<Module> XMod(ParseIRFile(ExtraModules[i], Err, Context));
std::unique_ptr<Module> XMod = parseIRFile(ExtraModules[i], Err, Context);
if (!XMod) {
Err.print(argv[0], errs());
return 1;

22
tools/llvm-diff/llvm-diff.cpp
View File

@ -32,21 +32,22 @@ using namespace llvm;
/// Reads a module from a file. On error, messages are written to stderr
/// and null is returned.
static Module *ReadModule(LLVMContext &Context, StringRef Name) {
static std::unique_ptr<Module> readModule(LLVMContext &Context,
StringRef Name) {
SMDiagnostic Diag;
Module *M = ParseIRFile(Name, Diag, Context);
std::unique_ptr<Module> M = parseIRFile(Name, Diag, Context);
if (!M)
Diag.print("llvm-diff", errs());
return M;
}
static void diffGlobal(DifferenceEngine &Engine, Module *L, Module *R,
static void diffGlobal(DifferenceEngine &Engine, Module &L, Module &R,
StringRef Name) {
// Drop leading sigils from the global name.
if (Name.startswith("@")) Name = Name.substr(1);
Function *LFn = L->getFunction(Name);
Function *RFn = R->getFunction(Name);
Function *LFn = L.getFunction(Name);
Function *RFn = R.getFunction(Name);
if (LFn && RFn)
Engine.diff(LFn, RFn);
else if (!LFn && !RFn)
@ -72,8 +73,8 @@ int main(int argc, char **argv) {
LLVMContext Context;
// Load both modules. Die if that fails.
Module *LModule = ReadModule(Context, LeftFilename);
Module *RModule = ReadModule(Context, RightFilename);
std::unique_ptr<Module> LModule = readModule(Context, LeftFilename);
std::unique_ptr<Module> RModule = readModule(Context, RightFilename);
if (!LModule || !RModule) return 1;
DiffConsumer Consumer;
@ -82,15 +83,12 @@ int main(int argc, char **argv) {
// If any global names were given, just diff those.
if (!GlobalsToCompare.empty()) {
for (unsigned I = 0, E = GlobalsToCompare.size(); I != E; ++I)
diffGlobal(Engine, LModule, RModule, GlobalsToCompare[I]);
diffGlobal(Engine, *LModule, *RModule, GlobalsToCompare[I]);
// Otherwise, diff everything in the module.
} else {
Engine.diff(LModule, RModule);
Engine.diff(LModule.get(), RModule.get());
}
delete LModule;
delete RModule;
return Consumer.hadDifferences();
}

3
tools/llvm-extract/llvm-extract.cpp
View File

@ -101,8 +101,7 @@ int main(int argc, char **argv) {
// Use lazy loading, since we only care about selected global values.
SMDiagnostic Err;
std::unique_ptr<Module> M;
M.reset(getLazyIRFileModule(InputFilename, Err, Context));
std::unique_ptr<Module> M = getLazyIRFileModule(InputFilename, Err, Context);
if (!M.get()) {
Err.print(argv[0], errs());

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

@ -55,17 +55,16 @@ static cl::opt<bool>
SuppressWarnings("suppress-warnings", cl::desc("Suppress all linking warnings"),
cl::init(false));
// LoadFile - Read the specified bitcode file in and return it. This routine
// searches the link path for the specified file to try to find it...
// Read the specified bitcode file in and return it. This routine searches the
// link path for the specified file to try to find it...
//
static inline Module *LoadFile(const char *argv0, const std::string &FN,
LLVMContext& Context) {
static std::unique_ptr<Module>
loadFile(const char *argv0, const std::string &FN, LLVMContext &Context) {
SMDiagnostic Err;
if (Verbose) errs() << "Loading '" << FN << "'\n";
Module* Result = nullptr;
Result = ParseIRFile(FN, Err, Context);
if (Result) return Result; // Load successful!
std::unique_ptr<Module> Result = parseIRFile(FN, Err, Context);
if (Result)
return Result;
Err.print(argv0, errs());
return nullptr;
@ -83,8 +82,8 @@ int main(int argc, char **argv) {
unsigned BaseArg = 0;
std::string ErrorMessage;
std::unique_ptr<Module> Composite(
LoadFile(argv[0], InputFilenames[BaseArg], Context));
std::unique_ptr<Module> Composite =
loadFile(argv[0], InputFilenames[BaseArg], Context);
if (!Composite.get()) {
errs() << argv[0] << ": error loading file '"
<< InputFilenames[BaseArg] << "'\n";
@ -93,7 +92,7 @@ int main(int argc, char **argv) {
Linker L(Composite.get(), SuppressWarnings);
for (unsigned i = BaseArg+1; i < InputFilenames.size(); ++i) {
std::unique_ptr<Module> M(LoadFile(argv[0], InputFilenames[i], Context));
std::unique_ptr<Module> M = loadFile(argv[0], InputFilenames[i], Context);
if (!M.get()) {
errs() << argv[0] << ": error loading file '" <<InputFilenames[i]<< "'\n";
return 1;

3
tools/opt/opt.cpp
View File

@ -362,8 +362,7 @@ int main(int argc, char **argv) {
SMDiagnostic Err;
// Load the input module...
std::unique_ptr<Module> M;
M.reset(ParseIRFile(InputFilename, Err, Context));
std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
if (!M.get()) {
Err.print(argv[0], errs());

3
tools/verify-uselistorder/verify-uselistorder.cpp
View File

@ -520,8 +520,7 @@ int main(int argc, char **argv) {
SMDiagnostic Err;
// Load the input module...
std::unique_ptr<Module> M;
M.reset(ParseIRFile(InputFilename, Err, Context));
std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
if (!M.get()) {
Err.print(argv[0], errs());