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