1 //===- JITTest.cpp - Unit tests for the JIT -------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "gtest/gtest.h"
11 #include "llvm/ADT/OwningPtr.h"
12 #include "llvm/BasicBlock.h"
13 #include "llvm/Constant.h"
14 #include "llvm/Constants.h"
15 #include "llvm/DerivedTypes.h"
16 #include "llvm/ExecutionEngine/JIT.h"
17 #include "llvm/ExecutionEngine/JITMemoryManager.h"
18 #include "llvm/Function.h"
19 #include "llvm/GlobalValue.h"
20 #include "llvm/GlobalVariable.h"
21 #include "llvm/LLVMContext.h"
22 #include "llvm/Module.h"
23 #include "llvm/ModuleProvider.h"
24 #include "llvm/Support/IRBuilder.h"
25 #include "llvm/Support/TypeBuilder.h"
26 #include "llvm/Target/TargetSelect.h"
27 #include "llvm/Type.h"
33 Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
34 std::vector<const Type*> params;
35 const FunctionType *FTy = FunctionType::get(G->getType()->getElementType(),
37 Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
38 BasicBlock *Entry = BasicBlock::Create(M->getContext(), "entry", F);
39 IRBuilder<> builder(Entry);
40 Value *Load = builder.CreateLoad(G);
41 const Type *GTy = G->getType()->getElementType();
42 Value *Add = builder.CreateAdd(Load, ConstantInt::get(GTy, 1LL));
43 builder.CreateStore(Add, G);
44 builder.CreateRet(Add);
48 class JITTest : public testing::Test {
50 virtual void SetUp() {
51 M = new Module("<main>", Context);
53 TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT)
54 .setErrorStr(&Error).create());
55 ASSERT_TRUE(TheJIT.get() != NULL) << Error;
59 Module *M; // Owned by ExecutionEngine.
60 OwningPtr<ExecutionEngine> TheJIT;
63 // Regression test for a bug. The JIT used to allocate globals inside the same
64 // memory block used for the function, and when the function code was freed,
65 // the global was left in the same place. This test allocates a function
66 // that uses and global, deallocates it, and then makes sure that the global
67 // stays alive after that.
68 TEST(JIT, GlobalInFunction) {
70 Module *M = new Module("<main>", context);
71 ExistingModuleProvider *MP = new ExistingModuleProvider(M);
73 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
74 // Tell the memory manager to poison freed memory so that accessing freed
75 // memory is more easily tested.
76 MemMgr->setPoisonMemory(true);
78 OwningPtr<ExecutionEngine> JIT(EngineBuilder(MP)
79 .setEngineKind(EngineKind::JIT)
81 .setJITMemoryManager(MemMgr)
82 // The next line enables the fix:
83 .setAllocateGVsWithCode(false)
87 // Create a global variable.
88 const Type *GTy = Type::getInt32Ty(context);
89 GlobalVariable *G = new GlobalVariable(
92 false, // Not constant.
93 GlobalValue::InternalLinkage,
94 Constant::getNullValue(GTy),
97 // Make a function that points to a global.
98 Function *F1 = makeReturnGlobal("F1", G, M);
100 // Get the pointer to the native code to force it to JIT the function and
101 // allocate space for the global.
103 // Hack to avoid ISO C++ warning about casting function pointers.
104 *(void**)(void*)&F1Ptr = JIT->getPointerToFunction(F1);
106 // Since F1 was codegen'd, a pointer to G should be available.
107 int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
108 ASSERT_NE((int32_t*)NULL, GPtr);
111 // F1() should increment G.
115 // Make a second function identical to the first, referring to the same
117 Function *F2 = makeReturnGlobal("F2", G, M);
118 // Hack to avoid ISO C++ warning about casting function pointers.
120 *(void**)(void*)&F2Ptr = JIT->getPointerToFunction(F2);
122 // F2() should increment G.
127 JIT->freeMachineCodeForFunction(F1);
129 // F2() should *still* increment G.
134 int PlusOne(int arg) {
138 TEST_F(JITTest, FarCallToKnownFunction) {
139 // x86-64 can only make direct calls to functions within 32 bits of
140 // the current PC. To call anything farther away, we have to load
141 // the address into a register and call through the register. The
142 // current JIT does this by allocating a stub for any far call.
143 // There was a bug in which the JIT tried to emit a direct call when
144 // the target was already in the JIT's global mappings and lazy
145 // compilation was disabled.
147 Function *KnownFunction = Function::Create(
148 TypeBuilder<int(int), false>::get(Context),
149 GlobalValue::ExternalLinkage, "known", M);
150 TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne);
152 // int test() { return known(7); }
153 Function *TestFunction = Function::Create(
154 TypeBuilder<int(), false>::get(Context),
155 GlobalValue::ExternalLinkage, "test", M);
156 BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction);
157 IRBuilder<> Builder(Entry);
158 Value *result = Builder.CreateCall(
160 ConstantInt::get(TypeBuilder<int, false>::get(Context), 7));
161 Builder.CreateRet(result);
163 TheJIT->EnableDlsymStubs(false);
164 TheJIT->DisableLazyCompilation();
165 int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>(
166 (intptr_t)TheJIT->getPointerToFunction(TestFunction));
167 // This used to crash in trying to call PlusOne().
168 EXPECT_EQ(8, TestFunctionPtr());
171 // This code is copied from JITEventListenerTest, but it only runs once for all
172 // the tests in this directory. Everything seems fine, but that's strange
174 class JITEnvironment : public testing::Environment {
175 virtual void SetUp() {
176 // Required to create a JIT.
177 InitializeNativeTarget();
180 testing::Environment* const jit_env =
181 testing::AddGlobalTestEnvironment(new JITEnvironment);