//===----------------------------------------------------------------------===//
#include "MCJIT.h"
-#include "llvm/DataLayout.h"
-#include "llvm/DerivedTypes.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/ExecutionEngine/JITEventListener.h"
#include "llvm/ExecutionEngine/JITMemoryManager.h"
#include "llvm/ExecutionEngine/MCJIT.h"
#include "llvm/ExecutionEngine/ObjectBuffer.h"
#include "llvm/ExecutionEngine/ObjectImage.h"
-#include "llvm/Function.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/DynamicLibrary.h"
#include "llvm/Support/ErrorHandling.h"
ExecutionEngine *MCJIT::createJIT(Module *M,
std::string *ErrorStr,
- JITMemoryManager *JMM,
+ RTDyldMemoryManager *MemMgr,
bool GVsWithCode,
TargetMachine *TM) {
// Try to register the program as a source of symbols to resolve against.
// FIXME: Don't do this here.
sys::DynamicLibrary::LoadLibraryPermanently(0, NULL);
- return new MCJIT(M, TM, JMM, GVsWithCode);
+ return new MCJIT(M, TM, MemMgr ? MemMgr : new SectionMemoryManager(),
+ GVsWithCode);
}
MCJIT::MCJIT(Module *m, TargetMachine *tm, RTDyldMemoryManager *MM,
bool AllocateGVsWithCode)
: ExecutionEngine(m), TM(tm), Ctx(0), MemMgr(MM), Dyld(MM),
- isCompiled(false), M(m) {
+ IsLoaded(false), M(m), ObjCache(0) {
setDataLayout(TM->getDataLayout());
}
delete TM;
}
-void MCJIT::emitObject(Module *m) {
+void MCJIT::setObjectCache(ObjectCache* NewCache) {
+ ObjCache = NewCache;
+}
+
+ObjectBufferStream* MCJIT::emitObject(Module *m) {
/// Currently, MCJIT only supports a single module and the module passed to
/// this function call is expected to be the contained module. The module
/// is passed as a parameter here to prepare for multiple module support in
// FIXME: Track compilation state on a per-module basis when multiple modules
// are supported.
// Re-compilation is not supported
- if (isCompiled)
- return;
+ assert(!IsLoaded);
PassManager PM;
PM.add(new DataLayout(*TM->getDataLayout()));
// The RuntimeDyld will take ownership of this shortly
- OwningPtr<ObjectBufferStream> Buffer(new ObjectBufferStream());
+ OwningPtr<ObjectBufferStream> CompiledObject(new ObjectBufferStream());
// Turn the machine code intermediate representation into bytes in memory
// that may be executed.
- if (TM->addPassesToEmitMC(PM, Ctx, Buffer->getOStream(), false)) {
+ if (TM->addPassesToEmitMC(PM, Ctx, CompiledObject->getOStream(), false)) {
report_fatal_error("Target does not support MC emission!");
}
// Initialize passes.
PM.run(*m);
// Flush the output buffer to get the generated code into memory
- Buffer->flush();
+ CompiledObject->flush();
+
+ // If we have an object cache, tell it about the new object.
+ // Note that we're using the compiled image, not the loaded image (as below).
+ if (ObjCache) {
+ // MemoryBuffer is a thin wrapper around the actual memory, so it's OK
+ // to create a temporary object here and delete it after the call.
+ OwningPtr<MemoryBuffer> MB(CompiledObject->getMemBuffer());
+ ObjCache->notifyObjectCompiled(m, MB.get());
+ }
+
+ return CompiledObject.take();
+}
+
+void MCJIT::loadObject(Module *M) {
+
+ // Get a thread lock to make sure we aren't trying to load multiple times
+ MutexGuard locked(lock);
+
+ // FIXME: Track compilation state on a per-module basis when multiple modules
+ // are supported.
+ // Re-compilation is not supported
+ if (IsLoaded)
+ return;
+
+ OwningPtr<ObjectBuffer> ObjectToLoad;
+ // Try to load the pre-compiled object from cache if possible
+ if (0 != ObjCache) {
+ OwningPtr<MemoryBuffer> PreCompiledObject(ObjCache->getObjectCopy(M));
+ if (0 != PreCompiledObject.get())
+ ObjectToLoad.reset(new ObjectBuffer(PreCompiledObject.take()));
+ }
+
+ // If the cache did not contain a suitable object, compile the object
+ if (!ObjectToLoad) {
+ ObjectToLoad.reset(emitObject(M));
+ assert(ObjectToLoad.get() && "Compilation did not produce an object.");
+ }
// Load the object into the dynamic linker.
// handing off ownership of the buffer
- LoadedObject.reset(Dyld.loadObject(Buffer.take()));
+ LoadedObject.reset(Dyld.loadObject(ObjectToLoad.take()));
if (!LoadedObject)
report_fatal_error(Dyld.getErrorString());
NotifyObjectEmitted(*LoadedObject);
// FIXME: Add support for per-module compilation state
- isCompiled = true;
+ IsLoaded = true;
}
// FIXME: Add a parameter to identify which object is being finalized when
// protection in the interface.
void MCJIT::finalizeObject() {
// If the module hasn't been compiled, just do that.
- if (!isCompiled) {
- // If the call to Dyld.resolveRelocations() is removed from emitObject()
+ if (!IsLoaded) {
+ // If the call to Dyld.resolveRelocations() is removed from loadObject()
// we'll need to do that here.
- emitObject(M);
-
- // Set page permissions.
- MemMgr->applyPermissions();
-
- return;
+ loadObject(M);
+ } else {
+ // Resolve any relocations.
+ Dyld.resolveRelocations();
}
- // Resolve any relocations.
- Dyld.resolveRelocations();
+ StringRef EHData = Dyld.getEHFrameSection();
+ if (!EHData.empty())
+ MemMgr->registerEHFrames(EHData);
// Set page permissions.
- MemMgr->applyPermissions();
+ MemMgr->finalizeMemory();
}
void *MCJIT::getPointerToBasicBlock(BasicBlock *BB) {
// dies.
// FIXME: Add support for per-module compilation state
- if (!isCompiled)
- emitObject(M);
+ if (!IsLoaded)
+ loadObject(M);
if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) {
bool AbortOnFailure = !F->hasExternalWeakLinkage();
void *MCJIT::getPointerToNamedFunction(const std::string &Name,
bool AbortOnFailure) {
// FIXME: Add support for per-module compilation state
- if (!isCompiled)
- emitObject(M);
+ if (!IsLoaded)
+ loadObject(M);
if (!isSymbolSearchingDisabled() && MemMgr) {
void *ptr = MemMgr->getPointerToNamedFunction(Name, false);
projects / oota-llvm.git / blobdiff