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