//
//===----------------------------------------------------------------------===//
-#include "llvm/ADT/OwningPtr.h"
-#include "llvm/ADT/Triple.h"
#include "../../lib/ExecutionEngine/IntelJITEvents/IntelJITEventsWrapper.h"
+#include "llvm/ADT/Triple.h"
#include "llvm/ExecutionEngine/JITEventListener.h"
-#include "llvm/ExecutionEngine/JITMemoryManager.h"
#include "llvm/ExecutionEngine/MCJIT.h"
-#include "llvm/ExecutionEngine/ObjectImage.h"
-#include "llvm/LLVMContext.h"
-#include "llvm/Module.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IRReader/IRReader.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
#include "llvm/Support/Host.h"
-#include "llvm/Support/IRReader.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/raw_ostream.h"
#include <string>
using namespace llvm;
// Parse the bitcode...
SMDiagnostic Err;
- TheModule = ParseIRFile(IRFile, Err, Context);
+ std::unique_ptr<Module> TheModule(parseIRFile(IRFile, Err, Context));
if (!TheModule) {
errs() << Err.getMessage();
return;
}
- // FIXME: This is using the default legacy JITMemoryManager because it
- // supports poison memory. At some point, we'll need to update this to
- // use an MCJIT-specific memory manager. It might be nice to have the
- // poison memory option there too.
- JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
+ RTDyldMemoryManager *MemMgr = new SectionMemoryManager();
if (!MemMgr) {
errs() << "Unable to create memory manager.";
return;
}
- // Tell the memory manager to poison freed memory so that accessing freed
- // memory is more easily tested.
- MemMgr->setPoisonMemory(true);
-
// Override the triple to generate ELF on Windows since that's supported
Triple Tuple(TheModule->getTargetTriple());
if (Tuple.getTriple().empty())
- Tuple.setTriple(LLVM_HOSTTRIPLE);
+ Tuple.setTriple(sys::getProcessTriple());
- if (Tuple.isOSWindows() && Triple::ELF != Tuple.getEnvironment()) {
- Tuple.setEnvironment(Triple::ELF);
+ if (Tuple.isOSWindows() && !Tuple.isOSBinFormatELF()) {
+ Tuple.setObjectFormat(Triple::ELF);
TheModule->setTargetTriple(Tuple.getTriple());
}
// Compile the IR
std::string Error;
- TheJIT.reset(EngineBuilder(TheModule)
+ TheJIT.reset(EngineBuilder(std::move(TheModule))
.setEngineKind(EngineKind::JIT)
.setErrorStr(&Error)
- .setJITMemoryManager(MemMgr)
- .setUseMCJIT(true)
+ .setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>(MemMgr))
.create());
if (Error.empty() == false)
errs() << Error;
}
LLVMContext Context; // Global ownership
- Module *TheModule; // Owned by ExecutionEngine.
- JITMemoryManager *JMM; // Owned by ExecutionEngine.
- OwningPtr<ExecutionEngine> TheJIT;
+ std::unique_ptr<ExecutionEngine> TheJIT;
public:
void ProcessInput(const std::string &Filename) {
InitEE(Filename);
- llvm::OwningPtr<llvm::JITEventListener> Listener(JITEventListener::createIntelJITEventListener(
- new IntelJITEventsWrapper(NotifyEvent, 0,
- IsProfilingActive, 0, 0,
- GetNewMethodID)));
+ std::unique_ptr<llvm::JITEventListener> Listener(
+ JITEventListener::createIntelJITEventListener(new IntelJITEventsWrapper(
+ NotifyEvent, 0, IsProfilingActive, 0, 0, GetNewMethodID)));
TheJIT->RegisterJITEventListener(Listener.get());