+++ /dev/null
-//===-- ObjectCache.h - Class definition for the ObjectCache -----C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIB_EXECUTIONENGINE_OBJECTCACHE_H
-#define LLVM_LIB_EXECUTIONENGINE_OBJECTCACHE_H
-
-#include "llvm/Support/MemoryBuffer.h"
-
-namespace llvm {
-
-class Module;
-
-/// This is the base ObjectCache type which can be provided to an
-/// ExecutionEngine for the purpose of avoiding compilation for Modules that
-/// have already been compiled and an object file is available.
-class ObjectCache {
-public:
- ObjectCache() { }
-
- virtual ~ObjectCache() { }
-
- /// notifyObjectCompiled - Provides a pointer to compiled code for Module M.
- virtual void notifyObjectCompiled(const Module *M, const MemoryBuffer *Obj) = 0;
-
- /// getObjectCopy - Returns a pointer to a newly allocated MemoryBuffer that
- /// contains the object which corresponds with Module M, or 0 if an object is
- /// not available. The caller owns the MemoryBuffer returned by this function.
- MemoryBuffer* getObjectCopy(const Module* M) {
- const MemoryBuffer* Obj = getObject(M);
- if (Obj)
- return MemoryBuffer::getMemBufferCopy(Obj->getBuffer());
- else
- return 0;
- }
-
-protected:
- /// getObject - Returns a pointer to a MemoryBuffer that contains an object
- /// that corresponds with Module M, or 0 if an object is not available.
- /// The pointer returned by this function is not suitable for loading because
- /// the memory is read-only and owned by the ObjectCache. To retrieve an
- /// owning pointer to a MemoryBuffer (which is suitable for calling
- /// RuntimeDyld::loadObject() with) use getObjectCopy() instead.
- virtual const MemoryBuffer* getObject(const Module* M) = 0;
-};
-
-}
-
-#endif
MCJIT::MCJIT(Module *m, TargetMachine *tm, RTDyldMemoryManager *MM,
bool AllocateGVsWithCode)
: ExecutionEngine(m), TM(tm), Ctx(0), MemMgr(MM), Dyld(MM),
- IsLoaded(false), M(m), ObjCache(0) {
+ isCompiled(false), M(m) {
setDataLayout(TM->getDataLayout());
}
delete TM;
}
-void MCJIT::setObjectCache(ObjectCache* NewCache) {
- ObjCache = NewCache;
-}
-
-ObjectBufferStream* MCJIT::emitObject(Module *m) {
+void 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
- assert(!IsLoaded);
+ if (isCompiled)
+ return;
PassManager PM;
PM.add(new DataLayout(*TM->getDataLayout()));
// The RuntimeDyld will take ownership of this shortly
- OwningPtr<ObjectBufferStream> CompiledObject(new ObjectBufferStream());
+ OwningPtr<ObjectBufferStream> Buffer(new ObjectBufferStream());
// Turn the machine code intermediate representation into bytes in memory
// that may be executed.
- if (TM->addPassesToEmitMC(PM, Ctx, CompiledObject->getOStream(), false)) {
+ if (TM->addPassesToEmitMC(PM, Ctx, Buffer->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
- 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) {
- ObjCache->notifyObjectCompiled(m, CompiledObject->getMemBuffer());
- }
-
- 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.");
- }
+ Buffer->flush();
// Load the object into the dynamic linker.
// handing off ownership of the buffer
- LoadedObject.reset(Dyld.loadObject(ObjectToLoad.take()));
+ LoadedObject.reset(Dyld.loadObject(Buffer.take()));
if (!LoadedObject)
report_fatal_error(Dyld.getErrorString());
NotifyObjectEmitted(*LoadedObject);
// FIXME: Add support for per-module compilation state
- IsLoaded = true;
+ isCompiled = 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 (!IsLoaded) {
- // If the call to Dyld.resolveRelocations() is removed from loadObject()
+ if (!isCompiled) {
+ // If the call to Dyld.resolveRelocations() is removed from emitObject()
// we'll need to do that here.
- loadObject(M);
+ emitObject(M);
// Set page permissions.
MemMgr->applyPermissions();
// dies.
// FIXME: Add support for per-module compilation state
- if (!IsLoaded)
- loadObject(M);
+ if (!isCompiled)
+ emitObject(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 (!IsLoaded)
- loadObject(M);
+ if (!isCompiled)
+ emitObject(M);
if (!isSymbolSearchingDisabled() && MemMgr) {
void *ptr = MemMgr->getPointerToNamedFunction(Name, false);
+++ /dev/null
-//===- MCJITObjectCacheTest.cpp - Unit tests for MCJIT object caching -----===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/OwningPtr.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/ExecutionEngine/JIT.h"
-#include "llvm/ExecutionEngine/MCJIT.h"
-#include "llvm/ExecutionEngine/ObjectCache.h"
-#include "llvm/ExecutionEngine/SectionMemoryManager.h"
-#include "MCJITTestBase.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-
-namespace {
-
-class TestObjectCache : public ObjectCache {
-public:
- TestObjectCache() : DuplicateInserted(false) { }
-
- virtual ~TestObjectCache() {
- // Free any buffers we've allocated.
- SmallVector<MemoryBuffer *, 2>::iterator it, end;
- end = AllocatedBuffers.end();
- for (it = AllocatedBuffers.begin(); it != end; ++it) {
- delete *it;
- }
- AllocatedBuffers.clear();
- }
-
- virtual void notifyObjectCompiled(const Module *M, const MemoryBuffer *Obj) {
- // If we've seen this module before, note that.
- const std::string ModuleID = M->getModuleIdentifier();
- if (ObjMap.find(ModuleID) != ObjMap.end())
- DuplicateInserted = true;
- // Store a copy of the buffer in our map.
- ObjMap[ModuleID] = copyBuffer(Obj);
- }
-
- // Test-harness-specific functions
- bool wereDuplicatesInserted() { return DuplicateInserted; }
-
- bool wasModuleLookedUp(const Module *M) {
- return ModulesLookedUp.find(M->getModuleIdentifier())
- != ModulesLookedUp.end();
- }
-
- const MemoryBuffer* getObjectInternal(const Module* M) {
- // Look for the module in our map.
- const std::string ModuleID = M->getModuleIdentifier();
- StringMap<const MemoryBuffer *>::iterator it = ObjMap.find(ModuleID);
- if (it == ObjMap.end())
- return 0;
- return it->second;
- }
-
-protected:
- virtual const MemoryBuffer* getObject(const Module* M) {
- const MemoryBuffer* BufferFound = getObjectInternal(M);
- ModulesLookedUp.insert(M->getModuleIdentifier());
- return BufferFound;
- }
-
-private:
- MemoryBuffer *copyBuffer(const MemoryBuffer *Buf) {
- // Create a local copy of the buffer.
- MemoryBuffer *NewBuffer = MemoryBuffer::getMemBufferCopy(Buf->getBuffer());
- AllocatedBuffers.push_back(NewBuffer);
- return NewBuffer;
- }
-
- StringMap<const MemoryBuffer *> ObjMap;
- StringSet<> ModulesLookedUp;
- SmallVector<MemoryBuffer *, 2> AllocatedBuffers;
- bool DuplicateInserted;
-};
-
-class MCJITObjectCacheTest : public testing::Test, public MCJITTestBase {
-protected:
-
- enum {
- OriginalRC = 6,
- ReplacementRC = 7
- };
-
- virtual void SetUp() {
- M.reset(createEmptyModule("<main>"));
- Main = insertMainFunction(M.get(), OriginalRC);
- }
-
- void compileAndRun(int ExpectedRC = OriginalRC) {
- // This function shouldn't be called until after SetUp.
- ASSERT_TRUE(0 != TheJIT);
- ASSERT_TRUE(0 != Main);
-
- TheJIT->finalizeObject();
- void *vPtr = TheJIT->getPointerToFunction(Main);
-
- static_cast<SectionMemoryManager*>(MM)->invalidateInstructionCache();
-
- EXPECT_TRUE(0 != vPtr)
- << "Unable to get pointer to main() from JIT";
-
- int (*FuncPtr)(void) = (int(*)(void))(intptr_t)vPtr;
- int returnCode = FuncPtr();
- EXPECT_EQ(returnCode, ExpectedRC);
- }
-
- Function *Main;
-};
-
-TEST_F(MCJITObjectCacheTest, SetNullObjectCache) {
- SKIP_UNSUPPORTED_PLATFORM;
-
- createJIT(M.take());
-
- TheJIT->setObjectCache(NULL);
-
- compileAndRun();
-}
-
-
-TEST_F(MCJITObjectCacheTest, VerifyBasicObjectCaching) {
- SKIP_UNSUPPORTED_PLATFORM;
-
- OwningPtr<TestObjectCache> Cache(new TestObjectCache);
-
- // Save a copy of the module pointer before handing it off to MCJIT.
- const Module * SavedModulePointer = M.get();
-
- createJIT(M.take());
-
- TheJIT->setObjectCache(Cache.get());
-
- // Verify that our object cache does not contain the module yet.
- const MemoryBuffer *ObjBuffer = Cache->getObjectInternal(SavedModulePointer);
- EXPECT_EQ(0, ObjBuffer);
-
- compileAndRun();
-
- // Verify that MCJIT tried to look-up this module in the cache.
- EXPECT_TRUE(Cache->wasModuleLookedUp(SavedModulePointer));
-
- // Verify that our object cache now contains the module.
- ObjBuffer = Cache->getObjectInternal(SavedModulePointer);
- EXPECT_TRUE(0 != ObjBuffer);
-
- // Verify that the cache was only notified once.
- EXPECT_FALSE(Cache->wereDuplicatesInserted());
-}
-
-TEST_F(MCJITObjectCacheTest, VerifyLoadFromCache) {
- SKIP_UNSUPPORTED_PLATFORM;
-
- OwningPtr<TestObjectCache> Cache(new TestObjectCache);
-
- // Compile this module with an MCJIT engine
- createJIT(M.take());
- TheJIT->setObjectCache(Cache.get());
- TheJIT->finalizeObject();
-
- // Destroy the MCJIT engine we just used
- TheJIT.reset();
-
- // Create a new memory manager.
- MM = new SectionMemoryManager;
-
- // Create a new module and save it. Use a different return code so we can
- // tell if MCJIT compiled this module or used the cache.
- M.reset(createEmptyModule("<main>"));
- Main = insertMainFunction(M.get(), ReplacementRC);
- const Module * SecondModulePointer = M.get();
-
- // Create a new MCJIT instance to load this module then execute it.
- createJIT(M.take());
- TheJIT->setObjectCache(Cache.get());
- compileAndRun();
-
- // Verify that MCJIT tried to look-up this module in the cache.
- EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
-
- // Verify that MCJIT didn't try to cache this again.
- EXPECT_FALSE(Cache->wereDuplicatesInserted());
-}
-
-TEST_F(MCJITObjectCacheTest, VerifyNonLoadFromCache) {
- SKIP_UNSUPPORTED_PLATFORM;
-
- OwningPtr<TestObjectCache> Cache(new TestObjectCache);
-
- // Compile this module with an MCJIT engine
- createJIT(M.take());
- TheJIT->setObjectCache(Cache.get());
- TheJIT->finalizeObject();
-
- // Destroy the MCJIT engine we just used
- TheJIT.reset();
-
- // Create a new memory manager.
- MM = new SectionMemoryManager;
-
- // Create a new module and save it. Use a different return code so we can
- // tell if MCJIT compiled this module or used the cache. Note that we use
- // a new module name here so the module shouldn't be found in the cache.
- M.reset(createEmptyModule("<not-main>"));
- Main = insertMainFunction(M.get(), ReplacementRC);
- const Module * SecondModulePointer = M.get();
-
- // Create a new MCJIT instance to load this module then execute it.
- createJIT(M.take());
- TheJIT->setObjectCache(Cache.get());
-
- // Verify that our object cache does not contain the module yet.
- const MemoryBuffer *ObjBuffer = Cache->getObjectInternal(SecondModulePointer);
- EXPECT_EQ(0, ObjBuffer);
-
- // Run the function and look for the replacement return code.
- compileAndRun(ReplacementRC);
-
- // Verify that MCJIT tried to look-up this module in the cache.
- EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
-
- // Verify that our object cache now contains the module.
- ObjBuffer = Cache->getObjectInternal(SecondModulePointer);
- EXPECT_TRUE(0 != ObjBuffer);
-
- // Verify that MCJIT didn't try to cache this again.
- EXPECT_FALSE(Cache->wereDuplicatesInserted());
-}
-
-} // Namespace
-
projects / oota-llvm.git / commitdiff