unittests/Linker/LinkModulesTest.cpp

   1 //===- llvm/unittest/Linker/LinkModulesTest.cpp - IRBuilder tests ---------===//
   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 "llvm/Linker.h"
  11 #include "llvm/IR/IRBuilder.h"
  12 #include "llvm/IR/BasicBlock.h"
  13 #include "llvm/IR/DataLayout.h"
  14 #include "llvm/IR/Function.h"
  15 #include "llvm/IR/Module.h"
  16 #include "gtest/gtest.h"
  17
  18 using namespace llvm;
  19
  20 namespace {
  21
  22 class LinkModuleTest : public testing::Test {
  23 protected:
  24   virtual void SetUp() {
  25     LLVMContext &Ctx = getGlobalContext();
  26     M.reset(new Module("MyModule", Ctx));
  27     FunctionType *FTy = FunctionType::get(Type::getInt8PtrTy(Ctx),
  28                                           Type::getInt32Ty(Ctx),
  29                                           false /*=isVarArg*/);
  30     F = Function::Create(FTy, Function::ExternalLinkage, "ba_func", M.get());
  31     F->setCallingConv(CallingConv::C);
  32
  33     EntryBB = BasicBlock::Create(Ctx, "entry", F);
  34     SwitchCase1BB = BasicBlock::Create(Ctx, "switch.case.1", F);
  35     SwitchCase2BB = BasicBlock::Create(Ctx, "switch.case.2", F);
  36     ExitBB = BasicBlock::Create(Ctx, "exit", F);
  37
  38     ArrayType *AT = ArrayType::get(Type::getInt8PtrTy(Ctx), 3);
  39
  40     GV = new GlobalVariable(*M.get(), AT, false /*=isConstant*/,
  41                             GlobalValue::InternalLinkage,
  42                             0, "switch.bas");
  43
  44
  45     // Global Initializer
  46     std::vector<Constant*> Init;
  47     Constant *SwitchCase1BA = BlockAddress::get(SwitchCase1BB);
  48     Init.push_back(SwitchCase1BA);
  49
  50     Constant *SwitchCase2BA = BlockAddress::get(SwitchCase2BB);
  51     Init.push_back(SwitchCase2BA);
  52
  53     ConstantInt *One = ConstantInt::get(Type::getInt32Ty(Ctx), 1);
  54     Constant *OnePtr = ConstantExpr::getCast(Instruction::IntToPtr,
  55                                              One, Type::getInt8PtrTy(Ctx));
  56     Init.push_back(OnePtr);
  57
  58     GV->setInitializer(ConstantArray::get(AT, Init));
  59   }
  60
  61   virtual void TearDown() {
  62     M.reset();
  63   }
  64
  65   OwningPtr<Module> M;
  66   Function *F;
  67   GlobalVariable *GV;
  68   BasicBlock *EntryBB;
  69   BasicBlock *SwitchCase1BB;
  70   BasicBlock *SwitchCase2BB;
  71   BasicBlock *ExitBB;
  72 };
  73
  74 TEST_F(LinkModuleTest, BlockAddress) {
  75   LLVMContext &Ctx = getGlobalContext();
  76   IRBuilder<> Builder(EntryBB);
  77
  78   std::vector<Value*> GEPIndices;
  79   GEPIndices.push_back(ConstantInt::get(Type::getInt32Ty(Ctx), 0));
  80   GEPIndices.push_back(F->arg_begin());
  81
  82   Value *GEP = Builder.CreateGEP(GV, GEPIndices, "switch.gep");
  83   Value *Load = Builder.CreateLoad(GEP, "switch.load");
  84
  85   Builder.CreateRet(Load);
  86
  87   Builder.SetInsertPoint(SwitchCase1BB);
  88   Builder.CreateBr(ExitBB);
  89
  90   Builder.SetInsertPoint(SwitchCase2BB);
  91   Builder.CreateBr(ExitBB);
  92
  93   Builder.SetInsertPoint(ExitBB);
  94   Builder.CreateRet(ConstantPointerNull::get(Type::getInt8PtrTy(Ctx)));
  95
  96   Module *LinkedModule = new Module("MyModuleLinked", getGlobalContext());
  97   Linker::LinkModules(LinkedModule, M.get(), Linker::PreserveSource, 0);
  98
  99   // Delete the original module.
 100   M.reset();
 101
 102   // Check that the global "@switch.bas" is well-formed.
 103   const GlobalVariable *LinkedGV = LinkedModule->getNamedGlobal("switch.bas");
 104   const Constant *Init = LinkedGV->getInitializer();
 105
 106   // @switch.bas = internal global [3 x i8*]
 107   //   [i8* blockaddress(@ba_func, %switch.case.1),
 108   //    i8* blockaddress(@ba_func, %switch.case.2),
 109   //    i8* inttoptr (i32 1 to i8*)]
 110
 111   ArrayType *AT = ArrayType::get(Type::getInt8PtrTy(Ctx), 3);
 112   EXPECT_EQ(AT, Init->getType());
 113
 114   Value *Elem = Init->getOperand(0);
 115   ASSERT_TRUE(isa<BlockAddress>(Elem));
 116   EXPECT_EQ(cast<BlockAddress>(Elem)->getFunction(),
 117             LinkedModule->getFunction("ba_func"));
 118   EXPECT_EQ(cast<BlockAddress>(Elem)->getBasicBlock()->getParent(),
 119             LinkedModule->getFunction("ba_func"));
 120
 121   Elem = Init->getOperand(1);
 122   ASSERT_TRUE(isa<BlockAddress>(Elem));
 123   EXPECT_EQ(cast<BlockAddress>(Elem)->getFunction(),
 124             LinkedModule->getFunction("ba_func"));
 125   EXPECT_EQ(cast<BlockAddress>(Elem)->getBasicBlock()->getParent(),
 126             LinkedModule->getFunction("ba_func"));
 127
 128   delete LinkedModule;
 129 }
 130
 131 TEST_F(LinkModuleTest, EmptyModule) {
 132   LLVMContext &Ctx = getGlobalContext();
 133   Module *InternalM = new Module("InternalModule", Ctx);
 134   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
 135                                         Type::getInt8PtrTy(Ctx),
 136                                         false /*=isVarArgs*/);
 137
 138   F = Function::Create(FTy, Function::InternalLinkage, "bar", InternalM);
 139   F->setCallingConv(CallingConv::C);
 140
 141   BasicBlock *BB = BasicBlock::Create(Ctx, "", F);
 142   IRBuilder<> Builder(BB);
 143   Builder.CreateRetVoid();
 144
 145   StructType *STy = StructType::create(Ctx, PointerType::get(FTy, 0));
 146
 147   GlobalVariable *GV =
 148     new GlobalVariable(*InternalM, STy, false /*=isConstant*/,
 149                        GlobalValue::InternalLinkage, 0, "g");
 150
 151   GV->setInitializer(ConstantStruct::get(STy, F));
 152
 153
 154   Module *EmptyM = new Module("EmptyModule1", Ctx);
 155   Linker::LinkModules(EmptyM, InternalM, Linker::PreserveSource, 0);
 156
 157   delete EmptyM;
 158   EmptyM = new Module("EmptyModule2", Ctx);
 159   Linker::LinkModules(InternalM, EmptyM, Linker::PreserveSource, 0);
 160
 161   delete EmptyM;
 162   delete InternalM;
 163 }
 164
 165 } // end anonymous namespace