• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- MCJITTest.cpp - Unit tests for the MCJIT -----------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This test suite verifies basic MCJIT functionality when invoked form the C
11 // API.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm-c/Analysis.h"
16 #include "MCJITTestAPICommon.h"
17 #include "llvm-c/Core.h"
18 #include "llvm-c/ExecutionEngine.h"
19 #include "llvm-c/Target.h"
20 #include "llvm-c/Transforms/PassManagerBuilder.h"
21 #include "llvm-c/Transforms/Scalar.h"
22 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
23 #include "llvm/Support/Debug.h"
24 #include "llvm/Support/Host.h"
25 #include "gtest/gtest.h"
26 
27 using namespace llvm;
28 
29 static bool didCallAllocateCodeSection;
30 static bool didAllocateCompactUnwindSection;
31 static bool didCallYield;
32 
roundTripAllocateCodeSection(void * object,uintptr_t size,unsigned alignment,unsigned sectionID,const char * sectionName)33 static uint8_t *roundTripAllocateCodeSection(void *object, uintptr_t size,
34                                              unsigned alignment,
35                                              unsigned sectionID,
36                                              const char *sectionName) {
37   didCallAllocateCodeSection = true;
38   return static_cast<SectionMemoryManager*>(object)->allocateCodeSection(
39     size, alignment, sectionID, sectionName);
40 }
41 
roundTripAllocateDataSection(void * object,uintptr_t size,unsigned alignment,unsigned sectionID,const char * sectionName,LLVMBool isReadOnly)42 static uint8_t *roundTripAllocateDataSection(void *object, uintptr_t size,
43                                              unsigned alignment,
44                                              unsigned sectionID,
45                                              const char *sectionName,
46                                              LLVMBool isReadOnly) {
47   if (!strcmp(sectionName, "__compact_unwind"))
48     didAllocateCompactUnwindSection = true;
49   return static_cast<SectionMemoryManager*>(object)->allocateDataSection(
50     size, alignment, sectionID, sectionName, isReadOnly);
51 }
52 
roundTripFinalizeMemory(void * object,char ** errMsg)53 static LLVMBool roundTripFinalizeMemory(void *object, char **errMsg) {
54   std::string errMsgString;
55   bool result =
56     static_cast<SectionMemoryManager*>(object)->finalizeMemory(&errMsgString);
57   if (result) {
58     *errMsg = LLVMCreateMessage(errMsgString.c_str());
59     return 1;
60   }
61   return 0;
62 }
63 
roundTripDestroy(void * object)64 static void roundTripDestroy(void *object) {
65   delete static_cast<SectionMemoryManager*>(object);
66 }
67 
yield(LLVMContextRef,void *)68 static void yield(LLVMContextRef, void *) {
69   didCallYield = true;
70 }
71 
72 namespace {
73 
74 // memory manager to test reserve allocation space callback
75 class TestReserveAllocationSpaceMemoryManager: public SectionMemoryManager {
76 public:
77   uintptr_t ReservedCodeSize;
78   uintptr_t UsedCodeSize;
79   uintptr_t ReservedDataSizeRO;
80   uintptr_t UsedDataSizeRO;
81   uintptr_t ReservedDataSizeRW;
82   uintptr_t UsedDataSizeRW;
83 
TestReserveAllocationSpaceMemoryManager()84   TestReserveAllocationSpaceMemoryManager() :
85     ReservedCodeSize(0), UsedCodeSize(0), ReservedDataSizeRO(0),
86     UsedDataSizeRO(0), ReservedDataSizeRW(0), UsedDataSizeRW(0) {
87   }
88 
needsToReserveAllocationSpace()89   bool needsToReserveAllocationSpace() override { return true; }
90 
reserveAllocationSpace(uintptr_t CodeSize,uint32_t CodeAlign,uintptr_t DataSizeRO,uint32_t RODataAlign,uintptr_t DataSizeRW,uint32_t RWDataAlign)91   void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
92 			      uintptr_t DataSizeRO, uint32_t RODataAlign,
93                               uintptr_t DataSizeRW, uint32_t RWDataAlign) override {
94     ReservedCodeSize = CodeSize;
95     ReservedDataSizeRO = DataSizeRO;
96     ReservedDataSizeRW = DataSizeRW;
97   }
98 
useSpace(uintptr_t * UsedSize,uintptr_t Size,unsigned Alignment)99   void useSpace(uintptr_t* UsedSize, uintptr_t Size, unsigned Alignment) {
100     uintptr_t AlignedSize = (Size + Alignment - 1) / Alignment * Alignment;
101     uintptr_t AlignedBegin = (*UsedSize + Alignment - 1) / Alignment * Alignment;
102     *UsedSize = AlignedBegin + AlignedSize;
103   }
104 
allocateDataSection(uintptr_t Size,unsigned Alignment,unsigned SectionID,StringRef SectionName,bool IsReadOnly)105   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
106                                unsigned SectionID, StringRef SectionName,
107                                bool IsReadOnly) override {
108     useSpace(IsReadOnly ? &UsedDataSizeRO : &UsedDataSizeRW, Size, Alignment);
109     return SectionMemoryManager::allocateDataSection(Size, Alignment,
110       SectionID, SectionName, IsReadOnly);
111   }
112 
allocateCodeSection(uintptr_t Size,unsigned Alignment,unsigned SectionID,StringRef SectionName)113   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
114                                unsigned SectionID,
115                                StringRef SectionName) override {
116     useSpace(&UsedCodeSize, Size, Alignment);
117     return SectionMemoryManager::allocateCodeSection(Size, Alignment,
118       SectionID, SectionName);
119   }
120 };
121 
122 class MCJITCAPITest : public testing::Test, public MCJITTestAPICommon {
123 protected:
MCJITCAPITest()124   MCJITCAPITest() {
125     // The architectures below are known to be compatible with MCJIT as they
126     // are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be
127     // kept in sync.
128     SupportedArchs.push_back(Triple::aarch64);
129     SupportedArchs.push_back(Triple::arm);
130     SupportedArchs.push_back(Triple::mips);
131     SupportedArchs.push_back(Triple::mips64);
132     SupportedArchs.push_back(Triple::mips64el);
133     SupportedArchs.push_back(Triple::x86);
134     SupportedArchs.push_back(Triple::x86_64);
135 
136     // Some architectures have sub-architectures in which tests will fail, like
137     // ARM. These two vectors will define if they do have sub-archs (to avoid
138     // extra work for those who don't), and if so, if they are listed to work
139     HasSubArchs.push_back(Triple::arm);
140     SupportedSubArchs.push_back("armv6");
141     SupportedSubArchs.push_back("armv7");
142 
143     // The operating systems below are known to be sufficiently incompatible
144     // that they will fail the MCJIT C API tests.
145     UnsupportedEnvironments.push_back(Triple::Cygnus);
146   }
147 
SetUp()148   void SetUp() override {
149     didCallAllocateCodeSection = false;
150     didAllocateCompactUnwindSection = false;
151     didCallYield = false;
152     Module = nullptr;
153     Function = nullptr;
154     Engine = nullptr;
155     Error = nullptr;
156   }
157 
TearDown()158   void TearDown() override {
159     if (Engine)
160       LLVMDisposeExecutionEngine(Engine);
161     else if (Module)
162       LLVMDisposeModule(Module);
163   }
164 
buildSimpleFunction()165   void buildSimpleFunction() {
166     Module = LLVMModuleCreateWithName("simple_module");
167 
168     LLVMSetTarget(Module, HostTriple.c_str());
169 
170     Function = LLVMAddFunction(Module, "simple_function",
171                                LLVMFunctionType(LLVMInt32Type(), nullptr,0, 0));
172     LLVMSetFunctionCallConv(Function, LLVMCCallConv);
173 
174     LLVMBasicBlockRef entry = LLVMAppendBasicBlock(Function, "entry");
175     LLVMBuilderRef builder = LLVMCreateBuilder();
176     LLVMPositionBuilderAtEnd(builder, entry);
177     LLVMBuildRet(builder, LLVMConstInt(LLVMInt32Type(), 42, 0));
178 
179     LLVMVerifyModule(Module, LLVMAbortProcessAction, &Error);
180     LLVMDisposeMessage(Error);
181 
182     LLVMDisposeBuilder(builder);
183   }
184 
buildFunctionThatUsesStackmap()185   void buildFunctionThatUsesStackmap() {
186     Module = LLVMModuleCreateWithName("simple_module");
187 
188     LLVMSetTarget(Module, HostTriple.c_str());
189 
190     LLVMTypeRef stackmapParamTypes[] = { LLVMInt64Type(), LLVMInt32Type() };
191     LLVMValueRef stackmap = LLVMAddFunction(
192       Module, "llvm.experimental.stackmap",
193       LLVMFunctionType(LLVMVoidType(), stackmapParamTypes, 2, 1));
194     LLVMSetLinkage(stackmap, LLVMExternalLinkage);
195 
196     Function = LLVMAddFunction(Module, "simple_function",
197                               LLVMFunctionType(LLVMInt32Type(), nullptr, 0, 0));
198 
199     LLVMBasicBlockRef entry = LLVMAppendBasicBlock(Function, "entry");
200     LLVMBuilderRef builder = LLVMCreateBuilder();
201     LLVMPositionBuilderAtEnd(builder, entry);
202     LLVMValueRef stackmapArgs[] = {
203       LLVMConstInt(LLVMInt64Type(), 0, 0), LLVMConstInt(LLVMInt32Type(), 5, 0),
204       LLVMConstInt(LLVMInt32Type(), 42, 0)
205     };
206     LLVMBuildCall(builder, stackmap, stackmapArgs, 3, "");
207     LLVMBuildRet(builder, LLVMConstInt(LLVMInt32Type(), 42, 0));
208 
209     LLVMVerifyModule(Module, LLVMAbortProcessAction, &Error);
210     LLVMDisposeMessage(Error);
211 
212     LLVMDisposeBuilder(builder);
213   }
214 
buildModuleWithCodeAndData()215   void buildModuleWithCodeAndData() {
216     Module = LLVMModuleCreateWithName("simple_module");
217 
218     LLVMSetTarget(Module, HostTriple.c_str());
219 
220     // build a global int32 variable initialized to 42.
221     LLVMValueRef GlobalVar = LLVMAddGlobal(Module, LLVMInt32Type(), "intVal");
222     LLVMSetInitializer(GlobalVar, LLVMConstInt(LLVMInt32Type(), 42, 0));
223 
224     {
225         Function = LLVMAddFunction(Module, "getGlobal",
226                               LLVMFunctionType(LLVMInt32Type(), nullptr, 0, 0));
227         LLVMSetFunctionCallConv(Function, LLVMCCallConv);
228 
229         LLVMBasicBlockRef Entry = LLVMAppendBasicBlock(Function, "entry");
230         LLVMBuilderRef Builder = LLVMCreateBuilder();
231         LLVMPositionBuilderAtEnd(Builder, Entry);
232 
233         LLVMValueRef IntVal = LLVMBuildLoad(Builder, GlobalVar, "intVal");
234         LLVMBuildRet(Builder, IntVal);
235 
236         LLVMVerifyModule(Module, LLVMAbortProcessAction, &Error);
237         LLVMDisposeMessage(Error);
238 
239         LLVMDisposeBuilder(Builder);
240     }
241 
242     {
243         LLVMTypeRef ParamTypes[] = { LLVMInt32Type() };
244         Function2 = LLVMAddFunction(
245           Module, "setGlobal", LLVMFunctionType(LLVMVoidType(), ParamTypes, 1, 0));
246         LLVMSetFunctionCallConv(Function2, LLVMCCallConv);
247 
248         LLVMBasicBlockRef Entry = LLVMAppendBasicBlock(Function2, "entry");
249         LLVMBuilderRef Builder = LLVMCreateBuilder();
250         LLVMPositionBuilderAtEnd(Builder, Entry);
251 
252         LLVMValueRef Arg = LLVMGetParam(Function2, 0);
253         LLVMBuildStore(Builder, Arg, GlobalVar);
254         LLVMBuildRetVoid(Builder);
255 
256         LLVMVerifyModule(Module, LLVMAbortProcessAction, &Error);
257         LLVMDisposeMessage(Error);
258 
259         LLVMDisposeBuilder(Builder);
260     }
261   }
262 
buildMCJITOptions()263   void buildMCJITOptions() {
264     LLVMInitializeMCJITCompilerOptions(&Options, sizeof(Options));
265     Options.OptLevel = 2;
266 
267     // Just ensure that this field still exists.
268     Options.NoFramePointerElim = false;
269   }
270 
useRoundTripSectionMemoryManager()271   void useRoundTripSectionMemoryManager() {
272     Options.MCJMM = LLVMCreateSimpleMCJITMemoryManager(
273       new SectionMemoryManager(),
274       roundTripAllocateCodeSection,
275       roundTripAllocateDataSection,
276       roundTripFinalizeMemory,
277       roundTripDestroy);
278   }
279 
buildMCJITEngine()280   void buildMCJITEngine() {
281     ASSERT_EQ(
282       0, LLVMCreateMCJITCompilerForModule(&Engine, Module, &Options,
283                                           sizeof(Options), &Error));
284   }
285 
buildAndRunPasses()286   void buildAndRunPasses() {
287     LLVMPassManagerRef pass = LLVMCreatePassManager();
288     LLVMAddConstantPropagationPass(pass);
289     LLVMAddInstructionCombiningPass(pass);
290     LLVMRunPassManager(pass, Module);
291     LLVMDisposePassManager(pass);
292   }
293 
buildAndRunOptPasses()294   void buildAndRunOptPasses() {
295     LLVMPassManagerBuilderRef passBuilder;
296 
297     passBuilder = LLVMPassManagerBuilderCreate();
298     LLVMPassManagerBuilderSetOptLevel(passBuilder, 2);
299     LLVMPassManagerBuilderSetSizeLevel(passBuilder, 0);
300 
301     LLVMPassManagerRef functionPasses =
302       LLVMCreateFunctionPassManagerForModule(Module);
303     LLVMPassManagerRef modulePasses =
304       LLVMCreatePassManager();
305 
306     LLVMPassManagerBuilderPopulateFunctionPassManager(passBuilder,
307                                                       functionPasses);
308     LLVMPassManagerBuilderPopulateModulePassManager(passBuilder, modulePasses);
309 
310     LLVMPassManagerBuilderDispose(passBuilder);
311 
312     LLVMInitializeFunctionPassManager(functionPasses);
313     for (LLVMValueRef value = LLVMGetFirstFunction(Module);
314          value; value = LLVMGetNextFunction(value))
315       LLVMRunFunctionPassManager(functionPasses, value);
316     LLVMFinalizeFunctionPassManager(functionPasses);
317 
318     LLVMRunPassManager(modulePasses, Module);
319 
320     LLVMDisposePassManager(functionPasses);
321     LLVMDisposePassManager(modulePasses);
322   }
323 
324   LLVMModuleRef Module;
325   LLVMValueRef Function;
326   LLVMValueRef Function2;
327   LLVMMCJITCompilerOptions Options;
328   LLVMExecutionEngineRef Engine;
329   char *Error;
330 };
331 } // end anonymous namespace
332 
TEST_F(MCJITCAPITest,simple_function)333 TEST_F(MCJITCAPITest, simple_function) {
334   SKIP_UNSUPPORTED_PLATFORM;
335 
336   buildSimpleFunction();
337   buildMCJITOptions();
338   buildMCJITEngine();
339   buildAndRunPasses();
340 
341   auto *functionPointer = reinterpret_cast<int (*)()>(
342       reinterpret_cast<uintptr_t>(LLVMGetPointerToGlobal(Engine, Function)));
343 
344   EXPECT_EQ(42, functionPointer());
345 }
346 
TEST_F(MCJITCAPITest,gva)347 TEST_F(MCJITCAPITest, gva) {
348   SKIP_UNSUPPORTED_PLATFORM;
349 
350   Module = LLVMModuleCreateWithName("simple_module");
351   LLVMSetTarget(Module, HostTriple.c_str());
352   LLVMValueRef GlobalVar = LLVMAddGlobal(Module, LLVMInt32Type(), "simple_value");
353   LLVMSetInitializer(GlobalVar, LLVMConstInt(LLVMInt32Type(), 42, 0));
354 
355   buildMCJITOptions();
356   buildMCJITEngine();
357   buildAndRunPasses();
358 
359   uint64_t raw = LLVMGetGlobalValueAddress(Engine, "simple_value");
360   int32_t *usable  = (int32_t *) raw;
361 
362   EXPECT_EQ(42, *usable);
363 }
364 
TEST_F(MCJITCAPITest,gfa)365 TEST_F(MCJITCAPITest, gfa) {
366   SKIP_UNSUPPORTED_PLATFORM;
367 
368   buildSimpleFunction();
369   buildMCJITOptions();
370   buildMCJITEngine();
371   buildAndRunPasses();
372 
373   uint64_t raw = LLVMGetFunctionAddress(Engine, "simple_function");
374   int (*usable)() = (int (*)()) raw;
375 
376   EXPECT_EQ(42, usable());
377 }
378 
TEST_F(MCJITCAPITest,custom_memory_manager)379 TEST_F(MCJITCAPITest, custom_memory_manager) {
380   SKIP_UNSUPPORTED_PLATFORM;
381 
382   buildSimpleFunction();
383   buildMCJITOptions();
384   useRoundTripSectionMemoryManager();
385   buildMCJITEngine();
386   buildAndRunPasses();
387 
388   auto *functionPointer = reinterpret_cast<int (*)()>(
389       reinterpret_cast<uintptr_t>(LLVMGetPointerToGlobal(Engine, Function)));
390 
391   EXPECT_EQ(42, functionPointer());
392   EXPECT_TRUE(didCallAllocateCodeSection);
393 }
394 
TEST_F(MCJITCAPITest,stackmap_creates_compact_unwind_on_darwin)395 TEST_F(MCJITCAPITest, stackmap_creates_compact_unwind_on_darwin) {
396   SKIP_UNSUPPORTED_PLATFORM;
397 
398   // This test is also not supported on non-x86 platforms.
399   if (Triple(HostTriple).getArch() != Triple::x86_64)
400     return;
401 
402   buildFunctionThatUsesStackmap();
403   buildMCJITOptions();
404   useRoundTripSectionMemoryManager();
405   buildMCJITEngine();
406   buildAndRunOptPasses();
407 
408   auto *functionPointer = reinterpret_cast<int (*)()>(
409       reinterpret_cast<uintptr_t>(LLVMGetPointerToGlobal(Engine, Function)));
410 
411   EXPECT_EQ(42, functionPointer());
412   EXPECT_TRUE(didCallAllocateCodeSection);
413 
414   // Up to this point, the test is specific only to X86-64. But this next
415   // expectation is only valid on Darwin because it assumes that unwind
416   // data is made available only through compact_unwind. It would be
417   // worthwhile to extend this to handle non-Darwin platforms, in which
418   // case you'd want to look for an eh_frame or something.
419   //
420   // FIXME: Currently, MCJIT relies on a configure-time check to determine which
421   // sections to emit. The JIT client should have runtime control over this.
422   EXPECT_TRUE(
423     Triple(HostTriple).getOS() != Triple::Darwin ||
424     Triple(HostTriple).isMacOSXVersionLT(10, 7) ||
425     didAllocateCompactUnwindSection);
426 }
427 
TEST_F(MCJITCAPITest,reserve_allocation_space)428 TEST_F(MCJITCAPITest, reserve_allocation_space) {
429   SKIP_UNSUPPORTED_PLATFORM;
430 
431   TestReserveAllocationSpaceMemoryManager* MM = new TestReserveAllocationSpaceMemoryManager();
432 
433   buildModuleWithCodeAndData();
434   buildMCJITOptions();
435   Options.MCJMM = wrap(MM);
436   buildMCJITEngine();
437   buildAndRunPasses();
438 
439   auto GetGlobalFct = reinterpret_cast<int (*)()>(
440       reinterpret_cast<uintptr_t>(LLVMGetPointerToGlobal(Engine, Function)));
441 
442   auto SetGlobalFct = reinterpret_cast<void (*)(int)>(
443       reinterpret_cast<uintptr_t>(LLVMGetPointerToGlobal(Engine, Function2)));
444 
445   SetGlobalFct(789);
446   EXPECT_EQ(789, GetGlobalFct());
447   EXPECT_LE(MM->UsedCodeSize, MM->ReservedCodeSize);
448   EXPECT_LE(MM->UsedDataSizeRO, MM->ReservedDataSizeRO);
449   EXPECT_LE(MM->UsedDataSizeRW, MM->ReservedDataSizeRW);
450   EXPECT_TRUE(MM->UsedCodeSize > 0);
451   EXPECT_TRUE(MM->UsedDataSizeRW > 0);
452 }
453 
TEST_F(MCJITCAPITest,yield)454 TEST_F(MCJITCAPITest, yield) {
455   SKIP_UNSUPPORTED_PLATFORM;
456 
457   buildSimpleFunction();
458   buildMCJITOptions();
459   buildMCJITEngine();
460   LLVMContextRef C = LLVMGetGlobalContext();
461   LLVMContextSetYieldCallback(C, yield, nullptr);
462   buildAndRunPasses();
463 
464   auto *functionPointer = reinterpret_cast<int (*)()>(
465       reinterpret_cast<uintptr_t>(LLVMGetPointerToGlobal(Engine, Function)));
466 
467   EXPECT_EQ(42, functionPointer());
468   EXPECT_TRUE(didCallYield);
469 }
470 
localTestFunc()471 static int localTestFunc() {
472   return 42;
473 }
474 
TEST_F(MCJITCAPITest,addGlobalMapping)475 TEST_F(MCJITCAPITest, addGlobalMapping) {
476   SKIP_UNSUPPORTED_PLATFORM;
477 
478   Module = LLVMModuleCreateWithName("testModule");
479   LLVMSetTarget(Module, HostTriple.c_str());
480   LLVMTypeRef FunctionType = LLVMFunctionType(LLVMInt32Type(), nullptr, 0, 0);
481   LLVMValueRef MappedFn = LLVMAddFunction(Module, "mapped_fn", FunctionType);
482 
483   Function = LLVMAddFunction(Module, "test_fn", FunctionType);
484   LLVMBasicBlockRef Entry = LLVMAppendBasicBlock(Function, "");
485   LLVMBuilderRef Builder = LLVMCreateBuilder();
486   LLVMPositionBuilderAtEnd(Builder, Entry);
487   LLVMValueRef RetVal = LLVMBuildCall(Builder, MappedFn, nullptr, 0, "");
488   LLVMBuildRet(Builder, RetVal);
489   LLVMDisposeBuilder(Builder);
490 
491   LLVMVerifyModule(Module, LLVMAbortProcessAction, &Error);
492   LLVMDisposeMessage(Error);
493 
494   buildMCJITOptions();
495   buildMCJITEngine();
496 
497   LLVMAddGlobalMapping(
498       Engine, MappedFn,
499       reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(&localTestFunc)));
500 
501   buildAndRunPasses();
502 
503   uint64_t raw = LLVMGetFunctionAddress(Engine, "test_fn");
504   int (*usable)() = (int (*)()) raw;
505 
506   EXPECT_EQ(42, usable());
507 }
508