ErrorOr<Module *> getLazyBitcodeModule(std::unique_ptr<MemoryBuffer> &&Buffer,
LLVMContext &Context);
- /// getStreamedBitcodeModule - Read the header of the specified stream
- /// and prepare for lazy deserialization and streaming of function bodies.
- /// On error, this returns null, and fills in *ErrMsg with an error
- /// description if ErrMsg is non-null.
- Module *getStreamedBitcodeModule(const std::string &name,
- DataStreamer *streamer,
- LLVMContext &Context,
- std::string *ErrMsg = nullptr);
+ /// Read the header of the specified stream and prepare for lazy
+ /// deserialization and streaming of function bodies.
+ ErrorOr<std::unique_ptr<Module>>
+ getStreamedBitcodeModule(StringRef Name, DataStreamer *Streamer,
+ LLVMContext &Context);
/// Read the header of the specified bitcode buffer and extract just the
/// triple information. If successful, this returns a string. On error, this
std::error_code BitcodeReader::InitLazyStream() {
// Check and strip off the bitcode wrapper; BitstreamReader expects never to
// see it.
- StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer);
- StreamFile.reset(new BitstreamReader(Bytes));
+ auto OwnedBytes = make_unique<StreamingMemoryObject>(LazyStreamer);
+ StreamingMemoryObject &Bytes = *OwnedBytes;
+ StreamFile = make_unique<BitstreamReader>(std::move(OwnedBytes));
Stream.init(&*StreamFile);
unsigned char buf[16];
- if (Bytes->readBytes(buf, 16, 0) != 16)
+ if (Bytes.readBytes(buf, 16, 0) != 16)
return Error(BitcodeError::InvalidBitcodeSignature);
if (!isBitcode(buf, buf + 16))
const unsigned char *bitcodeStart = buf;
const unsigned char *bitcodeEnd = buf + 16;
SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
- Bytes->dropLeadingBytes(bitcodeStart - buf);
- Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart);
+ Bytes.dropLeadingBytes(bitcodeStart - buf);
+ Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
}
return std::error_code();
}
return getLazyBitcodeModuleImpl(std::move(Buffer), Context, false);
}
-Module *llvm::getStreamedBitcodeModule(const std::string &name,
- DataStreamer *streamer,
- LLVMContext &Context,
- std::string *ErrMsg) {
- Module *M = new Module(name, Context);
- BitcodeReader *R = new BitcodeReader(streamer, Context);
+ErrorOr<std::unique_ptr<Module>>
+llvm::getStreamedBitcodeModule(StringRef Name, DataStreamer *Streamer,
+ LLVMContext &Context) {
+ std::unique_ptr<Module> M = make_unique<Module>(Name, Context);
+ BitcodeReader *R = new BitcodeReader(Streamer, Context);
M->setMaterializer(R);
- if (std::error_code EC = R->ParseBitcodeInto(M)) {
- if (ErrMsg)
- *ErrMsg = EC.message();
- delete M; // Also deletes R.
- return nullptr;
- }
- return M;
+ if (std::error_code EC = R->ParseBitcodeInto(M.get()))
+ return EC;
+ return std::move(M);
}
ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBufferRef Buffer,
std::unique_ptr<Module> M;
// Use the bitcode streaming interface
- DataStreamer *streamer = getDataFileStreamer(InputFilename, &ErrorMessage);
- if (streamer) {
+ DataStreamer *Streamer = getDataFileStreamer(InputFilename, &ErrorMessage);
+ if (Streamer) {
std::string DisplayFilename;
if (InputFilename == "-")
DisplayFilename = "<stdin>";
else
DisplayFilename = InputFilename;
- M.reset(getStreamedBitcodeModule(DisplayFilename, streamer, Context,
- &ErrorMessage));
+ ErrorOr<std::unique_ptr<Module>> MOrErr =
+ getStreamedBitcodeModule(DisplayFilename, Streamer, Context);
+ if (std::error_code EC = MOrErr.getError())
+ ErrorMessage = EC.message();
+ else
+ M = std::move(*MOrErr);
if(M.get()) {
if (std::error_code EC = M->materializeAllPermanently()) {
ErrorMessage = EC.message();