unittests/IR/IRBuilderTest.cpp

   1 //===- llvm/unittest/IR/IRBuilderTest.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/IR/IRBuilder.h"
  11 #include "llvm/IR/BasicBlock.h"
  12 #include "llvm/IR/DIBuilder.h"
  13 #include "llvm/IR/DataLayout.h"
  14 #include "llvm/IR/Function.h"
  15 #include "llvm/IR/IntrinsicInst.h"
  16 #include "llvm/IR/LLVMContext.h"
  17 #include "llvm/IR/MDBuilder.h"
  18 #include "llvm/IR/Module.h"
  19 #include "llvm/IR/NoFolder.h"
  20 #include "llvm/IR/Verifier.h"
  21 #include "gtest/gtest.h"
  22
  23 using namespace llvm;
  24
  25 namespace {
  26
  27 class IRBuilderTest : public testing::Test {
  28 protected:
  29   void SetUp() override {
  30     M.reset(new Module("MyModule", Ctx));
  31     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
  32                                           /*isVarArg=*/false);
  33     F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
  34     BB = BasicBlock::Create(Ctx, "", F);
  35     GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
  36                             GlobalValue::ExternalLinkage, nullptr);
  37   }
  38
  39   void TearDown() override {
  40     BB = nullptr;
  41     M.reset();
  42   }
  43
  44   LLVMContext Ctx;
  45   std::unique_ptr<Module> M;
  46   Function *F;
  47   BasicBlock *BB;
  48   GlobalVariable *GV;
  49 };
  50
  51 TEST_F(IRBuilderTest, Lifetime) {
  52   IRBuilder<> Builder(BB);
  53   AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
  54   AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
  55   AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
  56                                           Builder.getInt32(123));
  57
  58   CallInst *Start1 = Builder.CreateLifetimeStart(Var1);
  59   CallInst *Start2 = Builder.CreateLifetimeStart(Var2);
  60   CallInst *Start3 = Builder.CreateLifetimeStart(Var3, Builder.getInt64(100));
  61
  62   EXPECT_EQ(Start1->getArgOperand(0), Builder.getInt64(-1));
  63   EXPECT_EQ(Start2->getArgOperand(0), Builder.getInt64(-1));
  64   EXPECT_EQ(Start3->getArgOperand(0), Builder.getInt64(100));
  65
  66   EXPECT_EQ(Start1->getArgOperand(1), Var1);
  67   EXPECT_NE(Start2->getArgOperand(1), Var2);
  68   EXPECT_EQ(Start3->getArgOperand(1), Var3);
  69
  70   Value *End1 = Builder.CreateLifetimeEnd(Var1);
  71   Builder.CreateLifetimeEnd(Var2);
  72   Builder.CreateLifetimeEnd(Var3);
  73
  74   IntrinsicInst *II_Start1 = dyn_cast<IntrinsicInst>(Start1);
  75   IntrinsicInst *II_End1 = dyn_cast<IntrinsicInst>(End1);
  76   ASSERT_TRUE(II_Start1 != nullptr);
  77   EXPECT_EQ(II_Start1->getIntrinsicID(), Intrinsic::lifetime_start);
  78   ASSERT_TRUE(II_End1 != nullptr);
  79   EXPECT_EQ(II_End1->getIntrinsicID(), Intrinsic::lifetime_end);
  80 }
  81
  82 TEST_F(IRBuilderTest, CreateCondBr) {
  83   IRBuilder<> Builder(BB);
  84   BasicBlock *TBB = BasicBlock::Create(Ctx, "", F);
  85   BasicBlock *FBB = BasicBlock::Create(Ctx, "", F);
  86
  87   BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
  88   TerminatorInst *TI = BB->getTerminator();
  89   EXPECT_EQ(BI, TI);
  90   EXPECT_EQ(2u, TI->getNumSuccessors());
  91   EXPECT_EQ(TBB, TI->getSuccessor(0));
  92   EXPECT_EQ(FBB, TI->getSuccessor(1));
  93
  94   BI->eraseFromParent();
  95   MDNode *Weights = MDBuilder(Ctx).createBranchWeights(42, 13);
  96   BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB, Weights);
  97   TI = BB->getTerminator();
  98   EXPECT_EQ(BI, TI);
  99   EXPECT_EQ(2u, TI->getNumSuccessors());
 100   EXPECT_EQ(TBB, TI->getSuccessor(0));
 101   EXPECT_EQ(FBB, TI->getSuccessor(1));
 102   EXPECT_EQ(Weights, TI->getMetadata(LLVMContext::MD_prof));
 103 }
 104
 105 TEST_F(IRBuilderTest, LandingPadName) {
 106   IRBuilder<> Builder(BB);
 107   LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(), 0, "LP");
 108   EXPECT_EQ(LP->getName(), "LP");
 109 }
 110
 111 TEST_F(IRBuilderTest, DataLayout) {
 112   std::unique_ptr<Module> M(new Module("test", Ctx));
 113   M->setDataLayout("e-n32");
 114   EXPECT_TRUE(M->getDataLayout().isLegalInteger(32));
 115   M->setDataLayout("e");
 116   EXPECT_FALSE(M->getDataLayout().isLegalInteger(32));
 117 }
 118
 119 TEST_F(IRBuilderTest, GetIntTy) {
 120   IRBuilder<> Builder(BB);
 121   IntegerType *Ty1 = Builder.getInt1Ty();
 122   EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1));
 123
 124   DataLayout* DL = new DataLayout(M.get());
 125   IntegerType *IntPtrTy = Builder.getIntPtrTy(*DL);
 126   unsigned IntPtrBitSize =  DL->getPointerSizeInBits(0);
 127   EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
 128   delete DL;
 129 }
 130
 131 TEST_F(IRBuilderTest, FastMathFlags) {
 132   IRBuilder<> Builder(BB);
 133   Value *F, *FC;
 134   Instruction *FDiv, *FAdd, *FCmp, *FCall;
 135
 136   F = Builder.CreateLoad(GV);
 137   F = Builder.CreateFAdd(F, F);
 138
 139   EXPECT_FALSE(Builder.getFastMathFlags().any());
 140   ASSERT_TRUE(isa<Instruction>(F));
 141   FAdd = cast<Instruction>(F);
 142   EXPECT_FALSE(FAdd->hasNoNaNs());
 143
 144   FastMathFlags FMF;
 145   Builder.setFastMathFlags(FMF);
 146
 147   // By default, no flags are set.
 148   F = Builder.CreateFAdd(F, F);
 149   EXPECT_FALSE(Builder.getFastMathFlags().any());
 150   ASSERT_TRUE(isa<Instruction>(F));
 151   FAdd = cast<Instruction>(F);
 152   EXPECT_FALSE(FAdd->hasNoNaNs());
 153   EXPECT_FALSE(FAdd->hasNoInfs());
 154   EXPECT_FALSE(FAdd->hasNoSignedZeros());
 155   EXPECT_FALSE(FAdd->hasAllowReciprocal());
 156   EXPECT_FALSE(FAdd->hasAllowContract());
 157   EXPECT_FALSE(FAdd->hasAllowReassoc());
 158   EXPECT_FALSE(FAdd->hasApproxFunc());
 159
 160   // Set all flags in the instruction.
 161   FAdd->setFast(true);
 162   EXPECT_TRUE(FAdd->hasNoNaNs());
 163   EXPECT_TRUE(FAdd->hasNoInfs());
 164   EXPECT_TRUE(FAdd->hasNoSignedZeros());
 165   EXPECT_TRUE(FAdd->hasAllowReciprocal());
 166   EXPECT_TRUE(FAdd->hasAllowContract());
 167   EXPECT_TRUE(FAdd->hasAllowReassoc());
 168   EXPECT_TRUE(FAdd->hasApproxFunc());
 169
 170   // All flags are set in the builder.
 171   FMF.setFast();
 172   Builder.setFastMathFlags(FMF);
 173
 174   F = Builder.CreateFAdd(F, F);
 175   EXPECT_TRUE(Builder.getFastMathFlags().any());
 176   EXPECT_TRUE(Builder.getFastMathFlags().all());
 177   ASSERT_TRUE(isa<Instruction>(F));
 178   FAdd = cast<Instruction>(F);
 179   EXPECT_TRUE(FAdd->hasNoNaNs());
 180   EXPECT_TRUE(FAdd->isFast());
 181
 182   // Now, try it with CreateBinOp
 183   F = Builder.CreateBinOp(Instruction::FAdd, F, F);
 184   EXPECT_TRUE(Builder.getFastMathFlags().any());
 185   ASSERT_TRUE(isa<Instruction>(F));
 186   FAdd = cast<Instruction>(F);
 187   EXPECT_TRUE(FAdd->hasNoNaNs());
 188   EXPECT_TRUE(FAdd->isFast());
 189
 190   F = Builder.CreateFDiv(F, F);
 191   EXPECT_TRUE(Builder.getFastMathFlags().all());
 192   ASSERT_TRUE(isa<Instruction>(F));
 193   FDiv = cast<Instruction>(F);
 194   EXPECT_TRUE(FDiv->hasAllowReciprocal());
 195
 196   // Clear all FMF in the builder.
 197   Builder.clearFastMathFlags();
 198
 199   F = Builder.CreateFDiv(F, F);
 200   ASSERT_TRUE(isa<Instruction>(F));
 201   FDiv = cast<Instruction>(F);
 202   EXPECT_FALSE(FDiv->hasAllowReciprocal());
 203
 204   // Try individual flags.
 205   FMF.clear();
 206   FMF.setAllowReciprocal();
 207   Builder.setFastMathFlags(FMF);
 208
 209   F = Builder.CreateFDiv(F, F);
 210   EXPECT_TRUE(Builder.getFastMathFlags().any());
 211   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
 212   ASSERT_TRUE(isa<Instruction>(F));
 213   FDiv = cast<Instruction>(F);
 214   EXPECT_TRUE(FDiv->hasAllowReciprocal());
 215
 216   Builder.clearFastMathFlags();
 217
 218   FC = Builder.CreateFCmpOEQ(F, F);
 219   ASSERT_TRUE(isa<Instruction>(FC));
 220   FCmp = cast<Instruction>(FC);
 221   EXPECT_FALSE(FCmp->hasAllowReciprocal());
 222
 223   FMF.clear();
 224   FMF.setAllowReciprocal();
 225   Builder.setFastMathFlags(FMF);
 226
 227   FC = Builder.CreateFCmpOEQ(F, F);
 228   EXPECT_TRUE(Builder.getFastMathFlags().any());
 229   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
 230   ASSERT_TRUE(isa<Instruction>(FC));
 231   FCmp = cast<Instruction>(FC);
 232   EXPECT_TRUE(FCmp->hasAllowReciprocal());
 233
 234   Builder.clearFastMathFlags();
 235
 236   // Test FP-contract
 237   FC = Builder.CreateFAdd(F, F);
 238   ASSERT_TRUE(isa<Instruction>(FC));
 239   FAdd = cast<Instruction>(FC);
 240   EXPECT_FALSE(FAdd->hasAllowContract());
 241
 242   FMF.clear();
 243   FMF.setAllowContract(true);
 244   Builder.setFastMathFlags(FMF);
 245
 246   FC = Builder.CreateFAdd(F, F);
 247   EXPECT_TRUE(Builder.getFastMathFlags().any());
 248   EXPECT_TRUE(Builder.getFastMathFlags().AllowContract);
 249   ASSERT_TRUE(isa<Instruction>(FC));
 250   FAdd = cast<Instruction>(FC);
 251   EXPECT_TRUE(FAdd->hasAllowContract());
 252
 253   FMF.setApproxFunc();
 254   Builder.clearFastMathFlags();
 255   Builder.setFastMathFlags(FMF);
 256   // Now 'aml' and 'contract' are set.
 257   F = Builder.CreateFMul(F, F);
 258   FAdd = cast<Instruction>(F);
 259   EXPECT_TRUE(FAdd->hasApproxFunc());
 260   EXPECT_TRUE(FAdd->hasAllowContract());
 261   EXPECT_FALSE(FAdd->hasAllowReassoc());
 262
 263   FMF.setAllowReassoc();
 264   Builder.clearFastMathFlags();
 265   Builder.setFastMathFlags(FMF);
 266   // Now 'aml' and 'contract' and 'reassoc' are set.
 267   F = Builder.CreateFMul(F, F);
 268   FAdd = cast<Instruction>(F);
 269   EXPECT_TRUE(FAdd->hasApproxFunc());
 270   EXPECT_TRUE(FAdd->hasAllowContract());
 271   EXPECT_TRUE(FAdd->hasAllowReassoc());
 272
 273   // Test a call with FMF.
 274   auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
 275                                     /*isVarArg=*/false);
 276   auto Callee =
 277       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 278
 279   FCall = Builder.CreateCall(Callee, None);
 280   EXPECT_FALSE(FCall->hasNoNaNs());
 281
 282   Value *V =
 283       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 284   FCall = Builder.CreateCall(V, None);
 285   EXPECT_FALSE(FCall->hasNoNaNs());
 286
 287   FMF.clear();
 288   FMF.setNoNaNs();
 289   Builder.setFastMathFlags(FMF);
 290
 291   FCall = Builder.CreateCall(Callee, None);
 292   EXPECT_TRUE(Builder.getFastMathFlags().any());
 293   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
 294   EXPECT_TRUE(FCall->hasNoNaNs());
 295
 296   FCall = Builder.CreateCall(V, None);
 297   EXPECT_TRUE(Builder.getFastMathFlags().any());
 298   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
 299   EXPECT_TRUE(FCall->hasNoNaNs());
 300
 301   Builder.clearFastMathFlags();
 302
 303   // To test a copy, make sure that a '0' and a '1' change state.
 304   F = Builder.CreateFDiv(F, F);
 305   ASSERT_TRUE(isa<Instruction>(F));
 306   FDiv = cast<Instruction>(F);
 307   EXPECT_FALSE(FDiv->getFastMathFlags().any());
 308   FDiv->setHasAllowReciprocal(true);
 309   FAdd->setHasAllowReciprocal(false);
 310   FAdd->setHasNoNaNs(true);
 311   FDiv->copyFastMathFlags(FAdd);
 312   EXPECT_TRUE(FDiv->hasNoNaNs());
 313   EXPECT_FALSE(FDiv->hasAllowReciprocal());
 314
 315 }
 316
 317 TEST_F(IRBuilderTest, WrapFlags) {
 318   IRBuilder<NoFolder> Builder(BB);
 319
 320   // Test instructions.
 321   GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true,
 322                                          GlobalValue::ExternalLinkage, nullptr);
 323   Value *V = Builder.CreateLoad(G);
 324   EXPECT_TRUE(
 325       cast<BinaryOperator>(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap());
 326   EXPECT_TRUE(
 327       cast<BinaryOperator>(Builder.CreateNSWMul(V, V))->hasNoSignedWrap());
 328   EXPECT_TRUE(
 329       cast<BinaryOperator>(Builder.CreateNSWSub(V, V))->hasNoSignedWrap());
 330   EXPECT_TRUE(cast<BinaryOperator>(
 331                   Builder.CreateShl(V, V, "", /* NUW */ false, /* NSW */ true))
 332                   ->hasNoSignedWrap());
 333
 334   EXPECT_TRUE(
 335       cast<BinaryOperator>(Builder.CreateNUWAdd(V, V))->hasNoUnsignedWrap());
 336   EXPECT_TRUE(
 337       cast<BinaryOperator>(Builder.CreateNUWMul(V, V))->hasNoUnsignedWrap());
 338   EXPECT_TRUE(
 339       cast<BinaryOperator>(Builder.CreateNUWSub(V, V))->hasNoUnsignedWrap());
 340   EXPECT_TRUE(cast<BinaryOperator>(
 341                   Builder.CreateShl(V, V, "", /* NUW */ true, /* NSW */ false))
 342                   ->hasNoUnsignedWrap());
 343
 344   // Test operators created with constants.
 345   Constant *C = Builder.getInt32(42);
 346   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
 347                   ->hasNoSignedWrap());
 348   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
 349                   ->hasNoSignedWrap());
 350   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
 351                   ->hasNoSignedWrap());
 352   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
 353                   Builder.CreateShl(C, C, "", /* NUW */ false, /* NSW */ true))
 354                   ->hasNoSignedWrap());
 355
 356   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
 357                   ->hasNoUnsignedWrap());
 358   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
 359                   ->hasNoUnsignedWrap());
 360   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
 361                   ->hasNoUnsignedWrap());
 362   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
 363                   Builder.CreateShl(C, C, "", /* NUW */ true, /* NSW */ false))
 364                   ->hasNoUnsignedWrap());
 365 }
 366
 367 TEST_F(IRBuilderTest, RAIIHelpersTest) {
 368   IRBuilder<> Builder(BB);
 369   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
 370   MDBuilder MDB(M->getContext());
 371
 372   MDNode *FPMathA = MDB.createFPMath(0.01f);
 373   MDNode *FPMathB = MDB.createFPMath(0.1f);
 374
 375   Builder.setDefaultFPMathTag(FPMathA);
 376
 377   {
 378     IRBuilder<>::FastMathFlagGuard Guard(Builder);
 379     FastMathFlags FMF;
 380     FMF.setAllowReciprocal();
 381     Builder.setFastMathFlags(FMF);
 382     Builder.setDefaultFPMathTag(FPMathB);
 383     EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
 384     EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
 385   }
 386
 387   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
 388   EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());
 389
 390   Value *F = Builder.CreateLoad(GV);
 391
 392   {
 393     IRBuilder<>::InsertPointGuard Guard(Builder);
 394     Builder.SetInsertPoint(cast<Instruction>(F));
 395     EXPECT_EQ(F, &*Builder.GetInsertPoint());
 396   }
 397
 398   EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
 399   EXPECT_EQ(BB, Builder.GetInsertBlock());
 400 }
 401
 402 TEST_F(IRBuilderTest, createFunction) {
 403   IRBuilder<> Builder(BB);
 404   DIBuilder DIB(*M);
 405   auto File = DIB.createFile("error.swift", "/");
 406   auto CU =
 407       DIB.createCompileUnit(dwarf::DW_LANG_Swift, File, "swiftc", true, "", 0);
 408   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
 409   auto NoErr = DIB.createFunction(CU, "noerr", "", File, 1, Type, false, true, 1,
 410                                DINode::FlagZero, true);
 411   EXPECT_TRUE(!NoErr->getThrownTypes());
 412   auto Int = DIB.createBasicType("Int", 64, dwarf::DW_ATE_signed);
 413   auto Error = DIB.getOrCreateArray({Int});
 414   auto Err =
 415       DIB.createFunction(CU, "err", "", File, 1, Type, false, true, 1,
 416       DINode::FlagZero, true, nullptr, nullptr, Error.get());
 417   EXPECT_TRUE(Err->getThrownTypes().get() == Error.get());
 418   DIB.finalize();
 419 }
 420
 421 TEST_F(IRBuilderTest, DIBuilder) {
 422   IRBuilder<> Builder(BB);
 423   DIBuilder DIB(*M);
 424   auto File = DIB.createFile("F.CBL", "/");
 425   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
 426                                   DIB.createFile("F.CBL", "/"), "llvm-cobol74",
 427                                   true, "", 0);
 428   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
 429   auto SP = DIB.createFunction(CU, "foo", "", File, 1, Type, false, true, 1,
 430                                DINode::FlagZero, true);
 431   F->setSubprogram(SP);
 432   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
 433   auto BarSP = DIB.createFunction(CU, "bar", "", File, 1, Type, false, true, 1,
 434                                   DINode::FlagZero, true);
 435   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);
 436   I->setDebugLoc(DebugLoc::get(2, 0, BadScope));
 437   DIB.finalize();
 438   EXPECT_TRUE(verifyModule(*M));
 439 }
 440
 441 TEST_F(IRBuilderTest, InsertExtractElement) {
 442   IRBuilder<> Builder(BB);
 443
 444   auto VecTy = VectorType::get(Builder.getInt64Ty(), 4);
 445   auto Elt1 = Builder.getInt64(-1);
 446   auto Elt2 = Builder.getInt64(-2);
 447   Value *Vec = UndefValue::get(VecTy);
 448   Vec = Builder.CreateInsertElement(Vec, Elt1, Builder.getInt8(1));
 449   Vec = Builder.CreateInsertElement(Vec, Elt2, 2);
 450   auto X1 = Builder.CreateExtractElement(Vec, 1);
 451   auto X2 = Builder.CreateExtractElement(Vec, Builder.getInt32(2));
 452   EXPECT_EQ(Elt1, X1);
 453   EXPECT_EQ(Elt2, X2);
 454 }
 455
 456 TEST_F(IRBuilderTest, CreateGlobalStringPtr) {
 457   IRBuilder<> Builder(BB);
 458
 459   auto String1a = Builder.CreateGlobalStringPtr("TestString", "String1a");
 460   auto String1b = Builder.CreateGlobalStringPtr("TestString", "String1b", 0);
 461   auto String2 = Builder.CreateGlobalStringPtr("TestString", "String2", 1);
 462   auto String3 = Builder.CreateGlobalString("TestString", "String3", 2);
 463
 464   EXPECT_TRUE(String1a->getType()->getPointerAddressSpace() == 0);
 465   EXPECT_TRUE(String1b->getType()->getPointerAddressSpace() == 0);
 466   EXPECT_TRUE(String2->getType()->getPointerAddressSpace() == 1);
 467   EXPECT_TRUE(String3->getType()->getPointerAddressSpace() == 2);
 468 }
 469
 470 TEST_F(IRBuilderTest, DebugLoc) {
 471   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
 472                                     /*isVarArg=*/false);
 473   auto Callee =
 474       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 475
 476   DIBuilder DIB(*M);
 477   auto File = DIB.createFile("tmp.cpp", "/");
 478   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
 479                                   DIB.createFile("tmp.cpp", "/"), "", true, "",
 480                                   0);
 481   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
 482   auto SP =
 483       DIB.createFunction(CU, "foo", "foo", File, 1, SPType, false, true, 1);
 484   DebugLoc DL1 = DILocation::get(Ctx, 2, 0, SP);
 485   DebugLoc DL2 = DILocation::get(Ctx, 3, 0, SP);
 486
 487   auto BB2 = BasicBlock::Create(Ctx, "bb2", F);
 488   auto Br = BranchInst::Create(BB2, BB);
 489   Br->setDebugLoc(DL1);
 490
 491   IRBuilder<> Builder(Ctx);
 492   Builder.SetInsertPoint(Br);
 493   EXPECT_EQ(DL1, Builder.getCurrentDebugLocation());
 494   auto Call1 = Builder.CreateCall(Callee, None);
 495   EXPECT_EQ(DL1, Call1->getDebugLoc());
 496
 497   Call1->setDebugLoc(DL2);
 498   Builder.SetInsertPoint(Call1->getParent(), Call1->getIterator());
 499   EXPECT_EQ(DL2, Builder.getCurrentDebugLocation());
 500   auto Call2 = Builder.CreateCall(Callee, None);
 501   EXPECT_EQ(DL2, Call2->getDebugLoc());
 502
 503   DIB.finalize();
 504 }
 505
 506 TEST_F(IRBuilderTest, DIImportedEntity) {
 507   IRBuilder<> Builder(BB);
 508   DIBuilder DIB(*M);
 509   auto F = DIB.createFile("F.CBL", "/");
 510   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
 511                                   F, "llvm-cobol74",
 512                                   true, "", 0);
 513   DIB.createImportedDeclaration(CU, nullptr, F, 1);
 514   DIB.createImportedDeclaration(CU, nullptr, F, 1);
 515   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
 516   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
 517   DIB.finalize();
 518   EXPECT_TRUE(verifyModule(*M));
 519   EXPECT_TRUE(CU->getImportedEntities().size() == 2);
 520 }
 521
 522 //  0: #define M0 V0          <-- command line definition
 523 //  0: main.c                 <-- main file
 524 //     3:   #define M1 V1     <-- M1 definition in main.c
 525 //     5:   #include "file.h" <-- inclusion of file.h from main.c
 526 //          1: #define M2     <-- M2 definition in file.h with no value
 527 //     7:   #undef M1 V1      <-- M1 un-definition in main.c
 528 TEST_F(IRBuilderTest, DIBuilderMacro) {
 529   IRBuilder<> Builder(BB);
 530   DIBuilder DIB(*M);
 531   auto File1 = DIB.createFile("main.c", "/");
 532   auto File2 = DIB.createFile("file.h", "/");
 533   auto CU = DIB.createCompileUnit(
 534       dwarf::DW_LANG_C, DIB.createFile("main.c", "/"), "llvm-c", true, "", 0);
 535   auto MDef0 =
 536       DIB.createMacro(nullptr, 0, dwarf::DW_MACINFO_define, "M0", "V0");
 537   auto TMF1 = DIB.createTempMacroFile(nullptr, 0, File1);
 538   auto MDef1 = DIB.createMacro(TMF1, 3, dwarf::DW_MACINFO_define, "M1", "V1");
 539   auto TMF2 = DIB.createTempMacroFile(TMF1, 5, File2);
 540   auto MDef2 = DIB.createMacro(TMF2, 1, dwarf::DW_MACINFO_define, "M2");
 541   auto MUndef1 = DIB.createMacro(TMF1, 7, dwarf::DW_MACINFO_undef, "M1");
 542
 543   EXPECT_EQ(dwarf::DW_MACINFO_define, MDef1->getMacinfoType());
 544   EXPECT_EQ(3u, MDef1->getLine());
 545   EXPECT_EQ("M1", MDef1->getName());
 546   EXPECT_EQ("V1", MDef1->getValue());
 547
 548   EXPECT_EQ(dwarf::DW_MACINFO_undef, MUndef1->getMacinfoType());
 549   EXPECT_EQ(7u, MUndef1->getLine());
 550   EXPECT_EQ("M1", MUndef1->getName());
 551   EXPECT_EQ("", MUndef1->getValue());
 552
 553   EXPECT_EQ(dwarf::DW_MACINFO_start_file, TMF2->getMacinfoType());
 554   EXPECT_EQ(5u, TMF2->getLine());
 555   EXPECT_EQ(File2, TMF2->getFile());
 556
 557   DIB.finalize();
 558
 559   SmallVector<Metadata *, 4> Elements;
 560   Elements.push_back(MDef2);
 561   auto MF2 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 5, File2,
 562                               DIB.getOrCreateMacroArray(Elements));
 563
 564   Elements.clear();
 565   Elements.push_back(MDef1);
 566   Elements.push_back(MF2);
 567   Elements.push_back(MUndef1);
 568   auto MF1 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 0, File1,
 569                               DIB.getOrCreateMacroArray(Elements));
 570
 571   Elements.clear();
 572   Elements.push_back(MDef0);
 573   Elements.push_back(MF1);
 574   auto MN0 = MDTuple::get(Ctx, Elements);
 575   EXPECT_EQ(MN0, CU->getRawMacros());
 576
 577   Elements.clear();
 578   Elements.push_back(MDef1);
 579   Elements.push_back(MF2);
 580   Elements.push_back(MUndef1);
 581   auto MN1 = MDTuple::get(Ctx, Elements);
 582   EXPECT_EQ(MN1, MF1->getRawElements());
 583
 584   Elements.clear();
 585   Elements.push_back(MDef2);
 586   auto MN2 = MDTuple::get(Ctx, Elements);
 587   EXPECT_EQ(MN2, MF2->getRawElements());
 588   EXPECT_TRUE(verifyModule(*M));
 589 }
 590 }