/
OrcCAPITest.cpp
331 lines (300 loc) · 12.2 KB
/
OrcCAPITest.cpp
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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
//===--- OrcCAPITest.cpp - Unit tests for the OrcJIT v2 C API ---*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm-c/Core.h"
#include "llvm-c/LLJIT.h"
#include "llvm-c/Orc.h"
#include "gtest/gtest.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
// OrcCAPITestBase contains several helper methods and pointers for unit tests
// written for the LLVM-C API. It provides the following helpers:
//
// 1. Jit: an LLVMOrcLLJIT instance which is freed upon test exit
// 2. ExecutionSession: the LLVMOrcExecutionSession for the JIT
// 3. MainDylib: the main JITDylib for the LLJIT instance
// 4. materializationUnitFn: function pointer to an empty function, used for
// materialization unit testing
// 5. definitionGeneratorFn: function pointer for a basic
// LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction
// 6. createTestModule: helper method for creating a basic thread-safe-module
class OrcCAPITestBase : public testing::Test {
protected:
LLVMOrcLLJITRef Jit = nullptr;
LLVMOrcExecutionSessionRef ExecutionSession = nullptr;
LLVMOrcJITDylibRef MainDylib = nullptr;
public:
static void SetUpTestCase() {
LLVMInitializeNativeTarget();
LLVMInitializeNativeAsmParser();
LLVMInitializeNativeAsmPrinter();
// Attempt to set up a JIT instance once to verify that we can.
LLVMOrcJITTargetMachineBuilderRef JTMB = nullptr;
if (LLVMErrorRef E = LLVMOrcJITTargetMachineBuilderDetectHost(&JTMB)) {
// If setup fails then disable these tests.
LLVMConsumeError(E);
TargetSupported = false;
return;
}
// Capture the target triple. We'll use it for both verification that
// this target is *supposed* to be supported, and error messages in
// the case that it fails anyway.
char *TT = LLVMOrcJITTargetMachineBuilderGetTargetTriple(JTMB);
TargetTriple = TT;
LLVMOrcJITTargetMachineBuilderDisposeTargetTriple(JTMB, TT);
if (!isSupported(TargetTriple)) {
// If this triple isn't supported then bail out.
TargetSupported = false;
LLVMOrcDisposeJITTargetMachineBuilder(JTMB);
return;
}
LLVMOrcLLJITBuilderRef Builder = LLVMOrcCreateLLJITBuilder();
LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(Builder, JTMB);
LLVMOrcLLJITRef J;
if (LLVMErrorRef E = LLVMOrcCreateLLJIT(&J, Builder)) {
// If setup fails then disable these tests.
TargetSupported = false;
LLVMConsumeError(E);
return;
}
LLVMOrcDisposeLLJIT(J);
TargetSupported = true;
}
void SetUp() override {
if (!TargetSupported)
return;
LLVMOrcJITTargetMachineBuilderRef JTMB = nullptr;
LLVMErrorRef E1 = LLVMOrcJITTargetMachineBuilderDetectHost(&JTMB);
assert(E1 == LLVMErrorSuccess && "Expected call to detect host to succeed");
LLVMOrcLLJITBuilderRef Builder = LLVMOrcCreateLLJITBuilder();
LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(Builder, JTMB);
LLVMErrorRef E2 = LLVMOrcCreateLLJIT(&Jit, Builder);
assert(E2 == LLVMErrorSuccess &&
"Expected call to create LLJIT to succeed");
ExecutionSession = LLVMOrcLLJITGetExecutionSession(Jit);
MainDylib = LLVMOrcLLJITGetMainJITDylib(Jit);
}
void TearDown() override {
LLVMOrcDisposeLLJIT(Jit);
Jit = nullptr;
}
protected:
static bool isSupported(StringRef Triple) {
if (Triple.startswith("armv7"))
return false;
return true;
}
static void materializationUnitFn() {}
// Stub definition generator, where all Names are materialized from the
// materializationUnitFn() test function and defined into the JIT Dylib
static LLVMErrorRef
definitionGeneratorFn(LLVMOrcDefinitionGeneratorRef G, void *Ctx,
LLVMOrcLookupStateRef *LS, LLVMOrcLookupKind K,
LLVMOrcJITDylibRef JD, LLVMOrcJITDylibLookupFlags F,
LLVMOrcCLookupSet Names, size_t NamesCount) {
for (size_t I = 0; I < NamesCount; I++) {
LLVMOrcCLookupSetElement Element = Names[I];
LLVMOrcJITTargetAddress Addr =
(LLVMOrcJITTargetAddress)(&materializationUnitFn);
LLVMJITSymbolFlags Flags = {LLVMJITSymbolGenericFlagsWeak, 0};
LLVMJITEvaluatedSymbol Sym = {Addr, Flags};
LLVMOrcRetainSymbolStringPoolEntry(Element.Name);
LLVMJITCSymbolMapPair Pair = {Element.Name, Sym};
LLVMJITCSymbolMapPair Pairs[] = {Pair};
LLVMOrcMaterializationUnitRef MU = LLVMOrcAbsoluteSymbols(Pairs, 1);
LLVMErrorRef Err = LLVMOrcJITDylibDefine(JD, MU);
if (Err)
return Err;
}
return LLVMErrorSuccess;
}
// create a test LLVM IR module containing a function named "sum" which has
// returns the sum of its two parameters
static LLVMOrcThreadSafeModuleRef createTestModule() {
LLVMOrcThreadSafeContextRef TSC = LLVMOrcCreateNewThreadSafeContext();
LLVMContextRef Ctx = LLVMOrcThreadSafeContextGetContext(TSC);
LLVMModuleRef Mod = LLVMModuleCreateWithNameInContext("test", Ctx);
{
LLVMTypeRef Int32Ty = LLVMInt32TypeInContext(Ctx);
LLVMTypeRef ParamTys[] = {Int32Ty, Int32Ty};
LLVMTypeRef TestFnTy = LLVMFunctionType(Int32Ty, ParamTys, 2, 0);
LLVMValueRef TestFn = LLVMAddFunction(Mod, "sum", TestFnTy);
LLVMBuilderRef IRBuilder = LLVMCreateBuilderInContext(Ctx);
LLVMBasicBlockRef EntryBB = LLVMAppendBasicBlock(TestFn, "entry");
LLVMPositionBuilderAtEnd(IRBuilder, EntryBB);
LLVMValueRef Arg1 = LLVMGetParam(TestFn, 0);
LLVMValueRef Arg2 = LLVMGetParam(TestFn, 1);
LLVMValueRef Sum = LLVMBuildAdd(IRBuilder, Arg1, Arg2, "");
LLVMBuildRet(IRBuilder, Sum);
LLVMDisposeBuilder(IRBuilder);
}
LLVMOrcThreadSafeModuleRef TSM = LLVMOrcCreateNewThreadSafeModule(Mod, TSC);
LLVMOrcDisposeThreadSafeContext(TSC);
return TSM;
}
static std::string TargetTriple;
static bool TargetSupported;
};
std::string OrcCAPITestBase::TargetTriple;
bool OrcCAPITestBase::TargetSupported = false;
TEST_F(OrcCAPITestBase, SymbolStringPoolUniquing) {
if (!Jit) {
// TODO: Use GTEST_SKIP() when GTest is updated to version 1.10.0
return;
}
LLVMOrcSymbolStringPoolEntryRef E1 =
LLVMOrcExecutionSessionIntern(ExecutionSession, "aaa");
LLVMOrcSymbolStringPoolEntryRef E2 =
LLVMOrcExecutionSessionIntern(ExecutionSession, "aaa");
LLVMOrcSymbolStringPoolEntryRef E3 =
LLVMOrcExecutionSessionIntern(ExecutionSession, "bbb");
const char *SymbolName = LLVMOrcSymbolStringPoolEntryStr(E1);
ASSERT_EQ(E1, E2) << "String pool entries are not unique";
ASSERT_NE(E1, E3) << "Unique symbol pool entries are equal";
ASSERT_STREQ("aaa", SymbolName) << "String value of symbol is not equal";
LLVMOrcReleaseSymbolStringPoolEntry(E1);
LLVMOrcReleaseSymbolStringPoolEntry(E2);
LLVMOrcReleaseSymbolStringPoolEntry(E3);
}
TEST_F(OrcCAPITestBase, JITDylibLookup) {
if (!Jit) {
// TODO: Use GTEST_SKIP() when GTest is updated to version 1.10.0
return;
}
LLVMOrcJITDylibRef DoesNotExist =
LLVMOrcExecutionSessionGetJITDylibByName(ExecutionSession, "test");
ASSERT_FALSE(!!DoesNotExist);
LLVMOrcJITDylibRef L1 =
LLVMOrcExecutionSessionCreateBareJITDylib(ExecutionSession, "test");
LLVMOrcJITDylibRef L2 =
LLVMOrcExecutionSessionGetJITDylibByName(ExecutionSession, "test");
ASSERT_EQ(L1, L2) << "Located JIT Dylib is not equal to original";
}
TEST_F(OrcCAPITestBase, MaterializationUnitCreation) {
if (!Jit) {
// TODO: Use GTEST_SKIP() when GTest is updated to version 1.10.0
return;
}
LLVMOrcSymbolStringPoolEntryRef Name =
LLVMOrcLLJITMangleAndIntern(Jit, "test");
LLVMJITSymbolFlags Flags = {LLVMJITSymbolGenericFlagsWeak, 0};
LLVMOrcJITTargetAddress Addr =
(LLVMOrcJITTargetAddress)(&materializationUnitFn);
LLVMJITEvaluatedSymbol Sym = {Addr, Flags};
LLVMJITCSymbolMapPair Pair = {Name, Sym};
LLVMJITCSymbolMapPair Pairs[] = {Pair};
LLVMOrcMaterializationUnitRef MU = LLVMOrcAbsoluteSymbols(Pairs, 1);
LLVMOrcJITDylibDefine(MainDylib, MU);
LLVMOrcJITTargetAddress OutAddr;
if (LLVMErrorRef E = LLVMOrcLLJITLookup(Jit, &OutAddr, "test")) {
LLVMConsumeError(E);
FAIL() << "Failed to look up \"test\" symbol (triple = "
<< TargetTriple << ")";
}
ASSERT_EQ(Addr, OutAddr);
}
TEST_F(OrcCAPITestBase, DefinitionGenerators) {
if (!Jit) {
// TODO: Use GTEST_SKIP() when GTest is updated to version 1.10.0
return;
}
LLVMOrcDefinitionGeneratorRef Gen =
LLVMOrcCreateCustomCAPIDefinitionGenerator(&definitionGeneratorFn,
nullptr);
LLVMOrcJITDylibAddGenerator(MainDylib, Gen);
LLVMOrcJITTargetAddress OutAddr;
if (LLVMErrorRef E = LLVMOrcLLJITLookup(Jit, &OutAddr, "test")) {
LLVMConsumeError(E);
FAIL() << "The DefinitionGenerator did not create symbol \"test\" "
<< "(triple = " << TargetTriple << ")";
}
LLVMOrcJITTargetAddress ExpectedAddr =
(LLVMOrcJITTargetAddress)(&materializationUnitFn);
ASSERT_EQ(ExpectedAddr, OutAddr);
}
TEST_F(OrcCAPITestBase, ResourceTrackerDefinitionLifetime) {
if (!Jit) {
// TODO: Use GTEST_SKIP() when GTest is updated to version 1.10.0
return;
}
// This test case ensures that all symbols loaded into a JITDylib with a
// ResourceTracker attached are cleared from the JITDylib once the RT is
// removed.
LLVMOrcResourceTrackerRef RT =
LLVMOrcJITDylibCreateResourceTracker(MainDylib);
LLVMOrcThreadSafeModuleRef TSM = createTestModule();
if (LLVMErrorRef E = LLVMOrcLLJITAddLLVMIRModuleWithRT(Jit, RT, TSM)) {
LLVMConsumeError(E);
FAIL() << "Failed to add LLVM IR module to LLJIT (triple = "
<< TargetTriple << ")";
}
LLVMOrcJITTargetAddress TestFnAddr;
if (LLVMErrorRef E = LLVMOrcLLJITLookup(Jit, &TestFnAddr, "sum")) {
LLVMConsumeError(E);
FAIL() << "Symbol \"sum\" was not added into JIT (triple = "
<< TargetTriple << ")";
}
ASSERT_TRUE(!!TestFnAddr);
LLVMOrcResourceTrackerRemove(RT);
LLVMOrcJITTargetAddress OutAddr;
LLVMErrorRef Err = LLVMOrcLLJITLookup(Jit, &OutAddr, "sum");
ASSERT_TRUE(Err);
ASSERT_FALSE(OutAddr);
LLVMOrcReleaseResourceTracker(RT);
LLVMConsumeError(Err);
}
TEST_F(OrcCAPITestBase, ResourceTrackerTransfer) {
if (!Jit) {
// TODO: Use GTEST_SKIP() when GTest is updated to version 1.10.0
return;
}
LLVMOrcResourceTrackerRef DefaultRT =
LLVMOrcJITDylibGetDefaultResourceTracker(MainDylib);
LLVMOrcResourceTrackerRef RT2 =
LLVMOrcJITDylibCreateResourceTracker(MainDylib);
LLVMOrcThreadSafeModuleRef TSM = createTestModule();
if (LLVMErrorRef E = LLVMOrcLLJITAddLLVMIRModuleWithRT(Jit, DefaultRT, TSM)) {
LLVMConsumeError(E);
FAIL() << "Failed to add LLVM IR module to LLJIT (triple = "
<< TargetTriple << ")";
}
LLVMOrcJITTargetAddress Addr;
if (LLVMErrorRef E = LLVMOrcLLJITLookup(Jit, &Addr, "sum")) {
LLVMConsumeError(E);
FAIL() << "Symbol \"sum\" was not added into JIT (triple = "
<< TargetTriple << ")";
}
LLVMOrcResourceTrackerTransferTo(DefaultRT, RT2);
LLVMErrorRef Err = LLVMOrcLLJITLookup(Jit, &Addr, "sum");
ASSERT_FALSE(Err);
LLVMOrcReleaseResourceTracker(RT2);
}
TEST_F(OrcCAPITestBase, ExecutionTest) {
if (!Jit) {
// TODO: Use GTEST_SKIP() when GTest is updated to version 1.10.0
return;
}
using SumFunctionType = int32_t (*)(int32_t, int32_t);
// This test performs OrcJIT compilation of a simple sum module
LLVMInitializeNativeAsmPrinter();
LLVMOrcThreadSafeModuleRef TSM = createTestModule();
if (LLVMErrorRef E = LLVMOrcLLJITAddLLVMIRModule(Jit, MainDylib, TSM)) {
LLVMConsumeError(E);
FAIL() << "Failed to add LLVM IR module to LLJIT (triple = "
<< TargetTriple << ")";
}
LLVMOrcJITTargetAddress TestFnAddr;
if (LLVMErrorRef E = LLVMOrcLLJITLookup(Jit, &TestFnAddr, "sum")) {
LLVMConsumeError(E);
FAIL() << "Symbol \"sum\" was not added into JIT (triple = "
<< TargetTriple << ")";
}
auto *SumFn = (SumFunctionType)(TestFnAddr);
int32_t Result = SumFn(1, 1);
ASSERT_EQ(2, Result);
}