1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
//===- 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/BasicBlock.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/ModuleProvider.h"
#include "llvm/Support/IRBuilder.h"
#include "llvm/Support/TypeBuilder.h"
#include "llvm/Target/TargetSelect.h"
#include "llvm/Type.h"
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;
}
class JITTest : public testing::Test {
protected:
virtual void SetUp() {
M = new Module("<main>", Context);
std::string Error;
TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT)
.setErrorStr(&Error).create());
ASSERT_TRUE(TheJIT.get() != NULL) << Error;
}
LLVMContext Context;
Module *M; // Owned by ExecutionEngine.
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);
ExistingModuleProvider *MP = new ExistingModuleProvider(M);
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(MP)
.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)();
// Hack to avoid ISO C++ warning about casting function pointers.
*(void**)(void*)&F1Ptr = 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);
// Hack to avoid ISO C++ warning about casting function pointers.
void (*F2Ptr)();
*(void**)(void*)&F2Ptr = 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->EnableDlsymStubs(false);
TheJIT->DisableLazyCompilation();
int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>(
(intptr_t)TheJIT->getPointerToFunction(TestFunction));
// This used to crash in trying to call PlusOne().
EXPECT_EQ(8, TestFunctionPtr());
}
// 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);
}
|
