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