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/Target/TargetSelect.h"
26 #include "llvm/Type.h"
32 Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
33 std::vector<const Type*> params;
34 const FunctionType *FTy = FunctionType::get(G->getType()->getElementType(),
36 Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
37 BasicBlock *Entry = BasicBlock::Create("entry", F);
38 IRBuilder<> builder(Entry);
39 Value *Load = builder.CreateLoad(G);
40 const Type *GTy = G->getType()->getElementType();
41 Value *Add = builder.CreateAdd(Load, ConstantInt::get(GTy, 1LL));
42 builder.CreateStore(Add, G);
43 builder.CreateRet(Add);
47 // Regression test for a bug. The JIT used to allocate globals inside the same
48 // memory block used for the function, and when the function code was freed,
49 // the global was left in the same place. This test allocates a function
50 // that uses and global, deallocates it, and then makes sure that the global
51 // stays alive after that.
52 TEST(JIT, GlobalInFunction) {
54 Module *M = new Module("<main>", context);
55 ExistingModuleProvider *MP = new ExistingModuleProvider(M);
57 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
58 // Tell the memory manager to poison freed memory so that accessing freed
59 // memory is more easily tested.
60 MemMgr->setPoisonMemory(true);
62 OwningPtr<ExecutionEngine> JIT(EngineBuilder(MP)
63 .setEngineKind(EngineKind::JIT)
65 .setJITMemoryManager(MemMgr)
66 // The next line enables the fix:
67 .setAllocateGVsWithCode(false)
71 // Create a global variable.
72 const Type *GTy = Type::Int32Ty;
73 GlobalVariable *G = new GlobalVariable(
76 false, // Not constant.
77 GlobalValue::InternalLinkage,
78 context.getNullValue(GTy),
81 // Make a function that points to a global.
82 Function *F1 = makeReturnGlobal("F1", G, M);
84 // Get the pointer to the native code to force it to JIT the function and
85 // allocate space for the global.
87 // Hack to avoid ISO C++ warning about casting function pointers.
88 *(void**)(void*)&F1Ptr = JIT->getPointerToFunction(F1);
90 // Since F1 was codegen'd, a pointer to G should be available.
91 int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
92 ASSERT_NE((int32_t*)NULL, GPtr);
95 // F1() should increment G.
99 // Make a second function identical to the first, referring to the same
101 Function *F2 = makeReturnGlobal("F2", G, M);
102 // Hack to avoid ISO C++ warning about casting function pointers.
104 *(void**)(void*)&F2Ptr = JIT->getPointerToFunction(F2);
106 // F2() should increment G.
111 JIT->freeMachineCodeForFunction(F1);
113 // F2() should *still* increment G.
118 // This code is copied from JITEventListenerTest, but it only runs once for all
119 // the tests in this directory. Everything seems fine, but that's strange
121 class JITEnvironment : public testing::Environment {
122 virtual void SetUp() {
123 // Required to create a JIT.
124 InitializeNativeTarget();
127 testing::Environment* const jit_env =
128 testing::AddGlobalTestEnvironment(new JITEnvironment);