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