xref: /llvm-project/llvm/unittests/IR/IRBuilderTest.cpp (revision a5b72abc9eaadbd319f0fbb8ae947d2dd289b30a) 
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/IntrinsicsAArch64.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, Intrinsics) {
52   IRBuilder<> Builder(BB);
53   Value *V;
54   Instruction *I;
55   CallInst *Call;
56   IntrinsicInst *II;
57 
58   V = Builder.CreateLoad(GV->getValueType(), GV);
59   I = cast<Instruction>(Builder.CreateFAdd(V, V));
60   I->setHasNoInfs(true);
61   I->setHasNoNaNs(false);
62 
63   Call = Builder.CreateMinNum(V, V);
64   II = cast<IntrinsicInst>(Call);
65   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::minnum);
66 
67   Call = Builder.CreateMaxNum(V, V);
68   II = cast<IntrinsicInst>(Call);
69   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::maxnum);
70 
71   Call = Builder.CreateMinimum(V, V);
72   II = cast<IntrinsicInst>(Call);
73   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::minimum);
74 
75   Call = Builder.CreateMaximum(V, V);
76   II = cast<IntrinsicInst>(Call);
77   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::maximum);
78 
79   Call = Builder.CreateIntrinsic(Intrinsic::readcyclecounter, {}, {});
80   II = cast<IntrinsicInst>(Call);
81   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::readcyclecounter);
82 
83   Call = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, V);
84   II = cast<IntrinsicInst>(Call);
85   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fabs);
86   EXPECT_FALSE(II->hasNoInfs());
87   EXPECT_FALSE(II->hasNoNaNs());
88 
89   Call = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, V, I);
90   II = cast<IntrinsicInst>(Call);
91   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fabs);
92   EXPECT_TRUE(II->hasNoInfs());
93   EXPECT_FALSE(II->hasNoNaNs());
94 
95   Call = Builder.CreateBinaryIntrinsic(Intrinsic::pow, V, V);
96   II = cast<IntrinsicInst>(Call);
97   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::pow);
98   EXPECT_FALSE(II->hasNoInfs());
99   EXPECT_FALSE(II->hasNoNaNs());
100 
101   Call = Builder.CreateBinaryIntrinsic(Intrinsic::pow, V, V, I);
102   II = cast<IntrinsicInst>(Call);
103   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::pow);
104   EXPECT_TRUE(II->hasNoInfs());
105   EXPECT_FALSE(II->hasNoNaNs());
106 
107   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V});
108   II = cast<IntrinsicInst>(Call);
109   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
110   EXPECT_FALSE(II->hasNoInfs());
111   EXPECT_FALSE(II->hasNoNaNs());
112 
113   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
114   II = cast<IntrinsicInst>(Call);
115   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
116   EXPECT_TRUE(II->hasNoInfs());
117   EXPECT_FALSE(II->hasNoNaNs());
118 
119   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
120   II = cast<IntrinsicInst>(Call);
121   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
122   EXPECT_TRUE(II->hasNoInfs());
123   EXPECT_FALSE(II->hasNoNaNs());
124 
125   Call = Builder.CreateUnaryIntrinsic(Intrinsic::roundeven, V);
126   II = cast<IntrinsicInst>(Call);
127   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::roundeven);
128   EXPECT_FALSE(II->hasNoInfs());
129   EXPECT_FALSE(II->hasNoNaNs());
130 
131   Call = Builder.CreateIntrinsic(
132       Intrinsic::set_rounding, {},
133       {Builder.getInt32(static_cast<uint32_t>(RoundingMode::TowardZero))});
134   II = cast<IntrinsicInst>(Call);
135   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::set_rounding);
136 }
137 
138 TEST_F(IRBuilderTest, IntrinsicsWithScalableVectors) {
139   IRBuilder<> Builder(BB);
140   CallInst *Call;
141   FunctionType *FTy;
142 
143   // Test scalable flag isn't dropped for intrinsic that is explicitly defined
144   // with scalable vectors, e.g. LLVMType<nxv4i32>.
145   Type *SrcVecTy = VectorType::get(Builder.getHalfTy(), 8, true);
146   Type *DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
147   Type *PredTy = VectorType::get(Builder.getInt1Ty(), 4, true);
148 
149   SmallVector<Value*, 3> ArgTys;
150   ArgTys.push_back(UndefValue::get(DstVecTy));
151   ArgTys.push_back(UndefValue::get(PredTy));
152   ArgTys.push_back(UndefValue::get(SrcVecTy));
153 
154   Call = Builder.CreateIntrinsic(Intrinsic::aarch64_sve_fcvtzs_i32f16, {},
155                                  ArgTys, nullptr, "aarch64.sve.fcvtzs.i32f16");
156   FTy = Call->getFunctionType();
157   EXPECT_EQ(FTy->getReturnType(), DstVecTy);
158   for (unsigned i = 0; i != ArgTys.size(); ++i)
159     EXPECT_EQ(FTy->getParamType(i), ArgTys[i]->getType());
160 
161   // Test scalable flag isn't dropped for intrinsic defined with
162   // LLVMScalarOrSameVectorWidth.
163 
164   Type *VecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
165   Type *PtrToVecTy = VecTy->getPointerTo();
166   PredTy = VectorType::get(Builder.getInt1Ty(), 4, true);
167 
168   ArgTys.clear();
169   ArgTys.push_back(UndefValue::get(PtrToVecTy));
170   ArgTys.push_back(UndefValue::get(Builder.getInt32Ty()));
171   ArgTys.push_back(UndefValue::get(PredTy));
172   ArgTys.push_back(UndefValue::get(VecTy));
173 
174   Call = Builder.CreateIntrinsic(Intrinsic::masked_load,
175                                  {VecTy, PtrToVecTy}, ArgTys,
176                                  nullptr, "masked.load");
177   FTy = Call->getFunctionType();
178   EXPECT_EQ(FTy->getReturnType(), VecTy);
179   for (unsigned i = 0; i != ArgTys.size(); ++i)
180     EXPECT_EQ(FTy->getParamType(i), ArgTys[i]->getType());
181 }
182 
183 TEST_F(IRBuilderTest, CreateVScale) {
184   IRBuilder<> Builder(BB);
185 
186   Constant *Zero = Builder.getInt32(0);
187   Value *VScale = Builder.CreateVScale(Zero);
188   EXPECT_TRUE(isa<ConstantInt>(VScale) && cast<ConstantInt>(VScale)->isZero());
189 }
190 
191 TEST_F(IRBuilderTest, CreateStepVector) {
192   IRBuilder<> Builder(BB);
193 
194   // Fixed width vectors
195   Type *DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, false);
196   Value *StepVec = Builder.CreateStepVector(DstVecTy);
197   EXPECT_TRUE(isa<Constant>(StepVec));
198   EXPECT_EQ(StepVec->getType(), DstVecTy);
199 
200   const auto *VectorValue = cast<Constant>(StepVec);
201   for (unsigned i = 0; i < 4; i++) {
202     EXPECT_TRUE(isa<ConstantInt>(VectorValue->getAggregateElement(i)));
203     ConstantInt *El = cast<ConstantInt>(VectorValue->getAggregateElement(i));
204     EXPECT_EQ(El->getValue(), i);
205   }
206 
207   // Scalable vectors
208   DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
209   StepVec = Builder.CreateStepVector(DstVecTy);
210   EXPECT_TRUE(isa<CallInst>(StepVec));
211   CallInst *Call = cast<CallInst>(StepVec);
212   FunctionType *FTy = Call->getFunctionType();
213   EXPECT_EQ(FTy->getReturnType(), DstVecTy);
214   EXPECT_EQ(Call->getIntrinsicID(), Intrinsic::experimental_stepvector);
215 }
216 
217 TEST_F(IRBuilderTest, ConstrainedFP) {
218   IRBuilder<> Builder(BB);
219   Value *V;
220   Value *VDouble;
221   Value *VInt;
222   CallInst *Call;
223   IntrinsicInst *II;
224   GlobalVariable *GVDouble = new GlobalVariable(*M, Type::getDoubleTy(Ctx),
225                             true, GlobalValue::ExternalLinkage, nullptr);
226 
227   V = Builder.CreateLoad(GV->getValueType(), GV);
228   VDouble = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
229 
230   // See if we get constrained intrinsics instead of non-constrained
231   // instructions.
232   Builder.setIsFPConstrained(true);
233   auto Parent = BB->getParent();
234   Parent->addFnAttr(Attribute::StrictFP);
235 
236   V = Builder.CreateFAdd(V, V);
237   ASSERT_TRUE(isa<IntrinsicInst>(V));
238   II = cast<IntrinsicInst>(V);
239   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
240 
241   V = Builder.CreateFSub(V, V);
242   ASSERT_TRUE(isa<IntrinsicInst>(V));
243   II = cast<IntrinsicInst>(V);
244   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fsub);
245 
246   V = Builder.CreateFMul(V, V);
247   ASSERT_TRUE(isa<IntrinsicInst>(V));
248   II = cast<IntrinsicInst>(V);
249   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fmul);
250 
251   V = Builder.CreateFDiv(V, V);
252   ASSERT_TRUE(isa<IntrinsicInst>(V));
253   II = cast<IntrinsicInst>(V);
254   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fdiv);
255 
256   V = Builder.CreateFRem(V, V);
257   ASSERT_TRUE(isa<IntrinsicInst>(V));
258   II = cast<IntrinsicInst>(V);
259   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_frem);
260 
261   VInt = Builder.CreateFPToUI(VDouble, Builder.getInt32Ty());
262   ASSERT_TRUE(isa<IntrinsicInst>(VInt));
263   II = cast<IntrinsicInst>(VInt);
264   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fptoui);
265 
266   VInt = Builder.CreateFPToSI(VDouble, Builder.getInt32Ty());
267   ASSERT_TRUE(isa<IntrinsicInst>(VInt));
268   II = cast<IntrinsicInst>(VInt);
269   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fptosi);
270 
271   VDouble = Builder.CreateUIToFP(VInt, Builder.getDoubleTy());
272   ASSERT_TRUE(isa<IntrinsicInst>(VDouble));
273   II = cast<IntrinsicInst>(VDouble);
274   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_uitofp);
275 
276   VDouble = Builder.CreateSIToFP(VInt, Builder.getDoubleTy());
277   ASSERT_TRUE(isa<IntrinsicInst>(VDouble));
278   II = cast<IntrinsicInst>(VDouble);
279   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_sitofp);
280 
281   V = Builder.CreateFPTrunc(VDouble, Type::getFloatTy(Ctx));
282   ASSERT_TRUE(isa<IntrinsicInst>(V));
283   II = cast<IntrinsicInst>(V);
284   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fptrunc);
285 
286   VDouble = Builder.CreateFPExt(V, Type::getDoubleTy(Ctx));
287   ASSERT_TRUE(isa<IntrinsicInst>(VDouble));
288   II = cast<IntrinsicInst>(VDouble);
289   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fpext);
290 
291   // Verify attributes on the call are created automatically.
292   AttributeSet CallAttrs = II->getAttributes().getFnAttrs();
293   EXPECT_EQ(CallAttrs.hasAttribute(Attribute::StrictFP), true);
294 
295   // Verify attributes on the containing function are created when requested.
296   Builder.setConstrainedFPFunctionAttr();
297   AttributeList Attrs = BB->getParent()->getAttributes();
298   AttributeSet FnAttrs = Attrs.getFnAttrs();
299   EXPECT_EQ(FnAttrs.hasAttribute(Attribute::StrictFP), true);
300 
301   // Verify the codepaths for setting and overriding the default metadata.
302   V = Builder.CreateFAdd(V, V);
303   ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
304   auto *CII = cast<ConstrainedFPIntrinsic>(V);
305   EXPECT_EQ(fp::ebStrict, CII->getExceptionBehavior());
306   EXPECT_EQ(RoundingMode::Dynamic, CII->getRoundingMode());
307 
308   Builder.setDefaultConstrainedExcept(fp::ebIgnore);
309   Builder.setDefaultConstrainedRounding(RoundingMode::TowardPositive);
310   V = Builder.CreateFAdd(V, V);
311   CII = cast<ConstrainedFPIntrinsic>(V);
312   EXPECT_EQ(fp::ebIgnore, CII->getExceptionBehavior());
313   EXPECT_EQ(CII->getRoundingMode(), RoundingMode::TowardPositive);
314 
315   Builder.setDefaultConstrainedExcept(fp::ebIgnore);
316   Builder.setDefaultConstrainedRounding(RoundingMode::NearestTiesToEven);
317   V = Builder.CreateFAdd(V, V);
318   CII = cast<ConstrainedFPIntrinsic>(V);
319   EXPECT_EQ(fp::ebIgnore, CII->getExceptionBehavior());
320   EXPECT_EQ(RoundingMode::NearestTiesToEven, CII->getRoundingMode());
321 
322   Builder.setDefaultConstrainedExcept(fp::ebMayTrap);
323   Builder.setDefaultConstrainedRounding(RoundingMode::TowardNegative);
324   V = Builder.CreateFAdd(V, V);
325   CII = cast<ConstrainedFPIntrinsic>(V);
326   EXPECT_EQ(fp::ebMayTrap, CII->getExceptionBehavior());
327   EXPECT_EQ(RoundingMode::TowardNegative, CII->getRoundingMode());
328 
329   Builder.setDefaultConstrainedExcept(fp::ebStrict);
330   Builder.setDefaultConstrainedRounding(RoundingMode::TowardZero);
331   V = Builder.CreateFAdd(V, V);
332   CII = cast<ConstrainedFPIntrinsic>(V);
333   EXPECT_EQ(fp::ebStrict, CII->getExceptionBehavior());
334   EXPECT_EQ(RoundingMode::TowardZero, CII->getRoundingMode());
335 
336   Builder.setDefaultConstrainedExcept(fp::ebIgnore);
337   Builder.setDefaultConstrainedRounding(RoundingMode::Dynamic);
338   V = Builder.CreateFAdd(V, V);
339   CII = cast<ConstrainedFPIntrinsic>(V);
340   EXPECT_EQ(fp::ebIgnore, CII->getExceptionBehavior());
341   EXPECT_EQ(RoundingMode::Dynamic, CII->getRoundingMode());
342 
343   // Now override the defaults.
344   Call = Builder.CreateConstrainedFPBinOp(
345         Intrinsic::experimental_constrained_fadd, V, V, nullptr, "", nullptr,
346         RoundingMode::TowardNegative, fp::ebMayTrap);
347   CII = cast<ConstrainedFPIntrinsic>(Call);
348   EXPECT_EQ(CII->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
349   EXPECT_EQ(fp::ebMayTrap, CII->getExceptionBehavior());
350   EXPECT_EQ(RoundingMode::TowardNegative, CII->getRoundingMode());
351 
352   Builder.CreateRetVoid();
353   EXPECT_FALSE(verifyModule(*M));
354 }
355 
356 TEST_F(IRBuilderTest, ConstrainedFPIntrinsics) {
357   IRBuilder<> Builder(BB);
358   Value *V;
359   Value *VDouble;
360   ConstrainedFPIntrinsic *CII;
361   GlobalVariable *GVDouble = new GlobalVariable(
362       *M, Type::getDoubleTy(Ctx), true, GlobalValue::ExternalLinkage, nullptr);
363   VDouble = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
364 
365   Builder.setDefaultConstrainedExcept(fp::ebStrict);
366   Builder.setDefaultConstrainedRounding(RoundingMode::TowardZero);
367   Function *Fn = Intrinsic::getDeclaration(M.get(),
368       Intrinsic::experimental_constrained_roundeven, { Type::getDoubleTy(Ctx) });
369   V = Builder.CreateConstrainedFPCall(Fn, { VDouble });
370   CII = cast<ConstrainedFPIntrinsic>(V);
371   EXPECT_EQ(Intrinsic::experimental_constrained_roundeven, CII->getIntrinsicID());
372   EXPECT_EQ(fp::ebStrict, CII->getExceptionBehavior());
373 }
374 
375 TEST_F(IRBuilderTest, ConstrainedFPFunctionCall) {
376   IRBuilder<> Builder(BB);
377 
378   // Create an empty constrained FP function.
379   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
380                                         /*isVarArg=*/false);
381   Function *Callee =
382       Function::Create(FTy, Function::ExternalLinkage, "", M.get());
383   BasicBlock *CalleeBB = BasicBlock::Create(Ctx, "", Callee);
384   IRBuilder<> CalleeBuilder(CalleeBB);
385   CalleeBuilder.setIsFPConstrained(true);
386   CalleeBuilder.setConstrainedFPFunctionAttr();
387   CalleeBuilder.CreateRetVoid();
388 
389   // Now call the empty constrained FP function.
390   Builder.setIsFPConstrained(true);
391   Builder.setConstrainedFPFunctionAttr();
392   CallInst *FCall = Builder.CreateCall(Callee, None);
393 
394   // Check the attributes to verify the strictfp attribute is on the call.
395   EXPECT_TRUE(
396       FCall->getAttributes().getFnAttrs().hasAttribute(Attribute::StrictFP));
397 
398   Builder.CreateRetVoid();
399   EXPECT_FALSE(verifyModule(*M));
400 }
401 
402 TEST_F(IRBuilderTest, Lifetime) {
403   IRBuilder<> Builder(BB);
404   AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
405   AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
406   AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
407                                           Builder.getInt32(123));
408 
409   CallInst *Start1 = Builder.CreateLifetimeStart(Var1);
410   CallInst *Start2 = Builder.CreateLifetimeStart(Var2);
411   CallInst *Start3 = Builder.CreateLifetimeStart(Var3, Builder.getInt64(100));
412 
413   EXPECT_EQ(Start1->getArgOperand(0), Builder.getInt64(-1));
414   EXPECT_EQ(Start2->getArgOperand(0), Builder.getInt64(-1));
415   EXPECT_EQ(Start3->getArgOperand(0), Builder.getInt64(100));
416 
417   EXPECT_EQ(Start1->getArgOperand(1), Var1);
418   EXPECT_NE(Start2->getArgOperand(1), Var2);
419   EXPECT_EQ(Start3->getArgOperand(1), Var3);
420 
421   Value *End1 = Builder.CreateLifetimeEnd(Var1);
422   Builder.CreateLifetimeEnd(Var2);
423   Builder.CreateLifetimeEnd(Var3);
424 
425   IntrinsicInst *II_Start1 = dyn_cast<IntrinsicInst>(Start1);
426   IntrinsicInst *II_End1 = dyn_cast<IntrinsicInst>(End1);
427   ASSERT_TRUE(II_Start1 != nullptr);
428   EXPECT_EQ(II_Start1->getIntrinsicID(), Intrinsic::lifetime_start);
429   ASSERT_TRUE(II_End1 != nullptr);
430   EXPECT_EQ(II_End1->getIntrinsicID(), Intrinsic::lifetime_end);
431 }
432 
433 TEST_F(IRBuilderTest, CreateCondBr) {
434   IRBuilder<> Builder(BB);
435   BasicBlock *TBB = BasicBlock::Create(Ctx, "", F);
436   BasicBlock *FBB = BasicBlock::Create(Ctx, "", F);
437 
438   BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
439   Instruction *TI = BB->getTerminator();
440   EXPECT_EQ(BI, TI);
441   EXPECT_EQ(2u, TI->getNumSuccessors());
442   EXPECT_EQ(TBB, TI->getSuccessor(0));
443   EXPECT_EQ(FBB, TI->getSuccessor(1));
444 
445   BI->eraseFromParent();
446   MDNode *Weights = MDBuilder(Ctx).createBranchWeights(42, 13);
447   BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB, Weights);
448   TI = BB->getTerminator();
449   EXPECT_EQ(BI, TI);
450   EXPECT_EQ(2u, TI->getNumSuccessors());
451   EXPECT_EQ(TBB, TI->getSuccessor(0));
452   EXPECT_EQ(FBB, TI->getSuccessor(1));
453   EXPECT_EQ(Weights, TI->getMetadata(LLVMContext::MD_prof));
454 }
455 
456 TEST_F(IRBuilderTest, LandingPadName) {
457   IRBuilder<> Builder(BB);
458   LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(), 0, "LP");
459   EXPECT_EQ(LP->getName(), "LP");
460 }
461 
462 TEST_F(IRBuilderTest, DataLayout) {
463   std::unique_ptr<Module> M(new Module("test", Ctx));
464   M->setDataLayout("e-n32");
465   EXPECT_TRUE(M->getDataLayout().isLegalInteger(32));
466   M->setDataLayout("e");
467   EXPECT_FALSE(M->getDataLayout().isLegalInteger(32));
468 }
469 
470 TEST_F(IRBuilderTest, GetIntTy) {
471   IRBuilder<> Builder(BB);
472   IntegerType *Ty1 = Builder.getInt1Ty();
473   EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1));
474 
475   DataLayout* DL = new DataLayout(M.get());
476   IntegerType *IntPtrTy = Builder.getIntPtrTy(*DL);
477   unsigned IntPtrBitSize =  DL->getPointerSizeInBits(0);
478   EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
479   delete DL;
480 }
481 
482 TEST_F(IRBuilderTest, UnaryOperators) {
483   IRBuilder<NoFolder> Builder(BB);
484   Value *V = Builder.CreateLoad(GV->getValueType(), GV);
485 
486   // Test CreateUnOp(X)
487   Value *U = Builder.CreateUnOp(Instruction::FNeg, V);
488   ASSERT_TRUE(isa<Instruction>(U));
489   ASSERT_TRUE(isa<FPMathOperator>(U));
490   ASSERT_TRUE(isa<UnaryOperator>(U));
491   ASSERT_FALSE(isa<BinaryOperator>(U));
492 
493   // Test CreateFNegFMF(X)
494   Instruction *I = cast<Instruction>(U);
495   I->setHasNoSignedZeros(true);
496   I->setHasNoNaNs(true);
497   Value *VFMF = Builder.CreateFNegFMF(V, I);
498   Instruction *IFMF = cast<Instruction>(VFMF);
499   EXPECT_TRUE(IFMF->hasNoSignedZeros());
500   EXPECT_TRUE(IFMF->hasNoNaNs());
501   EXPECT_FALSE(IFMF->hasAllowReassoc());
502 }
503 
504 TEST_F(IRBuilderTest, FastMathFlags) {
505   IRBuilder<> Builder(BB);
506   Value *F, *FC;
507   Instruction *FDiv, *FAdd, *FCmp, *FCall;
508 
509   F = Builder.CreateLoad(GV->getValueType(), GV);
510   F = Builder.CreateFAdd(F, F);
511 
512   EXPECT_FALSE(Builder.getFastMathFlags().any());
513   ASSERT_TRUE(isa<Instruction>(F));
514   FAdd = cast<Instruction>(F);
515   EXPECT_FALSE(FAdd->hasNoNaNs());
516 
517   FastMathFlags FMF;
518   Builder.setFastMathFlags(FMF);
519 
520   // By default, no flags are set.
521   F = Builder.CreateFAdd(F, F);
522   EXPECT_FALSE(Builder.getFastMathFlags().any());
523   ASSERT_TRUE(isa<Instruction>(F));
524   FAdd = cast<Instruction>(F);
525   EXPECT_FALSE(FAdd->hasNoNaNs());
526   EXPECT_FALSE(FAdd->hasNoInfs());
527   EXPECT_FALSE(FAdd->hasNoSignedZeros());
528   EXPECT_FALSE(FAdd->hasAllowReciprocal());
529   EXPECT_FALSE(FAdd->hasAllowContract());
530   EXPECT_FALSE(FAdd->hasAllowReassoc());
531   EXPECT_FALSE(FAdd->hasApproxFunc());
532 
533   // Set all flags in the instruction.
534   FAdd->setFast(true);
535   EXPECT_TRUE(FAdd->hasNoNaNs());
536   EXPECT_TRUE(FAdd->hasNoInfs());
537   EXPECT_TRUE(FAdd->hasNoSignedZeros());
538   EXPECT_TRUE(FAdd->hasAllowReciprocal());
539   EXPECT_TRUE(FAdd->hasAllowContract());
540   EXPECT_TRUE(FAdd->hasAllowReassoc());
541   EXPECT_TRUE(FAdd->hasApproxFunc());
542 
543   // All flags are set in the builder.
544   FMF.setFast();
545   Builder.setFastMathFlags(FMF);
546 
547   F = Builder.CreateFAdd(F, F);
548   EXPECT_TRUE(Builder.getFastMathFlags().any());
549   EXPECT_TRUE(Builder.getFastMathFlags().all());
550   ASSERT_TRUE(isa<Instruction>(F));
551   FAdd = cast<Instruction>(F);
552   EXPECT_TRUE(FAdd->hasNoNaNs());
553   EXPECT_TRUE(FAdd->isFast());
554 
555   // Now, try it with CreateBinOp
556   F = Builder.CreateBinOp(Instruction::FAdd, F, F);
557   EXPECT_TRUE(Builder.getFastMathFlags().any());
558   ASSERT_TRUE(isa<Instruction>(F));
559   FAdd = cast<Instruction>(F);
560   EXPECT_TRUE(FAdd->hasNoNaNs());
561   EXPECT_TRUE(FAdd->isFast());
562 
563   F = Builder.CreateFDiv(F, F);
564   EXPECT_TRUE(Builder.getFastMathFlags().all());
565   ASSERT_TRUE(isa<Instruction>(F));
566   FDiv = cast<Instruction>(F);
567   EXPECT_TRUE(FDiv->hasAllowReciprocal());
568 
569   // Clear all FMF in the builder.
570   Builder.clearFastMathFlags();
571 
572   F = Builder.CreateFDiv(F, F);
573   ASSERT_TRUE(isa<Instruction>(F));
574   FDiv = cast<Instruction>(F);
575   EXPECT_FALSE(FDiv->hasAllowReciprocal());
576 
577   // Try individual flags.
578   FMF.clear();
579   FMF.setAllowReciprocal();
580   Builder.setFastMathFlags(FMF);
581 
582   F = Builder.CreateFDiv(F, F);
583   EXPECT_TRUE(Builder.getFastMathFlags().any());
584   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
585   ASSERT_TRUE(isa<Instruction>(F));
586   FDiv = cast<Instruction>(F);
587   EXPECT_TRUE(FDiv->hasAllowReciprocal());
588 
589   Builder.clearFastMathFlags();
590 
591   FC = Builder.CreateFCmpOEQ(F, F);
592   ASSERT_TRUE(isa<Instruction>(FC));
593   FCmp = cast<Instruction>(FC);
594   EXPECT_FALSE(FCmp->hasAllowReciprocal());
595 
596   FMF.clear();
597   FMF.setAllowReciprocal();
598   Builder.setFastMathFlags(FMF);
599 
600   FC = Builder.CreateFCmpOEQ(F, F);
601   EXPECT_TRUE(Builder.getFastMathFlags().any());
602   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
603   ASSERT_TRUE(isa<Instruction>(FC));
604   FCmp = cast<Instruction>(FC);
605   EXPECT_TRUE(FCmp->hasAllowReciprocal());
606 
607   Builder.clearFastMathFlags();
608 
609   // Test FP-contract
610   FC = Builder.CreateFAdd(F, F);
611   ASSERT_TRUE(isa<Instruction>(FC));
612   FAdd = cast<Instruction>(FC);
613   EXPECT_FALSE(FAdd->hasAllowContract());
614 
615   FMF.clear();
616   FMF.setAllowContract(true);
617   Builder.setFastMathFlags(FMF);
618 
619   FC = Builder.CreateFAdd(F, F);
620   EXPECT_TRUE(Builder.getFastMathFlags().any());
621   EXPECT_TRUE(Builder.getFastMathFlags().AllowContract);
622   ASSERT_TRUE(isa<Instruction>(FC));
623   FAdd = cast<Instruction>(FC);
624   EXPECT_TRUE(FAdd->hasAllowContract());
625 
626   FMF.setApproxFunc();
627   Builder.clearFastMathFlags();
628   Builder.setFastMathFlags(FMF);
629   // Now 'aml' and 'contract' are set.
630   F = Builder.CreateFMul(F, F);
631   FAdd = cast<Instruction>(F);
632   EXPECT_TRUE(FAdd->hasApproxFunc());
633   EXPECT_TRUE(FAdd->hasAllowContract());
634   EXPECT_FALSE(FAdd->hasAllowReassoc());
635 
636   FMF.setAllowReassoc();
637   Builder.clearFastMathFlags();
638   Builder.setFastMathFlags(FMF);
639   // Now 'aml' and 'contract' and 'reassoc' are set.
640   F = Builder.CreateFMul(F, F);
641   FAdd = cast<Instruction>(F);
642   EXPECT_TRUE(FAdd->hasApproxFunc());
643   EXPECT_TRUE(FAdd->hasAllowContract());
644   EXPECT_TRUE(FAdd->hasAllowReassoc());
645 
646   // Test a call with FMF.
647   auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
648                                     /*isVarArg=*/false);
649   auto Callee =
650       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
651 
652   FCall = Builder.CreateCall(Callee, None);
653   EXPECT_FALSE(FCall->hasNoNaNs());
654 
655   Function *V =
656       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
657   FCall = Builder.CreateCall(V, None);
658   EXPECT_FALSE(FCall->hasNoNaNs());
659 
660   FMF.clear();
661   FMF.setNoNaNs();
662   Builder.setFastMathFlags(FMF);
663 
664   FCall = Builder.CreateCall(Callee, None);
665   EXPECT_TRUE(Builder.getFastMathFlags().any());
666   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
667   EXPECT_TRUE(FCall->hasNoNaNs());
668 
669   FCall = Builder.CreateCall(V, None);
670   EXPECT_TRUE(Builder.getFastMathFlags().any());
671   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
672   EXPECT_TRUE(FCall->hasNoNaNs());
673 
674   Builder.clearFastMathFlags();
675 
676   // To test a copy, make sure that a '0' and a '1' change state.
677   F = Builder.CreateFDiv(F, F);
678   ASSERT_TRUE(isa<Instruction>(F));
679   FDiv = cast<Instruction>(F);
680   EXPECT_FALSE(FDiv->getFastMathFlags().any());
681   FDiv->setHasAllowReciprocal(true);
682   FAdd->setHasAllowReciprocal(false);
683   FAdd->setHasNoNaNs(true);
684   FDiv->copyFastMathFlags(FAdd);
685   EXPECT_TRUE(FDiv->hasNoNaNs());
686   EXPECT_FALSE(FDiv->hasAllowReciprocal());
687 
688 }
689 
690 TEST_F(IRBuilderTest, WrapFlags) {
691   IRBuilder<NoFolder> Builder(BB);
692 
693   // Test instructions.
694   GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true,
695                                          GlobalValue::ExternalLinkage, nullptr);
696   Value *V = Builder.CreateLoad(G->getValueType(), G);
697   EXPECT_TRUE(
698       cast<BinaryOperator>(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap());
699   EXPECT_TRUE(
700       cast<BinaryOperator>(Builder.CreateNSWMul(V, V))->hasNoSignedWrap());
701   EXPECT_TRUE(
702       cast<BinaryOperator>(Builder.CreateNSWSub(V, V))->hasNoSignedWrap());
703   EXPECT_TRUE(cast<BinaryOperator>(
704                   Builder.CreateShl(V, V, "", /* NUW */ false, /* NSW */ true))
705                   ->hasNoSignedWrap());
706 
707   EXPECT_TRUE(
708       cast<BinaryOperator>(Builder.CreateNUWAdd(V, V))->hasNoUnsignedWrap());
709   EXPECT_TRUE(
710       cast<BinaryOperator>(Builder.CreateNUWMul(V, V))->hasNoUnsignedWrap());
711   EXPECT_TRUE(
712       cast<BinaryOperator>(Builder.CreateNUWSub(V, V))->hasNoUnsignedWrap());
713   EXPECT_TRUE(cast<BinaryOperator>(
714                   Builder.CreateShl(V, V, "", /* NUW */ true, /* NSW */ false))
715                   ->hasNoUnsignedWrap());
716 
717   // Test operators created with constants.
718   Constant *C = Builder.getInt32(42);
719   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
720                   ->hasNoSignedWrap());
721   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
722                   ->hasNoSignedWrap());
723   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
724                   ->hasNoSignedWrap());
725   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
726                   Builder.CreateShl(C, C, "", /* NUW */ false, /* NSW */ true))
727                   ->hasNoSignedWrap());
728 
729   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
730                   ->hasNoUnsignedWrap());
731   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
732                   ->hasNoUnsignedWrap());
733   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
734                   ->hasNoUnsignedWrap());
735   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
736                   Builder.CreateShl(C, C, "", /* NUW */ true, /* NSW */ false))
737                   ->hasNoUnsignedWrap());
738 }
739 
740 TEST_F(IRBuilderTest, RAIIHelpersTest) {
741   IRBuilder<> Builder(BB);
742   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
743   MDBuilder MDB(M->getContext());
744 
745   MDNode *FPMathA = MDB.createFPMath(0.01f);
746   MDNode *FPMathB = MDB.createFPMath(0.1f);
747 
748   Builder.setDefaultFPMathTag(FPMathA);
749 
750   {
751     IRBuilder<>::FastMathFlagGuard Guard(Builder);
752     FastMathFlags FMF;
753     FMF.setAllowReciprocal();
754     Builder.setFastMathFlags(FMF);
755     Builder.setDefaultFPMathTag(FPMathB);
756     EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
757     EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
758   }
759 
760   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
761   EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());
762 
763   Value *F = Builder.CreateLoad(GV->getValueType(), GV);
764 
765   {
766     IRBuilder<>::InsertPointGuard Guard(Builder);
767     Builder.SetInsertPoint(cast<Instruction>(F));
768     EXPECT_EQ(F, &*Builder.GetInsertPoint());
769   }
770 
771   EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
772   EXPECT_EQ(BB, Builder.GetInsertBlock());
773 }
774 
775 TEST_F(IRBuilderTest, createFunction) {
776   IRBuilder<> Builder(BB);
777   DIBuilder DIB(*M);
778   auto File = DIB.createFile("error.swift", "/");
779   auto CU =
780       DIB.createCompileUnit(dwarf::DW_LANG_Swift, File, "swiftc", true, "", 0);
781   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
782   auto NoErr = DIB.createFunction(
783       CU, "noerr", "", File, 1, Type, 1, DINode::FlagZero,
784       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
785   EXPECT_TRUE(!NoErr->getThrownTypes());
786   auto Int = DIB.createBasicType("Int", 64, dwarf::DW_ATE_signed);
787   auto Error = DIB.getOrCreateArray({Int});
788   auto Err = DIB.createFunction(
789       CU, "err", "", File, 1, Type, 1, DINode::FlagZero,
790       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized, nullptr,
791       nullptr, Error.get());
792   EXPECT_TRUE(Err->getThrownTypes().get() == Error.get());
793   DIB.finalize();
794 }
795 
796 TEST_F(IRBuilderTest, DIBuilder) {
797   IRBuilder<> Builder(BB);
798   DIBuilder DIB(*M);
799   auto File = DIB.createFile("F.CBL", "/");
800   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
801                                   DIB.createFile("F.CBL", "/"), "llvm-cobol74",
802                                   true, "", 0);
803   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
804   auto SP = DIB.createFunction(
805       CU, "foo", "", File, 1, Type, 1, DINode::FlagZero,
806       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
807   F->setSubprogram(SP);
808   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
809   auto BarSP = DIB.createFunction(
810       CU, "bar", "", File, 1, Type, 1, DINode::FlagZero,
811       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
812   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);
813   I->setDebugLoc(DILocation::get(Ctx, 2, 0, BadScope));
814   DIB.finalize();
815   EXPECT_TRUE(verifyModule(*M));
816 }
817 
818 TEST_F(IRBuilderTest, createArtificialSubprogram) {
819   IRBuilder<> Builder(BB);
820   DIBuilder DIB(*M);
821   auto File = DIB.createFile("main.c", "/");
822   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "clang",
823                                   /*isOptimized=*/true, /*Flags=*/"",
824                                   /*Runtime Version=*/0);
825   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
826   auto SP = DIB.createFunction(
827       CU, "foo", /*LinkageName=*/"", File,
828       /*LineNo=*/1, Type, /*ScopeLine=*/2, DINode::FlagZero,
829       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
830   EXPECT_TRUE(SP->isDistinct());
831 
832   F->setSubprogram(SP);
833   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
834   ReturnInst *R = Builder.CreateRetVoid();
835   I->setDebugLoc(DILocation::get(Ctx, 3, 2, SP));
836   R->setDebugLoc(DILocation::get(Ctx, 4, 2, SP));
837   DIB.finalize();
838   EXPECT_FALSE(verifyModule(*M));
839 
840   Function *G = Function::Create(F->getFunctionType(),
841                                  Function::ExternalLinkage, "", M.get());
842   BasicBlock *GBB = BasicBlock::Create(Ctx, "", G);
843   Builder.SetInsertPoint(GBB);
844   I->removeFromParent();
845   Builder.Insert(I);
846   Builder.CreateRetVoid();
847   EXPECT_FALSE(verifyModule(*M));
848 
849   DISubprogram *GSP = DIBuilder::createArtificialSubprogram(F->getSubprogram());
850   EXPECT_EQ(SP->getFile(), GSP->getFile());
851   EXPECT_EQ(SP->getType(), GSP->getType());
852   EXPECT_EQ(SP->getLine(), GSP->getLine());
853   EXPECT_EQ(SP->getScopeLine(), GSP->getScopeLine());
854   EXPECT_TRUE(GSP->isDistinct());
855 
856   G->setSubprogram(GSP);
857   EXPECT_TRUE(verifyModule(*M));
858 
859   auto *InlinedAtNode =
860       DILocation::getDistinct(Ctx, GSP->getScopeLine(), 0, GSP);
861   DebugLoc DL = I->getDebugLoc();
862   DenseMap<const MDNode *, MDNode *> IANodes;
863   auto IA = DebugLoc::appendInlinedAt(DL, InlinedAtNode, Ctx, IANodes);
864   auto NewDL =
865       DILocation::get(Ctx, DL.getLine(), DL.getCol(), DL.getScope(), IA);
866   I->setDebugLoc(NewDL);
867   EXPECT_FALSE(verifyModule(*M));
868 
869   EXPECT_EQ("foo", SP->getName());
870   EXPECT_EQ("foo", GSP->getName());
871   EXPECT_FALSE(SP->isArtificial());
872   EXPECT_TRUE(GSP->isArtificial());
873 }
874 
875 TEST_F(IRBuilderTest, InsertExtractElement) {
876   IRBuilder<> Builder(BB);
877 
878   auto VecTy = FixedVectorType::get(Builder.getInt64Ty(), 4);
879   auto Elt1 = Builder.getInt64(-1);
880   auto Elt2 = Builder.getInt64(-2);
881   Value *Vec = UndefValue::get(VecTy);
882   Vec = Builder.CreateInsertElement(Vec, Elt1, Builder.getInt8(1));
883   Vec = Builder.CreateInsertElement(Vec, Elt2, 2);
884   auto X1 = Builder.CreateExtractElement(Vec, 1);
885   auto X2 = Builder.CreateExtractElement(Vec, Builder.getInt32(2));
886   EXPECT_EQ(Elt1, X1);
887   EXPECT_EQ(Elt2, X2);
888 }
889 
890 TEST_F(IRBuilderTest, CreateGlobalStringPtr) {
891   IRBuilder<> Builder(BB);
892 
893   auto String1a = Builder.CreateGlobalStringPtr("TestString", "String1a");
894   auto String1b = Builder.CreateGlobalStringPtr("TestString", "String1b", 0);
895   auto String2 = Builder.CreateGlobalStringPtr("TestString", "String2", 1);
896   auto String3 = Builder.CreateGlobalString("TestString", "String3", 2);
897 
898   EXPECT_TRUE(String1a->getType()->getPointerAddressSpace() == 0);
899   EXPECT_TRUE(String1b->getType()->getPointerAddressSpace() == 0);
900   EXPECT_TRUE(String2->getType()->getPointerAddressSpace() == 1);
901   EXPECT_TRUE(String3->getType()->getPointerAddressSpace() == 2);
902 }
903 
904 TEST_F(IRBuilderTest, DebugLoc) {
905   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
906                                     /*isVarArg=*/false);
907   auto Callee =
908       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
909 
910   DIBuilder DIB(*M);
911   auto File = DIB.createFile("tmp.cpp", "/");
912   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
913                                   DIB.createFile("tmp.cpp", "/"), "", true, "",
914                                   0);
915   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
916   auto SP =
917       DIB.createFunction(CU, "foo", "foo", File, 1, SPType, 1, DINode::FlagZero,
918                          DISubprogram::SPFlagDefinition);
919   DebugLoc DL1 = DILocation::get(Ctx, 2, 0, SP);
920   DebugLoc DL2 = DILocation::get(Ctx, 3, 0, SP);
921 
922   auto BB2 = BasicBlock::Create(Ctx, "bb2", F);
923   auto Br = BranchInst::Create(BB2, BB);
924   Br->setDebugLoc(DL1);
925 
926   IRBuilder<> Builder(Ctx);
927   Builder.SetInsertPoint(Br);
928   EXPECT_EQ(DL1, Builder.getCurrentDebugLocation());
929   auto Call1 = Builder.CreateCall(Callee, None);
930   EXPECT_EQ(DL1, Call1->getDebugLoc());
931 
932   Call1->setDebugLoc(DL2);
933   Builder.SetInsertPoint(Call1->getParent(), Call1->getIterator());
934   EXPECT_EQ(DL2, Builder.getCurrentDebugLocation());
935   auto Call2 = Builder.CreateCall(Callee, None);
936   EXPECT_EQ(DL2, Call2->getDebugLoc());
937 
938   DIB.finalize();
939 }
940 
941 TEST_F(IRBuilderTest, DIImportedEntity) {
942   IRBuilder<> Builder(BB);
943   DIBuilder DIB(*M);
944   auto F = DIB.createFile("F.CBL", "/");
945   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
946                                   F, "llvm-cobol74",
947                                   true, "", 0);
948   MDTuple *Elements = MDTuple::getDistinct(Ctx, None);
949 
950   DIB.createImportedDeclaration(CU, nullptr, F, 1);
951   DIB.createImportedDeclaration(CU, nullptr, F, 1);
952   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
953   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
954   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2, Elements);
955   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2, Elements);
956   DIB.finalize();
957   EXPECT_TRUE(verifyModule(*M));
958   EXPECT_TRUE(CU->getImportedEntities().size() == 3);
959 }
960 
961 //  0: #define M0 V0          <-- command line definition
962 //  0: main.c                 <-- main file
963 //     3:   #define M1 V1     <-- M1 definition in main.c
964 //     5:   #include "file.h" <-- inclusion of file.h from main.c
965 //          1: #define M2     <-- M2 definition in file.h with no value
966 //     7:   #undef M1 V1      <-- M1 un-definition in main.c
967 TEST_F(IRBuilderTest, DIBuilderMacro) {
968   IRBuilder<> Builder(BB);
969   DIBuilder DIB(*M);
970   auto File1 = DIB.createFile("main.c", "/");
971   auto File2 = DIB.createFile("file.h", "/");
972   auto CU = DIB.createCompileUnit(
973       dwarf::DW_LANG_C, DIB.createFile("main.c", "/"), "llvm-c", true, "", 0);
974   auto MDef0 =
975       DIB.createMacro(nullptr, 0, dwarf::DW_MACINFO_define, "M0", "V0");
976   auto TMF1 = DIB.createTempMacroFile(nullptr, 0, File1);
977   auto MDef1 = DIB.createMacro(TMF1, 3, dwarf::DW_MACINFO_define, "M1", "V1");
978   auto TMF2 = DIB.createTempMacroFile(TMF1, 5, File2);
979   auto MDef2 = DIB.createMacro(TMF2, 1, dwarf::DW_MACINFO_define, "M2");
980   auto MUndef1 = DIB.createMacro(TMF1, 7, dwarf::DW_MACINFO_undef, "M1");
981 
982   EXPECT_EQ(dwarf::DW_MACINFO_define, MDef1->getMacinfoType());
983   EXPECT_EQ(3u, MDef1->getLine());
984   EXPECT_EQ("M1", MDef1->getName());
985   EXPECT_EQ("V1", MDef1->getValue());
986 
987   EXPECT_EQ(dwarf::DW_MACINFO_undef, MUndef1->getMacinfoType());
988   EXPECT_EQ(7u, MUndef1->getLine());
989   EXPECT_EQ("M1", MUndef1->getName());
990   EXPECT_EQ("", MUndef1->getValue());
991 
992   EXPECT_EQ(dwarf::DW_MACINFO_start_file, TMF2->getMacinfoType());
993   EXPECT_EQ(5u, TMF2->getLine());
994   EXPECT_EQ(File2, TMF2->getFile());
995 
996   DIB.finalize();
997 
998   SmallVector<Metadata *, 4> Elements;
999   Elements.push_back(MDef2);
1000   auto MF2 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 5, File2,
1001                               DIB.getOrCreateMacroArray(Elements));
1002 
1003   Elements.clear();
1004   Elements.push_back(MDef1);
1005   Elements.push_back(MF2);
1006   Elements.push_back(MUndef1);
1007   auto MF1 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 0, File1,
1008                               DIB.getOrCreateMacroArray(Elements));
1009 
1010   Elements.clear();
1011   Elements.push_back(MDef0);
1012   Elements.push_back(MF1);
1013   auto MN0 = MDTuple::get(Ctx, Elements);
1014   EXPECT_EQ(MN0, CU->getRawMacros());
1015 
1016   Elements.clear();
1017   Elements.push_back(MDef1);
1018   Elements.push_back(MF2);
1019   Elements.push_back(MUndef1);
1020   auto MN1 = MDTuple::get(Ctx, Elements);
1021   EXPECT_EQ(MN1, MF1->getRawElements());
1022 
1023   Elements.clear();
1024   Elements.push_back(MDef2);
1025   auto MN2 = MDTuple::get(Ctx, Elements);
1026   EXPECT_EQ(MN2, MF2->getRawElements());
1027   EXPECT_TRUE(verifyModule(*M));
1028 }
1029 
1030 TEST_F(IRBuilderTest, NoFolderNames) {
1031   IRBuilder<NoFolder> Builder(BB);
1032   auto *Add =
1033       Builder.CreateAdd(Builder.getInt32(1), Builder.getInt32(2), "add");
1034   EXPECT_EQ(Add->getName(), "add");
1035 }
1036 }
1037