/// Make sure all GlobalValues in this Module are fully read.
error_code materializeAll();
- /// MaterializeAllPermanently - Make sure all GlobalValues in this Module are
- /// fully read and clear the Materializer. If the module is corrupt, this
- /// returns true, fills in the optional string with information about the
- /// problem, and DOES NOT clear the old Materializer. If successful, this
- /// returns false.
- bool MaterializeAllPermanently(std::string *ErrInfo = 0);
+ /// Make sure all GlobalValues in this Module are fully read and clear the
+ /// Materializer. If the module is corrupt, this DOES NOT clear the old
+ /// Materializer.
+ error_code materializeAllPermanently();
/// @}
/// @name Direct access to the globals list, functions list, and symbol table
static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false);
// Read in the entire module, and destroy the BitcodeReader.
- if (M->MaterializeAllPermanently(ErrMsg)) {
+ if (error_code EC = M->materializeAllPermanently()) {
+ if (ErrMsg)
+ *ErrMsg = EC.message();
delete M;
return 0;
}
///
ExecutionEngine *Interpreter::create(Module *M, std::string* ErrStr) {
// Tell this Module to materialize everything and release the GVMaterializer.
- if (M->MaterializeAllPermanently(ErrStr))
+ if (error_code EC = M->materializeAllPermanently()) {
+ if (ErrStr)
+ *ErrStr = EC.message();
// We got an error, just return 0
return 0;
+ }
return new Interpreter(M);
}
return Materializer->MaterializeModule(this);
}
-bool Module::MaterializeAllPermanently(std::string *ErrInfo) {
- if (error_code EC = materializeAll()) {
- if (ErrInfo)
- *ErrInfo = EC.message();
- return true;
- }
+error_code Module::materializeAllPermanently() {
+ if (error_code EC = materializeAll())
+ return EC;
+
Materializer.reset();
- return false;
+ return error_code::success();
}
//===----------------------------------------------------------------------===//
TargetMachine *target = march->createTargetMachine(TripleStr, CPU, FeatureStr,
options);
- m->MaterializeAllPermanently();
+ m->materializeAllPermanently();
LTOModule *Ret = new LTOModule(m.take(), target);
if (Ret->parseSymbols(errMsg)) {
}
// If not jitting lazily, load the whole bitcode file eagerly too.
- std::string ErrorMsg;
if (NoLazyCompilation) {
- if (Mod->MaterializeAllPermanently(&ErrorMsg)) {
+ if (error_code EC = Mod->materializeAllPermanently()) {
errs() << argv[0] << ": bitcode didn't read correctly.\n";
- errs() << "Reason: " << ErrorMsg << "\n";
+ errs() << "Reason: " << EC.message() << "\n";
exit(1);
}
}
DebugIRPass->runOnModule(*Mod);
}
+ std::string ErrorMsg;
EngineBuilder builder(Mod);
builder.setMArch(MArch);
builder.setMCPU(MCPU);
DisplayFilename = InputFilename;
M.reset(getStreamedBitcodeModule(DisplayFilename, streamer, Context,
&ErrorMessage));
- if(M.get() != 0 && M->MaterializeAllPermanently(&ErrorMessage)) {
- M.reset();
+ if(M.get() != 0) {
+ if (error_code EC = M->materializeAllPermanently()) {
+ ErrorMessage = EC.message();
+ M.reset();
+ }
}
}