unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

   1 //===- MCJITTest.cpp - Unit tests for the MCJIT ---------------------------===//
   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 "llvm-c/Core.h"
  17 #include "llvm-c/ExecutionEngine.h"
  18 #include "llvm-c/Target.h"
  19 #include "llvm-c/Transforms/Scalar.h"
  20 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
  21 #include "llvm/Support/Host.h"
  22 #include "MCJITTestAPICommon.h"
  23 #include "gtest/gtest.h"
  24
  25 using namespace llvm;
  26
  27 static bool didCallAllocateCodeSection;
  28
  29 static uint8_t *roundTripAllocateCodeSection(void *object, uintptr_t size,
  30                                              unsigned alignment,
  31                                              unsigned sectionID) {
  32   didCallAllocateCodeSection = true;
  33   return static_cast<SectionMemoryManager*>(object)->allocateCodeSection(
  34     size, alignment, sectionID);
  35 }
  36
  37 static uint8_t *roundTripAllocateDataSection(void *object, uintptr_t size,
  38                                              unsigned alignment,
  39                                              unsigned sectionID,
  40                                              LLVMBool isReadOnly) {
  41   return static_cast<SectionMemoryManager*>(object)->allocateDataSection(
  42     size, alignment, sectionID, isReadOnly);
  43 }
  44
  45 static LLVMBool roundTripFinalizeMemory(void *object, char **errMsg) {
  46   std::string errMsgString;
  47   bool result =
  48     static_cast<SectionMemoryManager*>(object)->finalizeMemory(&errMsgString);
  49   if (result) {
  50     *errMsg = LLVMCreateMessage(errMsgString.c_str());
  51     return 1;
  52   }
  53   return 0;
  54 }
  55
  56 static void roundTripDestroy(void *object) {
  57   delete static_cast<SectionMemoryManager*>(object);
  58 }
  59
  60 class MCJITCAPITest : public testing::Test, public MCJITTestAPICommon {
  61 protected:
  62   MCJITCAPITest() {
  63     // The architectures below are known to be compatible with MCJIT as they
  64     // are copied from test/ExecutionEngine/MCJIT/lit.local.cfg and should be
  65     // kept in sync.
  66     SupportedArchs.push_back(Triple::aarch64);
  67     SupportedArchs.push_back(Triple::arm);
  68     SupportedArchs.push_back(Triple::mips);
  69     SupportedArchs.push_back(Triple::x86);
  70     SupportedArchs.push_back(Triple::x86_64);
  71
  72     // Some architectures have sub-architectures in which tests will fail, like
  73     // ARM. These two vectors will define if they do have sub-archs (to avoid
  74     // extra work for those who don't), and if so, if they are listed to work
  75     HasSubArchs.push_back(Triple::arm);
  76     SupportedSubArchs.push_back("armv6");
  77     SupportedSubArchs.push_back("armv7");
  78
  79     // The operating systems below are known to be sufficiently incompatible
  80     // that they will fail the MCJIT C API tests.
  81     UnsupportedOSs.push_back(Triple::Cygwin);
  82   }
  83
  84   virtual void SetUp() {
  85     didCallAllocateCodeSection = false;
  86     Module = 0;
  87     Function = 0;
  88     Engine = 0;
  89     Error = 0;
  90   }
  91
  92   virtual void TearDown() {
  93     if (Engine)
  94       LLVMDisposeExecutionEngine(Engine);
  95     else if (Module)
  96       LLVMDisposeModule(Module);
  97   }
  98
  99   void buildSimpleFunction() {
 100     Module = LLVMModuleCreateWithName("simple_module");
 101
 102     LLVMSetTarget(Module, HostTriple.c_str());
 103
 104     Function = LLVMAddFunction(
 105       Module, "simple_function", LLVMFunctionType(LLVMInt32Type(), 0, 0, 0));
 106     LLVMSetFunctionCallConv(Function, LLVMCCallConv);
 107
 108     LLVMBasicBlockRef entry = LLVMAppendBasicBlock(Function, "entry");
 109     LLVMBuilderRef builder = LLVMCreateBuilder();
 110     LLVMPositionBuilderAtEnd(builder, entry);
 111     LLVMBuildRet(builder, LLVMConstInt(LLVMInt32Type(), 42, 0));
 112
 113     LLVMVerifyModule(Module, LLVMAbortProcessAction, &Error);
 114     LLVMDisposeMessage(Error);
 115
 116     LLVMDisposeBuilder(builder);
 117   }
 118
 119   void buildMCJITOptions() {
 120     LLVMInitializeMCJITCompilerOptions(&Options, sizeof(Options));
 121     Options.OptLevel = 2;
 122
 123     // Just ensure that this field still exists.
 124     Options.NoFramePointerElim = false;
 125   }
 126
 127   void useRoundTripSectionMemoryManager() {
 128     Options.MCJMM = LLVMCreateSimpleMCJITMemoryManager(
 129       new SectionMemoryManager(),
 130       roundTripAllocateCodeSection,
 131       roundTripAllocateDataSection,
 132       roundTripFinalizeMemory,
 133       roundTripDestroy);
 134   }
 135
 136   void buildMCJITEngine() {
 137     ASSERT_EQ(
 138       0, LLVMCreateMCJITCompilerForModule(&Engine, Module, &Options,
 139                                           sizeof(Options), &Error));
 140   }
 141
 142   void buildAndRunPasses() {
 143     LLVMPassManagerRef pass = LLVMCreatePassManager();
 144     LLVMAddTargetData(LLVMGetExecutionEngineTargetData(Engine), pass);
 145     LLVMAddConstantPropagationPass(pass);
 146     LLVMAddInstructionCombiningPass(pass);
 147     LLVMRunPassManager(pass, Module);
 148     LLVMDisposePassManager(pass);
 149   }
 150
 151   LLVMModuleRef Module;
 152   LLVMValueRef Function;
 153   LLVMMCJITCompilerOptions Options;
 154   LLVMExecutionEngineRef Engine;
 155   char *Error;
 156 };
 157
 158 TEST_F(MCJITCAPITest, simple_function) {
 159   SKIP_UNSUPPORTED_PLATFORM;
 160
 161   buildSimpleFunction();
 162   buildMCJITOptions();
 163   buildMCJITEngine();
 164   buildAndRunPasses();
 165
 166   union {
 167     void *raw;
 168     int (*usable)();
 169   } functionPointer;
 170   functionPointer.raw = LLVMGetPointerToGlobal(Engine, Function);
 171
 172   EXPECT_EQ(42, functionPointer.usable());
 173 }
 174
 175 TEST_F(MCJITCAPITest, custom_memory_manager) {
 176   SKIP_UNSUPPORTED_PLATFORM;
 177
 178   buildSimpleFunction();
 179   buildMCJITOptions();
 180   useRoundTripSectionMemoryManager();
 181   buildMCJITEngine();
 182   buildAndRunPasses();
 183
 184   union {
 185     void *raw;
 186     int (*usable)();
 187   } functionPointer;
 188   functionPointer.raw = LLVMGetPointerToGlobal(Engine, Function);
 189
 190   EXPECT_EQ(42, functionPointer.usable());
 191   EXPECT_TRUE(didCallAllocateCodeSection);
 192 }