MCJITObjectCacheTest.cpp [plain text]
#include "llvm/ADT/OwningPtr.h"
#include "MCJITTestBase.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 "gtest/gtest.h"
using namespace llvm;
namespace {
class TestObjectCache : public ObjectCache {
public:
TestObjectCache() : DuplicateInserted(false) { }
virtual ~TestObjectCache() {
SmallVectorImpl<MemoryBuffer *>::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) {
const std::string ModuleID = M->getModuleIdentifier();
if (ObjMap.find(ModuleID) != ObjMap.end())
DuplicateInserted = true;
ObjMap[ModuleID] = copyBuffer(Obj);
}
virtual MemoryBuffer* getObject(const Module* M) {
const MemoryBuffer* BufferFound = getObjectInternal(M);
ModulesLookedUp.insert(M->getModuleIdentifier());
if (!BufferFound)
return NULL;
return MemoryBuffer::getMemBufferCopy(BufferFound->getBuffer());
}
bool wereDuplicatesInserted() { return DuplicateInserted; }
bool wasModuleLookedUp(const Module *M) {
return ModulesLookedUp.find(M->getModuleIdentifier())
!= ModulesLookedUp.end();
}
const MemoryBuffer* getObjectInternal(const Module* M) {
const std::string ModuleID = M->getModuleIdentifier();
StringMap<const MemoryBuffer *>::iterator it = ObjMap.find(ModuleID);
if (it == ObjMap.end())
return 0;
return it->second;
}
private:
MemoryBuffer *copyBuffer(const MemoryBuffer *Buf) {
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) {
ASSERT_TRUE(TheJIT.isValid());
ASSERT_TRUE(0 != Main);
TheJIT->finalizeObject();
void *vPtr = TheJIT->getPointerToFunction(Main);
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);
const Module * SavedModulePointer = M.get();
createJIT(M.take());
TheJIT->setObjectCache(Cache.get());
const MemoryBuffer *ObjBuffer = Cache->getObjectInternal(SavedModulePointer);
EXPECT_EQ(0, ObjBuffer);
compileAndRun();
EXPECT_TRUE(Cache->wasModuleLookedUp(SavedModulePointer));
ObjBuffer = Cache->getObjectInternal(SavedModulePointer);
EXPECT_TRUE(0 != ObjBuffer);
EXPECT_FALSE(Cache->wereDuplicatesInserted());
}
TEST_F(MCJITObjectCacheTest, VerifyLoadFromCache) {
SKIP_UNSUPPORTED_PLATFORM;
OwningPtr<TestObjectCache> Cache(new TestObjectCache);
createJIT(M.take());
TheJIT->setObjectCache(Cache.get());
TheJIT->finalizeObject();
TheJIT.reset();
MM = new SectionMemoryManager;
M.reset(createEmptyModule("<main>"));
Main = insertMainFunction(M.get(), ReplacementRC);
const Module * SecondModulePointer = M.get();
createJIT(M.take());
TheJIT->setObjectCache(Cache.get());
compileAndRun();
EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
EXPECT_FALSE(Cache->wereDuplicatesInserted());
}
TEST_F(MCJITObjectCacheTest, VerifyNonLoadFromCache) {
SKIP_UNSUPPORTED_PLATFORM;
OwningPtr<TestObjectCache> Cache(new TestObjectCache);
createJIT(M.take());
TheJIT->setObjectCache(Cache.get());
TheJIT->finalizeObject();
TheJIT.reset();
MM = new SectionMemoryManager;
M.reset(createEmptyModule("<not-main>"));
Main = insertMainFunction(M.get(), ReplacementRC);
const Module * SecondModulePointer = M.get();
createJIT(M.take());
TheJIT->setObjectCache(Cache.get());
const MemoryBuffer *ObjBuffer = Cache->getObjectInternal(SecondModulePointer);
EXPECT_EQ(0, ObjBuffer);
compileAndRun(ReplacementRC);
EXPECT_TRUE(Cache->wasModuleLookedUp(SecondModulePointer));
ObjBuffer = Cache->getObjectInternal(SecondModulePointer);
EXPECT_TRUE(0 != ObjBuffer);
EXPECT_FALSE(Cache->wereDuplicatesInserted());
}
}