unittests/ExecutionEngine/JIT/JITTest.cpp

   1 //===- JITTest.cpp - Unit tests for the JIT -------------------------------===//
   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 #include "gtest/gtest.h"
  11 #include "llvm/ADT/OwningPtr.h"
  12 #include "llvm/BasicBlock.h"
  13 #include "llvm/Constant.h"
  14 #include "llvm/Constants.h"
  15 #include "llvm/DerivedTypes.h"
  16 #include "llvm/ExecutionEngine/JIT.h"
  17 #include "llvm/ExecutionEngine/JITMemoryManager.h"
  18 #include "llvm/Function.h"
  19 #include "llvm/GlobalValue.h"
  20 #include "llvm/GlobalVariable.h"
  21 #include "llvm/LLVMContext.h"
  22 #include "llvm/Module.h"
  23 #include "llvm/ModuleProvider.h"
  24 #include "llvm/Support/IRBuilder.h"
  25 #include "llvm/Support/TypeBuilder.h"
  26 #include "llvm/Target/TargetSelect.h"
  27 #include "llvm/Type.h"
  28
  29 using namespace llvm;
  30
  31 namespace {
  32
  33 Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
  34   std::vector<const Type*> params;
  35   const FunctionType *FTy = FunctionType::get(G->getType()->getElementType(),
  36                                               params, false);
  37   Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
  38   BasicBlock *Entry = BasicBlock::Create(M->getContext(), "entry", F);
  39   IRBuilder<> builder(Entry);
  40   Value *Load = builder.CreateLoad(G);
  41   const Type *GTy = G->getType()->getElementType();
  42   Value *Add = builder.CreateAdd(Load, ConstantInt::get(GTy, 1LL));
  43   builder.CreateStore(Add, G);
  44   builder.CreateRet(Add);
  45   return F;
  46 }
  47
  48 class JITTest : public testing::Test {
  49  protected:
  50   virtual void SetUp() {
  51     M = new Module("<main>", Context);
  52     std::string Error;
  53     TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT)
  54                  .setErrorStr(&Error).create());
  55     ASSERT_TRUE(TheJIT.get() != NULL) << Error;
  56   }
  57
  58   LLVMContext Context;
  59   Module *M;  // Owned by ExecutionEngine.
  60   OwningPtr<ExecutionEngine> TheJIT;
  61 };
  62
  63 // Regression test for a bug.  The JIT used to allocate globals inside the same
  64 // memory block used for the function, and when the function code was freed,
  65 // the global was left in the same place.  This test allocates a function
  66 // that uses and global, deallocates it, and then makes sure that the global
  67 // stays alive after that.
  68 TEST(JIT, GlobalInFunction) {
  69   LLVMContext context;
  70   Module *M = new Module("<main>", context);
  71   ExistingModuleProvider *MP = new ExistingModuleProvider(M);
  72
  73   JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
  74   // Tell the memory manager to poison freed memory so that accessing freed
  75   // memory is more easily tested.
  76   MemMgr->setPoisonMemory(true);
  77   std::string Error;
  78   OwningPtr<ExecutionEngine> JIT(EngineBuilder(MP)
  79                                  .setEngineKind(EngineKind::JIT)
  80                                  .setErrorStr(&Error)
  81                                  .setJITMemoryManager(MemMgr)
  82                                  // The next line enables the fix:
  83                                  .setAllocateGVsWithCode(false)
  84                                  .create());
  85   ASSERT_EQ(Error, "");
  86
  87   // Create a global variable.
  88   const Type *GTy = Type::getInt32Ty(context);
  89   GlobalVariable *G = new GlobalVariable(
  90       *M,
  91       GTy,
  92       false,  // Not constant.
  93       GlobalValue::InternalLinkage,
  94       Constant::getNullValue(GTy),
  95       "myglobal");
  96
  97   // Make a function that points to a global.
  98   Function *F1 = makeReturnGlobal("F1", G, M);
  99
 100   // Get the pointer to the native code to force it to JIT the function and
 101   // allocate space for the global.
 102   void (*F1Ptr)();
 103   // Hack to avoid ISO C++ warning about casting function pointers.
 104   *(void**)(void*)&F1Ptr = JIT->getPointerToFunction(F1);
 105
 106   // Since F1 was codegen'd, a pointer to G should be available.
 107   int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
 108   ASSERT_NE((int32_t*)NULL, GPtr);
 109   EXPECT_EQ(0, *GPtr);
 110
 111   // F1() should increment G.
 112   F1Ptr();
 113   EXPECT_EQ(1, *GPtr);
 114
 115   // Make a second function identical to the first, referring to the same
 116   // global.
 117   Function *F2 = makeReturnGlobal("F2", G, M);
 118   // Hack to avoid ISO C++ warning about casting function pointers.
 119   void (*F2Ptr)();
 120   *(void**)(void*)&F2Ptr = JIT->getPointerToFunction(F2);
 121
 122   // F2() should increment G.
 123   F2Ptr();
 124   EXPECT_EQ(2, *GPtr);
 125
 126   // Deallocate F1.
 127   JIT->freeMachineCodeForFunction(F1);
 128
 129   // F2() should *still* increment G.
 130   F2Ptr();
 131   EXPECT_EQ(3, *GPtr);
 132 }
 133
 134 int PlusOne(int arg) {
 135   return arg + 1;
 136 }
 137
 138 TEST_F(JITTest, FarCallToKnownFunction) {
 139   // x86-64 can only make direct calls to functions within 32 bits of
 140   // the current PC.  To call anything farther away, we have to load
 141   // the address into a register and call through the register.  The
 142   // current JIT does this by allocating a stub for any far call.
 143   // There was a bug in which the JIT tried to emit a direct call when
 144   // the target was already in the JIT's global mappings and lazy
 145   // compilation was disabled.
 146
 147   Function *KnownFunction = Function::Create(
 148       TypeBuilder<int(int), false>::get(Context),
 149       GlobalValue::ExternalLinkage, "known", M);
 150   TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne);
 151
 152   // int test() { return known(7); }
 153   Function *TestFunction = Function::Create(
 154       TypeBuilder<int(), false>::get(Context),
 155       GlobalValue::ExternalLinkage, "test", M);
 156   BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction);
 157   IRBuilder<> Builder(Entry);
 158   Value *result = Builder.CreateCall(
 159       KnownFunction,
 160       ConstantInt::get(TypeBuilder<int, false>::get(Context), 7));
 161   Builder.CreateRet(result);
 162
 163   TheJIT->EnableDlsymStubs(false);
 164   TheJIT->DisableLazyCompilation();
 165   int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>(
 166       (intptr_t)TheJIT->getPointerToFunction(TestFunction));
 167   // This used to crash in trying to call PlusOne().
 168   EXPECT_EQ(8, TestFunctionPtr());
 169 }
 170
 171 // This code is copied from JITEventListenerTest, but it only runs once for all
 172 // the tests in this directory.  Everything seems fine, but that's strange
 173 // behavior.
 174 class JITEnvironment : public testing::Environment {
 175   virtual void SetUp() {
 176     // Required to create a JIT.
 177     InitializeNativeTarget();
 178   }
 179 };
 180 testing::Environment* const jit_env =
 181   testing::AddGlobalTestEnvironment(new JITEnvironment);
 182
 183 }