unittests/ExecutionEngine/JIT/JITTest.cpp

   1 //===- JITEmitter.cpp - Unit tests for the JIT code emitter ---------------===//
   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/Module.h"
  22 #include "llvm/ModuleProvider.h"
  23 #include "llvm/Support/IRBuilder.h"
  24 #include "llvm/Target/TargetSelect.h"
  25 #include "llvm/Type.h"
  26
  27 using namespace llvm;
  28
  29 namespace {
  30
  31 Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
  32   std::vector<const Type*> params;
  33   const FunctionType *FTy =
  34     getGlobalContext().getFunctionType(G->getType()->getElementType(),
  35                                               params, false);
  36   Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
  37   BasicBlock *Entry = BasicBlock::Create("entry", F);
  38   IRBuilder<> builder(Entry);
  39   Value *Load = builder.CreateLoad(G);
  40   const Type *GTy = G->getType()->getElementType();
  41   Value *Add = builder.CreateAdd(Load,
  42     getGlobalContext().getConstantInt(GTy, 1LL));
  43   builder.CreateStore(Add, G);
  44   builder.CreateRet(Add);
  45   return F;
  46 }
  47
  48 // Regression test for a bug.  The JIT used to allocate globals inside the same
  49 // memory block used for the function, and when the function code was freed,
  50 // the global was left in the same place.  This test allocates a function
  51 // that uses and global, deallocates it, and then makes sure that the global
  52 // stays alive after that.
  53 TEST(JIT, GlobalInFunction) {
  54   LLVMContext context;
  55   Module *M = new Module("<main>", context);
  56   ExistingModuleProvider *MP = new ExistingModuleProvider(M);
  57
  58   JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
  59   // Tell the memory manager to poison freed memory so that accessing freed
  60   // memory is more easily tested.
  61   MemMgr->setPoisonMemory(true);
  62   std::string Error;
  63   OwningPtr<ExecutionEngine> JIT(ExecutionEngine::createJIT(
  64       MP,
  65       &Error,
  66       MemMgr,
  67       CodeGenOpt::Default,
  68       false));  // This last argument enables the fix.
  69   ASSERT_EQ(Error, "");
  70
  71   // Create a global variable.
  72   const Type *GTy = Type::Int32Ty;
  73   GlobalVariable *G = new GlobalVariable(
  74       *M,
  75       GTy,
  76       false,  // Not constant.
  77       GlobalValue::InternalLinkage,
  78       context.getNullValue(GTy),
  79       "myglobal");
  80
  81   // Make a function that points to a global.
  82   Function *F1 = makeReturnGlobal("F1", G, M);
  83
  84   // Get the pointer to the native code to force it to JIT the function and
  85   // allocate space for the global.
  86   void (*F1Ptr)();
  87   // Hack to avoid ISO C++ warning about casting function pointers.
  88   *(void**)(void*)&F1Ptr = JIT->getPointerToFunction(F1);
  89
  90   // Since F1 was codegen'd, a pointer to G should be available.
  91   int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
  92   ASSERT_NE((int32_t*)NULL, GPtr);
  93   EXPECT_EQ(0, *GPtr);
  94
  95   // F1() should increment G.
  96   F1Ptr();
  97   EXPECT_EQ(1, *GPtr);
  98
  99   // Make a second function identical to the first, referring to the same
 100   // global.
 101   Function *F2 = makeReturnGlobal("F2", G, M);
 102   // Hack to avoid ISO C++ warning about casting function pointers.
 103   void (*F2Ptr)();
 104   *(void**)(void*)&F2Ptr = JIT->getPointerToFunction(F2);
 105
 106   // F2() should increment G.
 107   F2Ptr();
 108   EXPECT_EQ(2, *GPtr);
 109
 110   // Deallocate F1.
 111   JIT->freeMachineCodeForFunction(F1);
 112
 113   // F2() should *still* increment G.
 114   F2Ptr();
 115   EXPECT_EQ(3, *GPtr);
 116 }
 117
 118 // TODO(rnk): This seems to only run once for both tests, which is unexpected.
 119 // That works just fine, but we shouldn't duplicate the code.
 120 class JITEnvironment : public testing::Environment {
 121   virtual void SetUp() {
 122     // Required for ExecutionEngine::createJIT to create a JIT.
 123     InitializeNativeTarget();
 124   }
 125 };
 126 testing::Environment* const jit_env =
 127   testing::AddGlobalTestEnvironment(new JITEnvironment);
 128
 129 }