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