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       reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F1));
 104
 105   // Since F1 was codegen'd, a pointer to G should be available.
 106   int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
 107   ASSERT_NE((int32_t*)NULL, GPtr);
 108   EXPECT_EQ(0, *GPtr);
 109
 110   // F1() should increment G.
 111   F1Ptr();
 112   EXPECT_EQ(1, *GPtr);
 113
 114   // Make a second function identical to the first, referring to the same
 115   // global.
 116   Function *F2 = makeReturnGlobal("F2", G, M);
 117   void (*F2Ptr)() =
 118       reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F2));
 119
 120   // F2() should increment G.
 121   F2Ptr();
 122   EXPECT_EQ(2, *GPtr);
 123
 124   // Deallocate F1.
 125   JIT->freeMachineCodeForFunction(F1);
 126
 127   // F2() should *still* increment G.
 128   F2Ptr();
 129   EXPECT_EQ(3, *GPtr);
 130 }
 131
 132 int PlusOne(int arg) {
 133   return arg + 1;
 134 }
 135
 136 TEST_F(JITTest, FarCallToKnownFunction) {
 137   // x86-64 can only make direct calls to functions within 32 bits of
 138   // the current PC.  To call anything farther away, we have to load
 139   // the address into a register and call through the register.  The
 140   // current JIT does this by allocating a stub for any far call.
 141   // There was a bug in which the JIT tried to emit a direct call when
 142   // the target was already in the JIT's global mappings and lazy
 143   // compilation was disabled.
 144
 145   Function *KnownFunction = Function::Create(
 146       TypeBuilder<int(int), false>::get(Context),
 147       GlobalValue::ExternalLinkage, "known", M);
 148   TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne);
 149
 150   // int test() { return known(7); }
 151   Function *TestFunction = Function::Create(
 152       TypeBuilder<int(), false>::get(Context),
 153       GlobalValue::ExternalLinkage, "test", M);
 154   BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction);
 155   IRBuilder<> Builder(Entry);
 156   Value *result = Builder.CreateCall(
 157       KnownFunction,
 158       ConstantInt::get(TypeBuilder<int, false>::get(Context), 7));
 159   Builder.CreateRet(result);
 160
 161   TheJIT->EnableDlsymStubs(false);
 162   TheJIT->DisableLazyCompilation();
 163   int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>(
 164       (intptr_t)TheJIT->getPointerToFunction(TestFunction));
 165   // This used to crash in trying to call PlusOne().
 166   EXPECT_EQ(8, TestFunctionPtr());
 167 }
 168
 169 // Test a function C which calls A and B which call each other.
 170 TEST_F(JITTest, NonLazyCompilationStillNeedsStubs) {
 171   TheJIT->DisableLazyCompilation();
 172
 173   const FunctionType *Func1Ty =
 174       cast<FunctionType>(TypeBuilder<void(void), false>::get(Context));
 175   std::vector<const Type*> arg_types;
 176   arg_types.push_back(Type::getInt1Ty(Context));
 177   const FunctionType *FuncTy = FunctionType::get(
 178       Type::getVoidTy(Context), arg_types, false);
 179   Function *Func1 = Function::Create(Func1Ty, Function::ExternalLinkage,
 180                                      "func1", M);
 181   Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
 182                                      "func2", M);
 183   Function *Func3 = Function::Create(FuncTy, Function::InternalLinkage,
 184                                      "func3", M);
 185   BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
 186   BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
 187   BasicBlock *True2 = BasicBlock::Create(Context, "cond_true", Func2);
 188   BasicBlock *False2 = BasicBlock::Create(Context, "cond_false", Func2);
 189   BasicBlock *Block3 = BasicBlock::Create(Context, "block3", Func3);
 190   BasicBlock *True3 = BasicBlock::Create(Context, "cond_true", Func3);
 191   BasicBlock *False3 = BasicBlock::Create(Context, "cond_false", Func3);
 192
 193   // Make Func1 call Func2(0) and Func3(0).
 194   IRBuilder<> Builder(Block1);
 195   Builder.CreateCall(Func2, ConstantInt::getTrue(Context));
 196   Builder.CreateCall(Func3, ConstantInt::getTrue(Context));
 197   Builder.CreateRetVoid();
 198
 199   // void Func2(bool b) { if (b) { Func3(false); return; } return; }
 200   Builder.SetInsertPoint(Block2);
 201   Builder.CreateCondBr(Func2->arg_begin(), True2, False2);
 202   Builder.SetInsertPoint(True2);
 203   Builder.CreateCall(Func3, ConstantInt::getFalse(Context));
 204   Builder.CreateRetVoid();
 205   Builder.SetInsertPoint(False2);
 206   Builder.CreateRetVoid();
 207
 208   // void Func3(bool b) { if (b) { Func2(false); return; } return; }
 209   Builder.SetInsertPoint(Block3);
 210   Builder.CreateCondBr(Func3->arg_begin(), True3, False3);
 211   Builder.SetInsertPoint(True3);
 212   Builder.CreateCall(Func2, ConstantInt::getFalse(Context));
 213   Builder.CreateRetVoid();
 214   Builder.SetInsertPoint(False3);
 215   Builder.CreateRetVoid();
 216
 217   // Compile the function to native code
 218   void (*F1Ptr)() =
 219      reinterpret_cast<void(*)()>((intptr_t)TheJIT->getPointerToFunction(Func1));
 220
 221   F1Ptr();
 222 }
 223
 224 // Regression test for PR5162.  This used to trigger an AssertingVH inside the
 225 // JIT's Function to stub mapping.
 226 TEST_F(JITTest, NonLazyLeaksNoStubs) {
 227   TheJIT->DisableLazyCompilation();
 228
 229   // Create two functions with a single basic block each.
 230   const FunctionType *FuncTy =
 231       cast<FunctionType>(TypeBuilder<int(), false>::get(Context));
 232   Function *Func1 = Function::Create(FuncTy, Function::ExternalLinkage,
 233                                      "func1", M);
 234   Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
 235                                      "func2", M);
 236   BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
 237   BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
 238
 239   // The first function calls the second and returns the result
 240   IRBuilder<> Builder(Block1);
 241   Value *Result = Builder.CreateCall(Func2);
 242   Builder.CreateRet(Result);
 243
 244   // The second function just returns a constant
 245   Builder.SetInsertPoint(Block2);
 246   Builder.CreateRet(ConstantInt::get(TypeBuilder<int, false>::get(Context),42));
 247
 248   // Compile the function to native code
 249   (void)TheJIT->getPointerToFunction(Func1);
 250
 251   // Free the JIT state for the functions
 252   TheJIT->freeMachineCodeForFunction(Func1);
 253   TheJIT->freeMachineCodeForFunction(Func2);
 254
 255   // Delete the first function (and show that is has no users)
 256   EXPECT_EQ(Func1->getNumUses(), 0u);
 257   Func1->eraseFromParent();
 258
 259   // Delete the second function (and show that it has no users - it had one,
 260   // func1 but that's gone now)
 261   EXPECT_EQ(Func2->getNumUses(), 0u);
 262   Func2->eraseFromParent();
 263 }
 264
 265 // This code is copied from JITEventListenerTest, but it only runs once for all
 266 // the tests in this directory.  Everything seems fine, but that's strange
 267 // behavior.
 268 class JITEnvironment : public testing::Environment {
 269   virtual void SetUp() {
 270     // Required to create a JIT.
 271     InitializeNativeTarget();
 272   }
 273 };
 274 testing::Environment* const jit_env =
 275   testing::AddGlobalTestEnvironment(new JITEnvironment);
 276
 277 }