diff options
Diffstat (limited to 'contrib/llvm/unittests/ExecutionEngine')
7 files changed, 0 insertions, 1652 deletions
diff --git a/contrib/llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp b/contrib/llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp deleted file mode 100644 index 904ee2b..0000000 --- a/contrib/llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp +++ /dev/null @@ -1,129 +0,0 @@ -//===- ExecutionEngineTest.cpp - Unit tests for ExecutionEngine -----------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "llvm/DerivedTypes.h" -#include "llvm/GlobalVariable.h" -#include "llvm/LLVMContext.h" -#include "llvm/Module.h" -#include "llvm/ADT/OwningPtr.h" -#include "llvm/ExecutionEngine/Interpreter.h" -#include "gtest/gtest.h" - -using namespace llvm; - -namespace { - -class ExecutionEngineTest : public testing::Test { -protected: - ExecutionEngineTest() - : M(new Module("<main>", getGlobalContext())), - Engine(EngineBuilder(M).create()) { - } - - virtual void SetUp() { - ASSERT_TRUE(Engine.get() != NULL); - } - - GlobalVariable *NewExtGlobal(const Type *T, const Twine &Name) { - return new GlobalVariable(*M, T, false, // Not constant. - GlobalValue::ExternalLinkage, NULL, Name); - } - - Module *const M; - const OwningPtr<ExecutionEngine> Engine; -}; - -TEST_F(ExecutionEngineTest, ForwardGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); - int32_t Mem1 = 3; - Engine->addGlobalMapping(G1, &Mem1); - EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G1)); - int32_t Mem2 = 4; - Engine->updateGlobalMapping(G1, &Mem2); - EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1)); - Engine->updateGlobalMapping(G1, NULL); - EXPECT_EQ(NULL, Engine->getPointerToGlobalIfAvailable(G1)); - Engine->updateGlobalMapping(G1, &Mem2); - EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1)); - - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); - EXPECT_EQ(NULL, Engine->getPointerToGlobalIfAvailable(G2)) - << "The NULL return shouldn't depend on having called" - << " updateGlobalMapping(..., NULL)"; - // Check that update...() can be called before add...(). - Engine->updateGlobalMapping(G2, &Mem1); - EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G2)); - EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1)) - << "A second mapping shouldn't affect the first."; -} - -TEST_F(ExecutionEngineTest, ReverseGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); - - int32_t Mem1 = 3; - Engine->addGlobalMapping(G1, &Mem1); - EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1)); - int32_t Mem2 = 4; - Engine->updateGlobalMapping(G1, &Mem2); - EXPECT_EQ(NULL, Engine->getGlobalValueAtAddress(&Mem1)); - EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2)); - - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2"); - Engine->updateGlobalMapping(G2, &Mem1); - EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1)); - EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2)); - Engine->updateGlobalMapping(G1, NULL); - EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1)) - << "Removing one mapping doesn't affect a different one."; - EXPECT_EQ(NULL, Engine->getGlobalValueAtAddress(&Mem2)); - Engine->updateGlobalMapping(G2, &Mem2); - EXPECT_EQ(NULL, Engine->getGlobalValueAtAddress(&Mem1)); - EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem2)) - << "Once a mapping is removed, we can point another GV at the" - << " now-free address."; -} - -TEST_F(ExecutionEngineTest, ClearModuleMappings) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); - - int32_t Mem1 = 3; - Engine->addGlobalMapping(G1, &Mem1); - EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1)); - - Engine->clearGlobalMappingsFromModule(M); - - EXPECT_EQ(NULL, Engine->getGlobalValueAtAddress(&Mem1)); - - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2"); - // After clearing the module mappings, we can assign a new GV to the - // same address. - Engine->addGlobalMapping(G2, &Mem1); - EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1)); -} - -TEST_F(ExecutionEngineTest, DestructionRemovesGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); - int32_t Mem1 = 3; - Engine->addGlobalMapping(G1, &Mem1); - // Make sure the reverse mapping is enabled. - EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1)); - // When the GV goes away, the ExecutionEngine should remove any - // mappings that refer to it. - G1->eraseFromParent(); - EXPECT_EQ(NULL, Engine->getGlobalValueAtAddress(&Mem1)); -} - -} diff --git a/contrib/llvm/unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp b/contrib/llvm/unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp deleted file mode 100644 index a36ec3b..0000000 --- a/contrib/llvm/unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp +++ /dev/null @@ -1,238 +0,0 @@ -//===- JITEventListenerTest.cpp - Unit tests for JITEventListeners --------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "llvm/ExecutionEngine/JITEventListener.h" - -#include "llvm/LLVMContext.h" -#include "llvm/Instructions.h" -#include "llvm/Module.h" -#include "llvm/ADT/OwningPtr.h" -#include "llvm/CodeGen/MachineCodeInfo.h" -#include "llvm/ExecutionEngine/JIT.h" -#include "llvm/Support/TypeBuilder.h" -#include "llvm/Target/TargetSelect.h" -#include "gtest/gtest.h" -#include <vector> - -using namespace llvm; - -int dummy; - -namespace { - -struct FunctionEmittedEvent { - // Indices are local to the RecordingJITEventListener, since the - // JITEventListener interface makes no guarantees about the order of - // calls between Listeners. - unsigned Index; - const Function *F; - void *Code; - size_t Size; - JITEvent_EmittedFunctionDetails Details; -}; -struct FunctionFreedEvent { - unsigned Index; - void *Code; -}; - -struct RecordingJITEventListener : public JITEventListener { - std::vector<FunctionEmittedEvent> EmittedEvents; - std::vector<FunctionFreedEvent> FreedEvents; - - int NextIndex; - - RecordingJITEventListener() : NextIndex(0) {} - - virtual void NotifyFunctionEmitted(const Function &F, - void *Code, size_t Size, - const EmittedFunctionDetails &Details) { - FunctionEmittedEvent Event = {NextIndex++, &F, Code, Size, Details}; - EmittedEvents.push_back(Event); - } - - virtual void NotifyFreeingMachineCode(void *OldPtr) { - FunctionFreedEvent Event = {NextIndex++, OldPtr}; - FreedEvents.push_back(Event); - } -}; - -class JITEventListenerTest : public testing::Test { - protected: - JITEventListenerTest() - : M(new Module("module", getGlobalContext())), - EE(EngineBuilder(M) - .setEngineKind(EngineKind::JIT) - .create()) { - } - - Module *M; - const OwningPtr<ExecutionEngine> EE; -}; - -Function *buildFunction(Module *M) { - Function *Result = Function::Create( - TypeBuilder<int32_t(int32_t), false>::get(getGlobalContext()), - GlobalValue::ExternalLinkage, "id", M); - Value *Arg = Result->arg_begin(); - BasicBlock *BB = BasicBlock::Create(M->getContext(), "entry", Result); - ReturnInst::Create(M->getContext(), Arg, BB); - return Result; -} - -// Tests that a single JITEventListener follows JIT events accurately. -TEST_F(JITEventListenerTest, Simple) { - RecordingJITEventListener Listener; - EE->RegisterJITEventListener(&Listener); - Function *F1 = buildFunction(M); - Function *F2 = buildFunction(M); - - void *F1_addr = EE->getPointerToFunction(F1); - void *F2_addr = EE->getPointerToFunction(F2); - EE->getPointerToFunction(F1); // Should do nothing. - EE->freeMachineCodeForFunction(F1); - EE->freeMachineCodeForFunction(F2); - - ASSERT_EQ(2U, Listener.EmittedEvents.size()); - ASSERT_EQ(2U, Listener.FreedEvents.size()); - - EXPECT_EQ(0U, Listener.EmittedEvents[0].Index); - EXPECT_EQ(F1, Listener.EmittedEvents[0].F); - EXPECT_EQ(F1_addr, Listener.EmittedEvents[0].Code); - EXPECT_LT(0U, Listener.EmittedEvents[0].Size) - << "We don't know how big the function will be, but it had better" - << " contain some bytes."; - - EXPECT_EQ(1U, Listener.EmittedEvents[1].Index); - EXPECT_EQ(F2, Listener.EmittedEvents[1].F); - EXPECT_EQ(F2_addr, Listener.EmittedEvents[1].Code); - EXPECT_LT(0U, Listener.EmittedEvents[1].Size) - << "We don't know how big the function will be, but it had better" - << " contain some bytes."; - - EXPECT_EQ(2U, Listener.FreedEvents[0].Index); - EXPECT_EQ(F1_addr, Listener.FreedEvents[0].Code); - - EXPECT_EQ(3U, Listener.FreedEvents[1].Index); - EXPECT_EQ(F2_addr, Listener.FreedEvents[1].Code); - - F1->eraseFromParent(); - F2->eraseFromParent(); -} - -// Tests that a single JITEventListener follows JIT events accurately. -TEST_F(JITEventListenerTest, MultipleListenersDontInterfere) { - RecordingJITEventListener Listener1; - RecordingJITEventListener Listener2; - RecordingJITEventListener Listener3; - Function *F1 = buildFunction(M); - Function *F2 = buildFunction(M); - - EE->RegisterJITEventListener(&Listener1); - EE->RegisterJITEventListener(&Listener2); - void *F1_addr = EE->getPointerToFunction(F1); - EE->RegisterJITEventListener(&Listener3); - EE->UnregisterJITEventListener(&Listener1); - void *F2_addr = EE->getPointerToFunction(F2); - EE->UnregisterJITEventListener(&Listener2); - EE->UnregisterJITEventListener(&Listener3); - EE->freeMachineCodeForFunction(F1); - EE->RegisterJITEventListener(&Listener2); - EE->RegisterJITEventListener(&Listener3); - EE->RegisterJITEventListener(&Listener1); - EE->freeMachineCodeForFunction(F2); - EE->UnregisterJITEventListener(&Listener1); - EE->UnregisterJITEventListener(&Listener2); - EE->UnregisterJITEventListener(&Listener3); - - // Listener 1. - ASSERT_EQ(1U, Listener1.EmittedEvents.size()); - ASSERT_EQ(1U, Listener1.FreedEvents.size()); - - EXPECT_EQ(0U, Listener1.EmittedEvents[0].Index); - EXPECT_EQ(F1, Listener1.EmittedEvents[0].F); - EXPECT_EQ(F1_addr, Listener1.EmittedEvents[0].Code); - EXPECT_LT(0U, Listener1.EmittedEvents[0].Size) - << "We don't know how big the function will be, but it had better" - << " contain some bytes."; - - EXPECT_EQ(1U, Listener1.FreedEvents[0].Index); - EXPECT_EQ(F2_addr, Listener1.FreedEvents[0].Code); - - // Listener 2. - ASSERT_EQ(2U, Listener2.EmittedEvents.size()); - ASSERT_EQ(1U, Listener2.FreedEvents.size()); - - EXPECT_EQ(0U, Listener2.EmittedEvents[0].Index); - EXPECT_EQ(F1, Listener2.EmittedEvents[0].F); - EXPECT_EQ(F1_addr, Listener2.EmittedEvents[0].Code); - EXPECT_LT(0U, Listener2.EmittedEvents[0].Size) - << "We don't know how big the function will be, but it had better" - << " contain some bytes."; - - EXPECT_EQ(1U, Listener2.EmittedEvents[1].Index); - EXPECT_EQ(F2, Listener2.EmittedEvents[1].F); - EXPECT_EQ(F2_addr, Listener2.EmittedEvents[1].Code); - EXPECT_LT(0U, Listener2.EmittedEvents[1].Size) - << "We don't know how big the function will be, but it had better" - << " contain some bytes."; - - EXPECT_EQ(2U, Listener2.FreedEvents[0].Index); - EXPECT_EQ(F2_addr, Listener2.FreedEvents[0].Code); - - // Listener 3. - ASSERT_EQ(1U, Listener3.EmittedEvents.size()); - ASSERT_EQ(1U, Listener3.FreedEvents.size()); - - EXPECT_EQ(0U, Listener3.EmittedEvents[0].Index); - EXPECT_EQ(F2, Listener3.EmittedEvents[0].F); - EXPECT_EQ(F2_addr, Listener3.EmittedEvents[0].Code); - EXPECT_LT(0U, Listener3.EmittedEvents[0].Size) - << "We don't know how big the function will be, but it had better" - << " contain some bytes."; - - EXPECT_EQ(1U, Listener3.FreedEvents[0].Index); - EXPECT_EQ(F2_addr, Listener3.FreedEvents[0].Code); - - F1->eraseFromParent(); - F2->eraseFromParent(); -} - -TEST_F(JITEventListenerTest, MatchesMachineCodeInfo) { - RecordingJITEventListener Listener; - MachineCodeInfo MCI; - Function *F = buildFunction(M); - - EE->RegisterJITEventListener(&Listener); - EE->runJITOnFunction(F, &MCI); - void *F_addr = EE->getPointerToFunction(F); - EE->freeMachineCodeForFunction(F); - - ASSERT_EQ(1U, Listener.EmittedEvents.size()); - ASSERT_EQ(1U, Listener.FreedEvents.size()); - - EXPECT_EQ(0U, Listener.EmittedEvents[0].Index); - EXPECT_EQ(F, Listener.EmittedEvents[0].F); - EXPECT_EQ(F_addr, Listener.EmittedEvents[0].Code); - EXPECT_EQ(MCI.address(), Listener.EmittedEvents[0].Code); - EXPECT_EQ(MCI.size(), Listener.EmittedEvents[0].Size); - - EXPECT_EQ(1U, Listener.FreedEvents[0].Index); - EXPECT_EQ(F_addr, Listener.FreedEvents[0].Code); -} - -class JITEnvironment : public testing::Environment { - virtual void SetUp() { - // Required to create a JIT. - InitializeNativeTarget(); - } -}; -testing::Environment* const jit_env = - testing::AddGlobalTestEnvironment(new JITEnvironment); - -} // anonymous namespace diff --git a/contrib/llvm/unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp b/contrib/llvm/unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp deleted file mode 100644 index ff5af3b..0000000 --- a/contrib/llvm/unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp +++ /dev/null @@ -1,279 +0,0 @@ -//===- JITMemoryManagerTest.cpp - Unit tests for the JIT memory manager ---===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "gtest/gtest.h" -#include "llvm/ADT/OwningPtr.h" -#include "llvm/ExecutionEngine/JITMemoryManager.h" -#include "llvm/DerivedTypes.h" -#include "llvm/Function.h" -#include "llvm/GlobalValue.h" -#include "llvm/LLVMContext.h" - -using namespace llvm; - -namespace { - -Function *makeFakeFunction() { - std::vector<const Type*> params; - const FunctionType *FTy = - FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false); - return Function::Create(FTy, GlobalValue::ExternalLinkage); -} - -// Allocate three simple functions that fit in the initial slab. This exercises -// the code in the case that we don't have to allocate more memory to store the -// function bodies. -TEST(JITMemoryManagerTest, NoAllocations) { - OwningPtr<JITMemoryManager> MemMgr( - JITMemoryManager::CreateDefaultMemManager()); - uintptr_t size; - std::string Error; - - // Allocate the functions. - OwningPtr<Function> F1(makeFakeFunction()); - size = 1024; - uint8_t *FunctionBody1 = MemMgr->startFunctionBody(F1.get(), size); - memset(FunctionBody1, 0xFF, 1024); - MemMgr->endFunctionBody(F1.get(), FunctionBody1, FunctionBody1 + 1024); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - OwningPtr<Function> F2(makeFakeFunction()); - size = 1024; - uint8_t *FunctionBody2 = MemMgr->startFunctionBody(F2.get(), size); - memset(FunctionBody2, 0xFF, 1024); - MemMgr->endFunctionBody(F2.get(), FunctionBody2, FunctionBody2 + 1024); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - OwningPtr<Function> F3(makeFakeFunction()); - size = 1024; - uint8_t *FunctionBody3 = MemMgr->startFunctionBody(F3.get(), size); - memset(FunctionBody3, 0xFF, 1024); - MemMgr->endFunctionBody(F3.get(), FunctionBody3, FunctionBody3 + 1024); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - // Deallocate them out of order, in case that matters. - MemMgr->deallocateFunctionBody(FunctionBody2); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - MemMgr->deallocateFunctionBody(FunctionBody1); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - MemMgr->deallocateFunctionBody(FunctionBody3); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; -} - -// Make three large functions that take up most of the space in the slab. Then -// try allocating three smaller functions that don't require additional slabs. -TEST(JITMemoryManagerTest, TestCodeAllocation) { - OwningPtr<JITMemoryManager> MemMgr( - JITMemoryManager::CreateDefaultMemManager()); - uintptr_t size; - std::string Error; - - // Big functions are a little less than the largest block size. - const uintptr_t smallFuncSize = 1024; - const uintptr_t bigFuncSize = (MemMgr->GetDefaultCodeSlabSize() - - smallFuncSize * 2); - - // Allocate big functions - OwningPtr<Function> F1(makeFakeFunction()); - size = bigFuncSize; - uint8_t *FunctionBody1 = MemMgr->startFunctionBody(F1.get(), size); - ASSERT_LE(bigFuncSize, size); - memset(FunctionBody1, 0xFF, bigFuncSize); - MemMgr->endFunctionBody(F1.get(), FunctionBody1, FunctionBody1 + bigFuncSize); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - OwningPtr<Function> F2(makeFakeFunction()); - size = bigFuncSize; - uint8_t *FunctionBody2 = MemMgr->startFunctionBody(F2.get(), size); - ASSERT_LE(bigFuncSize, size); - memset(FunctionBody2, 0xFF, bigFuncSize); - MemMgr->endFunctionBody(F2.get(), FunctionBody2, FunctionBody2 + bigFuncSize); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - OwningPtr<Function> F3(makeFakeFunction()); - size = bigFuncSize; - uint8_t *FunctionBody3 = MemMgr->startFunctionBody(F3.get(), size); - ASSERT_LE(bigFuncSize, size); - memset(FunctionBody3, 0xFF, bigFuncSize); - MemMgr->endFunctionBody(F3.get(), FunctionBody3, FunctionBody3 + bigFuncSize); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - // Check that each large function took it's own slab. - EXPECT_EQ(3U, MemMgr->GetNumCodeSlabs()); - - // Allocate small functions - OwningPtr<Function> F4(makeFakeFunction()); - size = smallFuncSize; - uint8_t *FunctionBody4 = MemMgr->startFunctionBody(F4.get(), size); - ASSERT_LE(smallFuncSize, size); - memset(FunctionBody4, 0xFF, smallFuncSize); - MemMgr->endFunctionBody(F4.get(), FunctionBody4, - FunctionBody4 + smallFuncSize); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - OwningPtr<Function> F5(makeFakeFunction()); - size = smallFuncSize; - uint8_t *FunctionBody5 = MemMgr->startFunctionBody(F5.get(), size); - ASSERT_LE(smallFuncSize, size); - memset(FunctionBody5, 0xFF, smallFuncSize); - MemMgr->endFunctionBody(F5.get(), FunctionBody5, - FunctionBody5 + smallFuncSize); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - OwningPtr<Function> F6(makeFakeFunction()); - size = smallFuncSize; - uint8_t *FunctionBody6 = MemMgr->startFunctionBody(F6.get(), size); - ASSERT_LE(smallFuncSize, size); - memset(FunctionBody6, 0xFF, smallFuncSize); - MemMgr->endFunctionBody(F6.get(), FunctionBody6, - FunctionBody6 + smallFuncSize); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - - // Check that the small functions didn't allocate any new slabs. - EXPECT_EQ(3U, MemMgr->GetNumCodeSlabs()); - - // Deallocate them out of order, in case that matters. - MemMgr->deallocateFunctionBody(FunctionBody2); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - MemMgr->deallocateFunctionBody(FunctionBody1); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - MemMgr->deallocateFunctionBody(FunctionBody4); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - MemMgr->deallocateFunctionBody(FunctionBody3); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - MemMgr->deallocateFunctionBody(FunctionBody5); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; - MemMgr->deallocateFunctionBody(FunctionBody6); - EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error; -} - -// Allocate five global ints of varying widths and alignment, and check their -// alignment and overlap. -TEST(JITMemoryManagerTest, TestSmallGlobalInts) { - OwningPtr<JITMemoryManager> MemMgr( - JITMemoryManager::CreateDefaultMemManager()); - uint8_t *a = (uint8_t *)MemMgr->allocateGlobal(8, 0); - uint16_t *b = (uint16_t*)MemMgr->allocateGlobal(16, 2); - uint32_t *c = (uint32_t*)MemMgr->allocateGlobal(32, 4); - uint64_t *d = (uint64_t*)MemMgr->allocateGlobal(64, 8); - - // Check the alignment. - EXPECT_EQ(0U, ((uintptr_t)b) & 0x1); - EXPECT_EQ(0U, ((uintptr_t)c) & 0x3); - EXPECT_EQ(0U, ((uintptr_t)d) & 0x7); - - // Initialize them each one at a time and make sure they don't overlap. - *a = 0xff; - *b = 0U; - *c = 0U; - *d = 0U; - EXPECT_EQ(0xffU, *a); - EXPECT_EQ(0U, *b); - EXPECT_EQ(0U, *c); - EXPECT_EQ(0U, *d); - *a = 0U; - *b = 0xffffU; - EXPECT_EQ(0U, *a); - EXPECT_EQ(0xffffU, *b); - EXPECT_EQ(0U, *c); - EXPECT_EQ(0U, *d); - *b = 0U; - *c = 0xffffffffU; - EXPECT_EQ(0U, *a); - EXPECT_EQ(0U, *b); - EXPECT_EQ(0xffffffffU, *c); - EXPECT_EQ(0U, *d); - *c = 0U; - *d = 0xffffffffffffffffULL; - EXPECT_EQ(0U, *a); - EXPECT_EQ(0U, *b); - EXPECT_EQ(0U, *c); - EXPECT_EQ(0xffffffffffffffffULL, *d); - - // Make sure we didn't allocate any extra slabs for this tiny amount of data. - EXPECT_EQ(1U, MemMgr->GetNumDataSlabs()); -} - -// Allocate a small global, a big global, and a third global, and make sure we -// only use two slabs for that. -TEST(JITMemoryManagerTest, TestLargeGlobalArray) { - OwningPtr<JITMemoryManager> MemMgr( - JITMemoryManager::CreateDefaultMemManager()); - size_t Size = 4 * MemMgr->GetDefaultDataSlabSize(); - uint64_t *a = (uint64_t*)MemMgr->allocateGlobal(64, 8); - uint8_t *g = MemMgr->allocateGlobal(Size, 8); - uint64_t *b = (uint64_t*)MemMgr->allocateGlobal(64, 8); - - // Check the alignment. - EXPECT_EQ(0U, ((uintptr_t)a) & 0x7); - EXPECT_EQ(0U, ((uintptr_t)g) & 0x7); - EXPECT_EQ(0U, ((uintptr_t)b) & 0x7); - - // Initialize them to make sure we don't segfault and make sure they don't - // overlap. - memset(a, 0x1, 8); - memset(g, 0x2, Size); - memset(b, 0x3, 8); - EXPECT_EQ(0x0101010101010101ULL, *a); - // Just check the edges. - EXPECT_EQ(0x02U, g[0]); - EXPECT_EQ(0x02U, g[Size - 1]); - EXPECT_EQ(0x0303030303030303ULL, *b); - - // Check the number of slabs. - EXPECT_EQ(2U, MemMgr->GetNumDataSlabs()); -} - -// Allocate lots of medium globals so that we can test moving the bump allocator -// to a new slab. -TEST(JITMemoryManagerTest, TestManyGlobals) { - OwningPtr<JITMemoryManager> MemMgr( - JITMemoryManager::CreateDefaultMemManager()); - size_t SlabSize = MemMgr->GetDefaultDataSlabSize(); - size_t Size = 128; - int Iters = (SlabSize / Size) + 1; - - // We should start with no slabs. - EXPECT_EQ(0U, MemMgr->GetNumDataSlabs()); - - // After allocating a bunch of globals, we should have two. - for (int I = 0; I < Iters; ++I) - MemMgr->allocateGlobal(Size, 8); - EXPECT_EQ(2U, MemMgr->GetNumDataSlabs()); - - // And after much more, we should have three. - for (int I = 0; I < Iters; ++I) - MemMgr->allocateGlobal(Size, 8); - EXPECT_EQ(3U, MemMgr->GetNumDataSlabs()); -} - -// Allocate lots of function stubs so that we can test moving the stub bump -// allocator to a new slab. -TEST(JITMemoryManagerTest, TestManyStubs) { - OwningPtr<JITMemoryManager> MemMgr( - JITMemoryManager::CreateDefaultMemManager()); - size_t SlabSize = MemMgr->GetDefaultStubSlabSize(); - size_t Size = 128; - int Iters = (SlabSize / Size) + 1; - - // We should start with no slabs. - EXPECT_EQ(0U, MemMgr->GetNumDataSlabs()); - - // After allocating a bunch of stubs, we should have two. - for (int I = 0; I < Iters; ++I) - MemMgr->allocateStub(NULL, Size, 8); - EXPECT_EQ(2U, MemMgr->GetNumStubSlabs()); - - // And after much more, we should have three. - for (int I = 0; I < Iters; ++I) - MemMgr->allocateStub(NULL, Size, 8); - EXPECT_EQ(3U, MemMgr->GetNumStubSlabs()); -} - -} diff --git a/contrib/llvm/unittests/ExecutionEngine/JIT/JITTest.cpp b/contrib/llvm/unittests/ExecutionEngine/JIT/JITTest.cpp deleted file mode 100644 index 8f0582d..0000000 --- a/contrib/llvm/unittests/ExecutionEngine/JIT/JITTest.cpp +++ /dev/null @@ -1,806 +0,0 @@ -//===- JITTest.cpp - Unit tests for the JIT -------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "gtest/gtest.h" -#include "llvm/ADT/OwningPtr.h" -#include "llvm/ADT/SmallPtrSet.h" -#include "llvm/Assembly/Parser.h" -#include "llvm/BasicBlock.h" -#include "llvm/Bitcode/ReaderWriter.h" -#include "llvm/Constant.h" -#include "llvm/Constants.h" -#include "llvm/DerivedTypes.h" -#include "llvm/ExecutionEngine/JIT.h" -#include "llvm/ExecutionEngine/JITMemoryManager.h" -#include "llvm/Function.h" -#include "llvm/GlobalValue.h" -#include "llvm/GlobalVariable.h" -#include "llvm/LLVMContext.h" -#include "llvm/Module.h" -#include "llvm/Support/IRBuilder.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/SourceMgr.h" -#include "llvm/Support/TypeBuilder.h" -#include "llvm/Target/TargetSelect.h" -#include "llvm/Type.h" - -#include <vector> - -using namespace llvm; - -namespace { - -Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) { - std::vector<const Type*> params; - const FunctionType *FTy = FunctionType::get(G->getType()->getElementType(), - params, false); - Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M); - BasicBlock *Entry = BasicBlock::Create(M->getContext(), "entry", F); - IRBuilder<> builder(Entry); - Value *Load = builder.CreateLoad(G); - const Type *GTy = G->getType()->getElementType(); - Value *Add = builder.CreateAdd(Load, ConstantInt::get(GTy, 1LL)); - builder.CreateStore(Add, G); - builder.CreateRet(Add); - return F; -} - -std::string DumpFunction(const Function *F) { - std::string Result; - raw_string_ostream(Result) << "" << *F; - return Result; -} - -class RecordingJITMemoryManager : public JITMemoryManager { - const OwningPtr<JITMemoryManager> Base; -public: - RecordingJITMemoryManager() - : Base(JITMemoryManager::CreateDefaultMemManager()) { - stubsAllocated = 0; - } - - void setSizeRequired(bool Required) { SizeRequired = Required; } - - virtual void setMemoryWritable() { Base->setMemoryWritable(); } - virtual void setMemoryExecutable() { Base->setMemoryExecutable(); } - virtual void setPoisonMemory(bool poison) { Base->setPoisonMemory(poison); } - virtual void AllocateGOT() { Base->AllocateGOT(); } - virtual uint8_t *getGOTBase() const { return Base->getGOTBase(); } - struct StartFunctionBodyCall { - StartFunctionBodyCall(uint8_t *Result, const Function *F, - uintptr_t ActualSize, uintptr_t ActualSizeResult) - : Result(Result), F(F), F_dump(DumpFunction(F)), - ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {} - uint8_t *Result; - const Function *F; - std::string F_dump; - uintptr_t ActualSize; - uintptr_t ActualSizeResult; - }; - std::vector<StartFunctionBodyCall> startFunctionBodyCalls; - virtual uint8_t *startFunctionBody(const Function *F, - uintptr_t &ActualSize) { - uintptr_t InitialActualSize = ActualSize; - uint8_t *Result = Base->startFunctionBody(F, ActualSize); - startFunctionBodyCalls.push_back( - StartFunctionBodyCall(Result, F, InitialActualSize, ActualSize)); - return Result; - } - int stubsAllocated; - virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize, - unsigned Alignment) { - stubsAllocated++; - return Base->allocateStub(F, StubSize, Alignment); - } - struct EndFunctionBodyCall { - EndFunctionBodyCall(const Function *F, uint8_t *FunctionStart, - uint8_t *FunctionEnd) - : F(F), F_dump(DumpFunction(F)), - FunctionStart(FunctionStart), FunctionEnd(FunctionEnd) {} - const Function *F; - std::string F_dump; - uint8_t *FunctionStart; - uint8_t *FunctionEnd; - }; - std::vector<EndFunctionBodyCall> endFunctionBodyCalls; - virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart, - uint8_t *FunctionEnd) { - endFunctionBodyCalls.push_back( - EndFunctionBodyCall(F, FunctionStart, FunctionEnd)); - Base->endFunctionBody(F, FunctionStart, FunctionEnd); - } - virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) { - return Base->allocateSpace(Size, Alignment); - } - virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) { - return Base->allocateGlobal(Size, Alignment); - } - struct DeallocateFunctionBodyCall { - DeallocateFunctionBodyCall(const void *Body) : Body(Body) {} - const void *Body; - }; - std::vector<DeallocateFunctionBodyCall> deallocateFunctionBodyCalls; - virtual void deallocateFunctionBody(void *Body) { - deallocateFunctionBodyCalls.push_back(DeallocateFunctionBodyCall(Body)); - Base->deallocateFunctionBody(Body); - } - struct DeallocateExceptionTableCall { - DeallocateExceptionTableCall(const void *ET) : ET(ET) {} - const void *ET; - }; - std::vector<DeallocateExceptionTableCall> deallocateExceptionTableCalls; - virtual void deallocateExceptionTable(void *ET) { - deallocateExceptionTableCalls.push_back(DeallocateExceptionTableCall(ET)); - Base->deallocateExceptionTable(ET); - } - struct StartExceptionTableCall { - StartExceptionTableCall(uint8_t *Result, const Function *F, - uintptr_t ActualSize, uintptr_t ActualSizeResult) - : Result(Result), F(F), F_dump(DumpFunction(F)), - ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {} - uint8_t *Result; - const Function *F; - std::string F_dump; - uintptr_t ActualSize; - uintptr_t ActualSizeResult; - }; - std::vector<StartExceptionTableCall> startExceptionTableCalls; - virtual uint8_t* startExceptionTable(const Function* F, - uintptr_t &ActualSize) { - uintptr_t InitialActualSize = ActualSize; - uint8_t *Result = Base->startExceptionTable(F, ActualSize); - startExceptionTableCalls.push_back( - StartExceptionTableCall(Result, F, InitialActualSize, ActualSize)); - return Result; - } - struct EndExceptionTableCall { - EndExceptionTableCall(const Function *F, uint8_t *TableStart, - uint8_t *TableEnd, uint8_t* FrameRegister) - : F(F), F_dump(DumpFunction(F)), - TableStart(TableStart), TableEnd(TableEnd), - FrameRegister(FrameRegister) {} - const Function *F; - std::string F_dump; - uint8_t *TableStart; - uint8_t *TableEnd; - uint8_t *FrameRegister; - }; - std::vector<EndExceptionTableCall> endExceptionTableCalls; - virtual void endExceptionTable(const Function *F, uint8_t *TableStart, - uint8_t *TableEnd, uint8_t* FrameRegister) { - endExceptionTableCalls.push_back( - EndExceptionTableCall(F, TableStart, TableEnd, FrameRegister)); - return Base->endExceptionTable(F, TableStart, TableEnd, FrameRegister); - } -}; - -bool LoadAssemblyInto(Module *M, const char *assembly) { - SMDiagnostic Error; - bool success = - NULL != ParseAssemblyString(assembly, M, Error, M->getContext()); - std::string errMsg; - raw_string_ostream os(errMsg); - Error.Print("", os); - EXPECT_TRUE(success) << os.str(); - return success; -} - -class JITTest : public testing::Test { - protected: - virtual void SetUp() { - M = new Module("<main>", Context); - RJMM = new RecordingJITMemoryManager; - RJMM->setPoisonMemory(true); - std::string Error; - TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT) - .setJITMemoryManager(RJMM) - .setErrorStr(&Error).create()); - ASSERT_TRUE(TheJIT.get() != NULL) << Error; - } - - void LoadAssembly(const char *assembly) { - LoadAssemblyInto(M, assembly); - } - - LLVMContext Context; - Module *M; // Owned by ExecutionEngine. - RecordingJITMemoryManager *RJMM; - OwningPtr<ExecutionEngine> TheJIT; -}; - -// Regression test for a bug. The JIT used to allocate globals inside the same -// memory block used for the function, and when the function code was freed, -// the global was left in the same place. This test allocates a function -// that uses and global, deallocates it, and then makes sure that the global -// stays alive after that. -TEST(JIT, GlobalInFunction) { - LLVMContext context; - Module *M = new Module("<main>", context); - - JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager(); - // Tell the memory manager to poison freed memory so that accessing freed - // memory is more easily tested. - MemMgr->setPoisonMemory(true); - std::string Error; - OwningPtr<ExecutionEngine> JIT(EngineBuilder(M) - .setEngineKind(EngineKind::JIT) - .setErrorStr(&Error) - .setJITMemoryManager(MemMgr) - // The next line enables the fix: - .setAllocateGVsWithCode(false) - .create()); - ASSERT_EQ(Error, ""); - - // Create a global variable. - const Type *GTy = Type::getInt32Ty(context); - GlobalVariable *G = new GlobalVariable( - *M, - GTy, - false, // Not constant. - GlobalValue::InternalLinkage, - Constant::getNullValue(GTy), - "myglobal"); - - // Make a function that points to a global. - Function *F1 = makeReturnGlobal("F1", G, M); - - // Get the pointer to the native code to force it to JIT the function and - // allocate space for the global. - void (*F1Ptr)() = - reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F1)); - - // Since F1 was codegen'd, a pointer to G should be available. - int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G); - ASSERT_NE((int32_t*)NULL, GPtr); - EXPECT_EQ(0, *GPtr); - - // F1() should increment G. - F1Ptr(); - EXPECT_EQ(1, *GPtr); - - // Make a second function identical to the first, referring to the same - // global. - Function *F2 = makeReturnGlobal("F2", G, M); - void (*F2Ptr)() = - reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F2)); - - // F2() should increment G. - F2Ptr(); - EXPECT_EQ(2, *GPtr); - - // Deallocate F1. - JIT->freeMachineCodeForFunction(F1); - - // F2() should *still* increment G. - F2Ptr(); - EXPECT_EQ(3, *GPtr); -} - -int PlusOne(int arg) { - return arg + 1; -} - -TEST_F(JITTest, FarCallToKnownFunction) { - // x86-64 can only make direct calls to functions within 32 bits of - // the current PC. To call anything farther away, we have to load - // the address into a register and call through the register. The - // current JIT does this by allocating a stub for any far call. - // There was a bug in which the JIT tried to emit a direct call when - // the target was already in the JIT's global mappings and lazy - // compilation was disabled. - - Function *KnownFunction = Function::Create( - TypeBuilder<int(int), false>::get(Context), - GlobalValue::ExternalLinkage, "known", M); - TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne); - - // int test() { return known(7); } - Function *TestFunction = Function::Create( - TypeBuilder<int(), false>::get(Context), - GlobalValue::ExternalLinkage, "test", M); - BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction); - IRBuilder<> Builder(Entry); - Value *result = Builder.CreateCall( - KnownFunction, - ConstantInt::get(TypeBuilder<int, false>::get(Context), 7)); - Builder.CreateRet(result); - - TheJIT->DisableLazyCompilation(true); - int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>( - (intptr_t)TheJIT->getPointerToFunction(TestFunction)); - // This used to crash in trying to call PlusOne(). - EXPECT_EQ(8, TestFunctionPtr()); -} - -// Test a function C which calls A and B which call each other. -TEST_F(JITTest, NonLazyCompilationStillNeedsStubs) { - TheJIT->DisableLazyCompilation(true); - - const FunctionType *Func1Ty = - cast<FunctionType>(TypeBuilder<void(void), false>::get(Context)); - std::vector<const Type*> arg_types; - arg_types.push_back(Type::getInt1Ty(Context)); - const FunctionType *FuncTy = FunctionType::get( - Type::getVoidTy(Context), arg_types, false); - Function *Func1 = Function::Create(Func1Ty, Function::ExternalLinkage, - "func1", M); - Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage, - "func2", M); - Function *Func3 = Function::Create(FuncTy, Function::InternalLinkage, - "func3", M); - BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1); - BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2); - BasicBlock *True2 = BasicBlock::Create(Context, "cond_true", Func2); - BasicBlock *False2 = BasicBlock::Create(Context, "cond_false", Func2); - BasicBlock *Block3 = BasicBlock::Create(Context, "block3", Func3); - BasicBlock *True3 = BasicBlock::Create(Context, "cond_true", Func3); - BasicBlock *False3 = BasicBlock::Create(Context, "cond_false", Func3); - - // Make Func1 call Func2(0) and Func3(0). - IRBuilder<> Builder(Block1); - Builder.CreateCall(Func2, ConstantInt::getTrue(Context)); - Builder.CreateCall(Func3, ConstantInt::getTrue(Context)); - Builder.CreateRetVoid(); - - // void Func2(bool b) { if (b) { Func3(false); return; } return; } - Builder.SetInsertPoint(Block2); - Builder.CreateCondBr(Func2->arg_begin(), True2, False2); - Builder.SetInsertPoint(True2); - Builder.CreateCall(Func3, ConstantInt::getFalse(Context)); - Builder.CreateRetVoid(); - Builder.SetInsertPoint(False2); - Builder.CreateRetVoid(); - - // void Func3(bool b) { if (b) { Func2(false); return; } return; } - Builder.SetInsertPoint(Block3); - Builder.CreateCondBr(Func3->arg_begin(), True3, False3); - Builder.SetInsertPoint(True3); - Builder.CreateCall(Func2, ConstantInt::getFalse(Context)); - Builder.CreateRetVoid(); - Builder.SetInsertPoint(False3); - Builder.CreateRetVoid(); - - // Compile the function to native code - void (*F1Ptr)() = - reinterpret_cast<void(*)()>((intptr_t)TheJIT->getPointerToFunction(Func1)); - - F1Ptr(); -} - -// Regression test for PR5162. This used to trigger an AssertingVH inside the -// JIT's Function to stub mapping. -TEST_F(JITTest, NonLazyLeaksNoStubs) { - TheJIT->DisableLazyCompilation(true); - - // Create two functions with a single basic block each. - const FunctionType *FuncTy = - cast<FunctionType>(TypeBuilder<int(), false>::get(Context)); - Function *Func1 = Function::Create(FuncTy, Function::ExternalLinkage, - "func1", M); - Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage, - "func2", M); - BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1); - BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2); - - // The first function calls the second and returns the result - IRBuilder<> Builder(Block1); - Value *Result = Builder.CreateCall(Func2); - Builder.CreateRet(Result); - - // The second function just returns a constant - Builder.SetInsertPoint(Block2); - Builder.CreateRet(ConstantInt::get(TypeBuilder<int, false>::get(Context),42)); - - // Compile the function to native code - (void)TheJIT->getPointerToFunction(Func1); - - // Free the JIT state for the functions - TheJIT->freeMachineCodeForFunction(Func1); - TheJIT->freeMachineCodeForFunction(Func2); - - // Delete the first function (and show that is has no users) - EXPECT_EQ(Func1->getNumUses(), 0u); - Func1->eraseFromParent(); - - // Delete the second function (and show that it has no users - it had one, - // func1 but that's gone now) - EXPECT_EQ(Func2->getNumUses(), 0u); - Func2->eraseFromParent(); -} - -TEST_F(JITTest, ModuleDeletion) { - TheJIT->DisableLazyCompilation(false); - LoadAssembly("define void @main() { " - " call i32 @computeVal() " - " ret void " - "} " - " " - "define internal i32 @computeVal() { " - " ret i32 0 " - "} "); - Function *func = M->getFunction("main"); - TheJIT->getPointerToFunction(func); - TheJIT->removeModule(M); - delete M; - - SmallPtrSet<const void*, 2> FunctionsDeallocated; - for (unsigned i = 0, e = RJMM->deallocateFunctionBodyCalls.size(); - i != e; ++i) { - FunctionsDeallocated.insert(RJMM->deallocateFunctionBodyCalls[i].Body); - } - for (unsigned i = 0, e = RJMM->startFunctionBodyCalls.size(); i != e; ++i) { - EXPECT_TRUE(FunctionsDeallocated.count( - RJMM->startFunctionBodyCalls[i].Result)) - << "Function leaked: \n" << RJMM->startFunctionBodyCalls[i].F_dump; - } - EXPECT_EQ(RJMM->startFunctionBodyCalls.size(), - RJMM->deallocateFunctionBodyCalls.size()); - - SmallPtrSet<const void*, 2> ExceptionTablesDeallocated; - unsigned NumTablesDeallocated = 0; - for (unsigned i = 0, e = RJMM->deallocateExceptionTableCalls.size(); - i != e; ++i) { - ExceptionTablesDeallocated.insert( - RJMM->deallocateExceptionTableCalls[i].ET); - if (RJMM->deallocateExceptionTableCalls[i].ET != NULL) { - // If JITEmitDebugInfo is off, we'll "deallocate" NULL, which doesn't - // appear in startExceptionTableCalls. - NumTablesDeallocated++; - } - } - for (unsigned i = 0, e = RJMM->startExceptionTableCalls.size(); i != e; ++i) { - EXPECT_TRUE(ExceptionTablesDeallocated.count( - RJMM->startExceptionTableCalls[i].Result)) - << "Function's exception table leaked: \n" - << RJMM->startExceptionTableCalls[i].F_dump; - } - EXPECT_EQ(RJMM->startExceptionTableCalls.size(), - NumTablesDeallocated); -} - -// ARM and PPC still emit stubs for calls since the target may be too far away -// to call directly. This #if can probably be removed when -// http://llvm.org/PR5201 is fixed. -#if !defined(__arm__) && !defined(__powerpc__) && !defined(__ppc__) -typedef int (*FooPtr) (); - -TEST_F(JITTest, NoStubs) { - LoadAssembly("define void @bar() {" - "entry: " - "ret void" - "}" - " " - "define i32 @foo() {" - "entry:" - "call void @bar()" - "ret i32 undef" - "}" - " " - "define i32 @main() {" - "entry:" - "%0 = call i32 @foo()" - "call void @bar()" - "ret i32 undef" - "}"); - Function *foo = M->getFunction("foo"); - uintptr_t tmp = (uintptr_t)(TheJIT->getPointerToFunction(foo)); - FooPtr ptr = (FooPtr)(tmp); - - (ptr)(); - - // We should now allocate no more stubs, we have the code to foo - // and the existing stub for bar. - int stubsBefore = RJMM->stubsAllocated; - Function *func = M->getFunction("main"); - TheJIT->getPointerToFunction(func); - - Function *bar = M->getFunction("bar"); - TheJIT->getPointerToFunction(bar); - - ASSERT_EQ(stubsBefore, RJMM->stubsAllocated); -} -#endif // !ARM && !PPC - -TEST_F(JITTest, FunctionPointersOutliveTheirCreator) { - TheJIT->DisableLazyCompilation(true); - LoadAssembly("define i8()* @get_foo_addr() { " - " ret i8()* @foo " - "} " - " " - "define i8 @foo() { " - " ret i8 42 " - "} "); - Function *F_get_foo_addr = M->getFunction("get_foo_addr"); - - typedef char(*fooT)(); - fooT (*get_foo_addr)() = reinterpret_cast<fooT(*)()>( - (intptr_t)TheJIT->getPointerToFunction(F_get_foo_addr)); - fooT foo_addr = get_foo_addr(); - - // Now free get_foo_addr. This should not free the machine code for foo or - // any call stub returned as foo's canonical address. - TheJIT->freeMachineCodeForFunction(F_get_foo_addr); - - // Check by calling the reported address of foo. - EXPECT_EQ(42, foo_addr()); - - // The reported address should also be the same as the result of a subsequent - // getPointerToFunction(foo). -#if 0 - // Fails until PR5126 is fixed: - Function *F_foo = M->getFunction("foo"); - fooT foo = reinterpret_cast<fooT>( - (intptr_t)TheJIT->getPointerToFunction(F_foo)); - EXPECT_EQ((intptr_t)foo, (intptr_t)foo_addr); -#endif -} - -// ARM doesn't have an implementation of replaceMachineCodeForFunction(), so -// recompileAndRelinkFunction doesn't work. -#if !defined(__arm__) -TEST_F(JITTest, FunctionIsRecompiledAndRelinked) { - Function *F = Function::Create(TypeBuilder<int(void), false>::get(Context), - GlobalValue::ExternalLinkage, "test", M); - BasicBlock *Entry = BasicBlock::Create(Context, "entry", F); - IRBuilder<> Builder(Entry); - Value *Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 1); - Builder.CreateRet(Val); - - TheJIT->DisableLazyCompilation(true); - // Compile the function once, and make sure it works. - int (*OrigFPtr)() = reinterpret_cast<int(*)()>( - (intptr_t)TheJIT->recompileAndRelinkFunction(F)); - EXPECT_EQ(1, OrigFPtr()); - - // Now change the function to return a different value. - Entry->eraseFromParent(); - BasicBlock *NewEntry = BasicBlock::Create(Context, "new_entry", F); - Builder.SetInsertPoint(NewEntry); - Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 2); - Builder.CreateRet(Val); - // Recompile it, which should produce a new function pointer _and_ update the - // old one. - int (*NewFPtr)() = reinterpret_cast<int(*)()>( - (intptr_t)TheJIT->recompileAndRelinkFunction(F)); - - EXPECT_EQ(2, NewFPtr()) - << "The new pointer should call the new version of the function"; - EXPECT_EQ(2, OrigFPtr()) - << "The old pointer's target should now jump to the new version"; -} -#endif // !defined(__arm__) - -} // anonymous namespace -// This variable is intentionally defined differently in the statically-compiled -// program from the IR input to the JIT to assert that the JIT doesn't use its -// definition. -extern "C" int32_t JITTest_AvailableExternallyGlobal; -int32_t JITTest_AvailableExternallyGlobal = 42; -namespace { - -TEST_F(JITTest, AvailableExternallyGlobalIsntEmitted) { - TheJIT->DisableLazyCompilation(true); - LoadAssembly("@JITTest_AvailableExternallyGlobal = " - " available_externally global i32 7 " - " " - "define i32 @loader() { " - " %result = load i32* @JITTest_AvailableExternallyGlobal " - " ret i32 %result " - "} "); - Function *loaderIR = M->getFunction("loader"); - - int32_t (*loader)() = reinterpret_cast<int32_t(*)()>( - (intptr_t)TheJIT->getPointerToFunction(loaderIR)); - EXPECT_EQ(42, loader()) << "func should return 42 from the external global," - << " not 7 from the IR version."; -} - -} // anonymous namespace -// This function is intentionally defined differently in the statically-compiled -// program from the IR input to the JIT to assert that the JIT doesn't use its -// definition. -extern "C" int32_t JITTest_AvailableExternallyFunction() { - return 42; -} -namespace { - -TEST_F(JITTest, AvailableExternallyFunctionIsntCompiled) { - TheJIT->DisableLazyCompilation(true); - LoadAssembly("define available_externally i32 " - " @JITTest_AvailableExternallyFunction() { " - " ret i32 7 " - "} " - " " - "define i32 @func() { " - " %result = tail call i32 " - " @JITTest_AvailableExternallyFunction() " - " ret i32 %result " - "} "); - Function *funcIR = M->getFunction("func"); - - int32_t (*func)() = reinterpret_cast<int32_t(*)()>( - (intptr_t)TheJIT->getPointerToFunction(funcIR)); - EXPECT_EQ(42, func()) << "func should return 42 from the static version," - << " not 7 from the IR version."; -} - -TEST_F(JITTest, NeedsExactSizeWithManyGlobals) { - // PR5291: When the JMM needed the exact size of function bodies before - // starting to emit them, the JITEmitter would modify a set while iterating - // over it. - TheJIT->DisableLazyCompilation(true); - RJMM->setSizeRequired(true); - - LoadAssembly("@A = global i32 42 " - "@B = global i32* @A " - "@C = global i32** @B " - "@D = global i32*** @C " - "@E = global i32**** @D " - "@F = global i32***** @E " - "@G = global i32****** @F " - "@H = global i32******* @G " - "@I = global i32******** @H " - "define i32********* @test() { " - " ret i32********* @I " - "}"); - Function *testIR = M->getFunction("test"); - int32_t********* (*test)() = reinterpret_cast<int32_t*********(*)()>( - (intptr_t)TheJIT->getPointerToFunction(testIR)); - EXPECT_EQ(42, *********test()); -} - -TEST_F(JITTest, EscapedLazyStubStillCallable) { - TheJIT->DisableLazyCompilation(false); - LoadAssembly("define internal i32 @stubbed() { " - " ret i32 42 " - "} " - " " - "define i32()* @get_stub() { " - " ret i32()* @stubbed " - "} "); - typedef int32_t(*StubTy)(); - - // Call get_stub() to get the address of @stubbed without actually JITting it. - Function *get_stubIR = M->getFunction("get_stub"); - StubTy (*get_stub)() = reinterpret_cast<StubTy(*)()>( - (intptr_t)TheJIT->getPointerToFunction(get_stubIR)); - StubTy stubbed = get_stub(); - // Now get_stubIR is the only reference to stubbed's stub. - get_stubIR->eraseFromParent(); - // Now there are no references inside the JIT, but we've got a pointer outside - // it. The stub should be callable and return the right value. - EXPECT_EQ(42, stubbed()); -} - -// Converts the LLVM assembly to bitcode and returns it in a std::string. An -// empty string indicates an error. -std::string AssembleToBitcode(LLVMContext &Context, const char *Assembly) { - Module TempModule("TempModule", Context); - if (!LoadAssemblyInto(&TempModule, Assembly)) { - return ""; - } - - std::string Result; - raw_string_ostream OS(Result); - WriteBitcodeToFile(&TempModule, OS); - OS.flush(); - return Result; -} - -// Returns a newly-created ExecutionEngine that reads the bitcode in 'Bitcode' -// lazily. The associated Module (owned by the ExecutionEngine) is returned in -// M. Both will be NULL on an error. Bitcode must live at least as long as the -// ExecutionEngine. -ExecutionEngine *getJITFromBitcode( - LLVMContext &Context, const std::string &Bitcode, Module *&M) { - // c_str() is null-terminated like MemoryBuffer::getMemBuffer requires. - MemoryBuffer *BitcodeBuffer = - MemoryBuffer::getMemBuffer(Bitcode, "Bitcode for test"); - std::string errMsg; - M = getLazyBitcodeModule(BitcodeBuffer, Context, &errMsg); - if (M == NULL) { - ADD_FAILURE() << errMsg; - delete BitcodeBuffer; - return NULL; - } - ExecutionEngine *TheJIT = EngineBuilder(M) - .setEngineKind(EngineKind::JIT) - .setErrorStr(&errMsg) - .create(); - if (TheJIT == NULL) { - ADD_FAILURE() << errMsg; - delete M; - M = NULL; - return NULL; - } - return TheJIT; -} - -TEST(LazyLoadedJITTest, MaterializableAvailableExternallyFunctionIsntCompiled) { - LLVMContext Context; - const std::string Bitcode = - AssembleToBitcode(Context, - "define available_externally i32 " - " @JITTest_AvailableExternallyFunction() { " - " ret i32 7 " - "} " - " " - "define i32 @func() { " - " %result = tail call i32 " - " @JITTest_AvailableExternallyFunction() " - " ret i32 %result " - "} "); - ASSERT_FALSE(Bitcode.empty()) << "Assembling failed"; - Module *M; - OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M)); - ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT."; - TheJIT->DisableLazyCompilation(true); - - Function *funcIR = M->getFunction("func"); - Function *availableFunctionIR = - M->getFunction("JITTest_AvailableExternallyFunction"); - - // Double-check that the available_externally function is still unmaterialized - // when getPointerToFunction needs to find out if it's available_externally. - EXPECT_TRUE(availableFunctionIR->isMaterializable()); - - int32_t (*func)() = reinterpret_cast<int32_t(*)()>( - (intptr_t)TheJIT->getPointerToFunction(funcIR)); - EXPECT_EQ(42, func()) << "func should return 42 from the static version," - << " not 7 from the IR version."; -} - -TEST(LazyLoadedJITTest, EagerCompiledRecursionThroughGhost) { - LLVMContext Context; - const std::string Bitcode = - AssembleToBitcode(Context, - "define i32 @recur1(i32 %a) { " - " %zero = icmp eq i32 %a, 0 " - " br i1 %zero, label %done, label %notdone " - "done: " - " ret i32 3 " - "notdone: " - " %am1 = sub i32 %a, 1 " - " %result = call i32 @recur2(i32 %am1) " - " ret i32 %result " - "} " - " " - "define i32 @recur2(i32 %b) { " - " %result = call i32 @recur1(i32 %b) " - " ret i32 %result " - "} "); - ASSERT_FALSE(Bitcode.empty()) << "Assembling failed"; - Module *M; - OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M)); - ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT."; - TheJIT->DisableLazyCompilation(true); - - Function *recur1IR = M->getFunction("recur1"); - Function *recur2IR = M->getFunction("recur2"); - EXPECT_TRUE(recur1IR->isMaterializable()); - EXPECT_TRUE(recur2IR->isMaterializable()); - - int32_t (*recur1)(int32_t) = reinterpret_cast<int32_t(*)(int32_t)>( - (intptr_t)TheJIT->getPointerToFunction(recur1IR)); - EXPECT_EQ(3, recur1(4)); -} - -// This code is copied from JITEventListenerTest, but it only runs once for all -// the tests in this directory. Everything seems fine, but that's strange -// behavior. -class JITEnvironment : public testing::Environment { - virtual void SetUp() { - // Required to create a JIT. - InitializeNativeTarget(); - } -}; -testing::Environment* const jit_env = - testing::AddGlobalTestEnvironment(new JITEnvironment); - -} diff --git a/contrib/llvm/unittests/ExecutionEngine/JIT/Makefile b/contrib/llvm/unittests/ExecutionEngine/JIT/Makefile deleted file mode 100644 index f5abe75..0000000 --- a/contrib/llvm/unittests/ExecutionEngine/JIT/Makefile +++ /dev/null @@ -1,18 +0,0 @@ -##===- unittests/ExecutionEngine/JIT/Makefile --------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LEVEL = ../../.. -TESTNAME = JIT -LINK_COMPONENTS := asmparser bitreader bitwriter core jit native support - -include $(LEVEL)/Makefile.config -include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest - -# Permit these tests to use the JIT's symbolic lookup. -LD.Flags += $(RDYNAMIC) diff --git a/contrib/llvm/unittests/ExecutionEngine/JIT/MultiJITTest.cpp b/contrib/llvm/unittests/ExecutionEngine/JIT/MultiJITTest.cpp deleted file mode 100644 index 8997d39..0000000 --- a/contrib/llvm/unittests/ExecutionEngine/JIT/MultiJITTest.cpp +++ /dev/null @@ -1,164 +0,0 @@ -//===- MultiJITTest.cpp - Unit tests for instantiating multiple JITs ------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "gtest/gtest.h" -#include "llvm/LLVMContext.h" -#include "llvm/Module.h" -#include "llvm/Assembly/Parser.h" -#include "llvm/ExecutionEngine/GenericValue.h" -#include "llvm/ExecutionEngine/JIT.h" -#include "llvm/Support/SourceMgr.h" -#include <vector> - -using namespace llvm; - -namespace { - -bool LoadAssemblyInto(Module *M, const char *assembly) { - SMDiagnostic Error; - bool success = - NULL != ParseAssemblyString(assembly, M, Error, M->getContext()); - std::string errMsg; - raw_string_ostream os(errMsg); - Error.Print("", os); - EXPECT_TRUE(success) << os.str(); - return success; -} - -void createModule1(LLVMContext &Context1, Module *&M1, Function *&FooF1) { - M1 = new Module("test1", Context1); - LoadAssemblyInto(M1, - "define i32 @add1(i32 %ArgX1) { " - "entry: " - " %addresult = add i32 1, %ArgX1 " - " ret i32 %addresult " - "} " - " " - "define i32 @foo1() { " - "entry: " - " %add1 = call i32 @add1(i32 10) " - " ret i32 %add1 " - "} "); - FooF1 = M1->getFunction("foo1"); -} - -void createModule2(LLVMContext &Context2, Module *&M2, Function *&FooF2) { - M2 = new Module("test2", Context2); - LoadAssemblyInto(M2, - "define i32 @add2(i32 %ArgX2) { " - "entry: " - " %addresult = add i32 2, %ArgX2 " - " ret i32 %addresult " - "} " - " " - "define i32 @foo2() { " - "entry: " - " %add2 = call i32 @add2(i32 10) " - " ret i32 %add2 " - "} "); - FooF2 = M2->getFunction("foo2"); -} - -TEST(MultiJitTest, EagerMode) { - LLVMContext Context1; - Module *M1 = 0; - Function *FooF1 = 0; - createModule1(Context1, M1, FooF1); - - LLVMContext Context2; - Module *M2 = 0; - Function *FooF2 = 0; - createModule2(Context2, M2, FooF2); - - // Now we create the JIT in eager mode - OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create()); - EE1->DisableLazyCompilation(true); - OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create()); - EE2->DisableLazyCompilation(true); - - // Call the `foo' function with no arguments: - std::vector<GenericValue> noargs; - GenericValue gv1 = EE1->runFunction(FooF1, noargs); - GenericValue gv2 = EE2->runFunction(FooF2, noargs); - - // Import result of execution: - EXPECT_EQ(gv1.IntVal, 11); - EXPECT_EQ(gv2.IntVal, 12); - - EE1->freeMachineCodeForFunction(FooF1); - EE2->freeMachineCodeForFunction(FooF2); -} - -TEST(MultiJitTest, LazyMode) { - LLVMContext Context1; - Module *M1 = 0; - Function *FooF1 = 0; - createModule1(Context1, M1, FooF1); - - LLVMContext Context2; - Module *M2 = 0; - Function *FooF2 = 0; - createModule2(Context2, M2, FooF2); - - // Now we create the JIT in lazy mode - OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create()); - EE1->DisableLazyCompilation(false); - OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create()); - EE2->DisableLazyCompilation(false); - - // Call the `foo' function with no arguments: - std::vector<GenericValue> noargs; - GenericValue gv1 = EE1->runFunction(FooF1, noargs); - GenericValue gv2 = EE2->runFunction(FooF2, noargs); - - // Import result of execution: - EXPECT_EQ(gv1.IntVal, 11); - EXPECT_EQ(gv2.IntVal, 12); - - EE1->freeMachineCodeForFunction(FooF1); - EE2->freeMachineCodeForFunction(FooF2); -} - -extern "C" { - extern void *getPointerToNamedFunction(const char *Name); -} - -TEST(MultiJitTest, JitPool) { - LLVMContext Context1; - Module *M1 = 0; - Function *FooF1 = 0; - createModule1(Context1, M1, FooF1); - - LLVMContext Context2; - Module *M2 = 0; - Function *FooF2 = 0; - createModule2(Context2, M2, FooF2); - - // Now we create two JITs - OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create()); - OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create()); - - Function *F1 = EE1->FindFunctionNamed("foo1"); - void *foo1 = EE1->getPointerToFunction(F1); - - Function *F2 = EE2->FindFunctionNamed("foo2"); - void *foo2 = EE2->getPointerToFunction(F2); - - // Function in M1 - EXPECT_EQ(getPointerToNamedFunction("foo1"), foo1); - - // Function in M2 - EXPECT_EQ(getPointerToNamedFunction("foo2"), foo2); - - // Symbol search - EXPECT_EQ((intptr_t)getPointerToNamedFunction("getPointerToNamedFunction"), - (intptr_t)&getPointerToNamedFunction); -} - -} // anonymous namespace diff --git a/contrib/llvm/unittests/ExecutionEngine/Makefile b/contrib/llvm/unittests/ExecutionEngine/Makefile deleted file mode 100644 index d4ef92f..0000000 --- a/contrib/llvm/unittests/ExecutionEngine/Makefile +++ /dev/null @@ -1,18 +0,0 @@ -##===- unittests/ExecutionEngine/Makefile ------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LEVEL = ../.. -TESTNAME = ExecutionEngine -LINK_COMPONENTS := engine interpreter - -include $(LEVEL)/Makefile.config - -PARALLEL_DIRS = JIT - -include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest |
