unittests/IR/IRBuilderTest.cpp

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