xref: /llvm-project/llvm/unittests/IR/IRBuilderTest.cpp (revision 14359ef1b6a0610ac91df5f5a91c88a0b51c187c) 
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, FastMathFlags) {
206   IRBuilder<> Builder(BB);
207   Value *F, *FC;
208   Instruction *FDiv, *FAdd, *FCmp, *FCall;
209 
210   F = Builder.CreateLoad(GV->getValueType(), GV);
211   F = Builder.CreateFAdd(F, F);
212 
213   EXPECT_FALSE(Builder.getFastMathFlags().any());
214   ASSERT_TRUE(isa<Instruction>(F));
215   FAdd = cast<Instruction>(F);
216   EXPECT_FALSE(FAdd->hasNoNaNs());
217 
218   FastMathFlags FMF;
219   Builder.setFastMathFlags(FMF);
220 
221   // By default, no flags are set.
222   F = Builder.CreateFAdd(F, F);
223   EXPECT_FALSE(Builder.getFastMathFlags().any());
224   ASSERT_TRUE(isa<Instruction>(F));
225   FAdd = cast<Instruction>(F);
226   EXPECT_FALSE(FAdd->hasNoNaNs());
227   EXPECT_FALSE(FAdd->hasNoInfs());
228   EXPECT_FALSE(FAdd->hasNoSignedZeros());
229   EXPECT_FALSE(FAdd->hasAllowReciprocal());
230   EXPECT_FALSE(FAdd->hasAllowContract());
231   EXPECT_FALSE(FAdd->hasAllowReassoc());
232   EXPECT_FALSE(FAdd->hasApproxFunc());
233 
234   // Set all flags in the instruction.
235   FAdd->setFast(true);
236   EXPECT_TRUE(FAdd->hasNoNaNs());
237   EXPECT_TRUE(FAdd->hasNoInfs());
238   EXPECT_TRUE(FAdd->hasNoSignedZeros());
239   EXPECT_TRUE(FAdd->hasAllowReciprocal());
240   EXPECT_TRUE(FAdd->hasAllowContract());
241   EXPECT_TRUE(FAdd->hasAllowReassoc());
242   EXPECT_TRUE(FAdd->hasApproxFunc());
243 
244   // All flags are set in the builder.
245   FMF.setFast();
246   Builder.setFastMathFlags(FMF);
247 
248   F = Builder.CreateFAdd(F, F);
249   EXPECT_TRUE(Builder.getFastMathFlags().any());
250   EXPECT_TRUE(Builder.getFastMathFlags().all());
251   ASSERT_TRUE(isa<Instruction>(F));
252   FAdd = cast<Instruction>(F);
253   EXPECT_TRUE(FAdd->hasNoNaNs());
254   EXPECT_TRUE(FAdd->isFast());
255 
256   // Now, try it with CreateBinOp
257   F = Builder.CreateBinOp(Instruction::FAdd, F, F);
258   EXPECT_TRUE(Builder.getFastMathFlags().any());
259   ASSERT_TRUE(isa<Instruction>(F));
260   FAdd = cast<Instruction>(F);
261   EXPECT_TRUE(FAdd->hasNoNaNs());
262   EXPECT_TRUE(FAdd->isFast());
263 
264   F = Builder.CreateFDiv(F, F);
265   EXPECT_TRUE(Builder.getFastMathFlags().all());
266   ASSERT_TRUE(isa<Instruction>(F));
267   FDiv = cast<Instruction>(F);
268   EXPECT_TRUE(FDiv->hasAllowReciprocal());
269 
270   // Clear all FMF in the builder.
271   Builder.clearFastMathFlags();
272 
273   F = Builder.CreateFDiv(F, F);
274   ASSERT_TRUE(isa<Instruction>(F));
275   FDiv = cast<Instruction>(F);
276   EXPECT_FALSE(FDiv->hasAllowReciprocal());
277 
278   // Try individual flags.
279   FMF.clear();
280   FMF.setAllowReciprocal();
281   Builder.setFastMathFlags(FMF);
282 
283   F = Builder.CreateFDiv(F, F);
284   EXPECT_TRUE(Builder.getFastMathFlags().any());
285   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
286   ASSERT_TRUE(isa<Instruction>(F));
287   FDiv = cast<Instruction>(F);
288   EXPECT_TRUE(FDiv->hasAllowReciprocal());
289 
290   Builder.clearFastMathFlags();
291 
292   FC = Builder.CreateFCmpOEQ(F, F);
293   ASSERT_TRUE(isa<Instruction>(FC));
294   FCmp = cast<Instruction>(FC);
295   EXPECT_FALSE(FCmp->hasAllowReciprocal());
296 
297   FMF.clear();
298   FMF.setAllowReciprocal();
299   Builder.setFastMathFlags(FMF);
300 
301   FC = Builder.CreateFCmpOEQ(F, F);
302   EXPECT_TRUE(Builder.getFastMathFlags().any());
303   EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
304   ASSERT_TRUE(isa<Instruction>(FC));
305   FCmp = cast<Instruction>(FC);
306   EXPECT_TRUE(FCmp->hasAllowReciprocal());
307 
308   Builder.clearFastMathFlags();
309 
310   // Test FP-contract
311   FC = Builder.CreateFAdd(F, F);
312   ASSERT_TRUE(isa<Instruction>(FC));
313   FAdd = cast<Instruction>(FC);
314   EXPECT_FALSE(FAdd->hasAllowContract());
315 
316   FMF.clear();
317   FMF.setAllowContract(true);
318   Builder.setFastMathFlags(FMF);
319 
320   FC = Builder.CreateFAdd(F, F);
321   EXPECT_TRUE(Builder.getFastMathFlags().any());
322   EXPECT_TRUE(Builder.getFastMathFlags().AllowContract);
323   ASSERT_TRUE(isa<Instruction>(FC));
324   FAdd = cast<Instruction>(FC);
325   EXPECT_TRUE(FAdd->hasAllowContract());
326 
327   FMF.setApproxFunc();
328   Builder.clearFastMathFlags();
329   Builder.setFastMathFlags(FMF);
330   // Now 'aml' and 'contract' are set.
331   F = Builder.CreateFMul(F, F);
332   FAdd = cast<Instruction>(F);
333   EXPECT_TRUE(FAdd->hasApproxFunc());
334   EXPECT_TRUE(FAdd->hasAllowContract());
335   EXPECT_FALSE(FAdd->hasAllowReassoc());
336 
337   FMF.setAllowReassoc();
338   Builder.clearFastMathFlags();
339   Builder.setFastMathFlags(FMF);
340   // Now 'aml' and 'contract' and 'reassoc' are set.
341   F = Builder.CreateFMul(F, F);
342   FAdd = cast<Instruction>(F);
343   EXPECT_TRUE(FAdd->hasApproxFunc());
344   EXPECT_TRUE(FAdd->hasAllowContract());
345   EXPECT_TRUE(FAdd->hasAllowReassoc());
346 
347   // Test a call with FMF.
348   auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
349                                     /*isVarArg=*/false);
350   auto Callee =
351       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
352 
353   FCall = Builder.CreateCall(Callee, None);
354   EXPECT_FALSE(FCall->hasNoNaNs());
355 
356   Function *V =
357       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
358   FCall = Builder.CreateCall(V, None);
359   EXPECT_FALSE(FCall->hasNoNaNs());
360 
361   FMF.clear();
362   FMF.setNoNaNs();
363   Builder.setFastMathFlags(FMF);
364 
365   FCall = Builder.CreateCall(Callee, None);
366   EXPECT_TRUE(Builder.getFastMathFlags().any());
367   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
368   EXPECT_TRUE(FCall->hasNoNaNs());
369 
370   FCall = Builder.CreateCall(V, None);
371   EXPECT_TRUE(Builder.getFastMathFlags().any());
372   EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
373   EXPECT_TRUE(FCall->hasNoNaNs());
374 
375   Builder.clearFastMathFlags();
376 
377   // To test a copy, make sure that a '0' and a '1' change state.
378   F = Builder.CreateFDiv(F, F);
379   ASSERT_TRUE(isa<Instruction>(F));
380   FDiv = cast<Instruction>(F);
381   EXPECT_FALSE(FDiv->getFastMathFlags().any());
382   FDiv->setHasAllowReciprocal(true);
383   FAdd->setHasAllowReciprocal(false);
384   FAdd->setHasNoNaNs(true);
385   FDiv->copyFastMathFlags(FAdd);
386   EXPECT_TRUE(FDiv->hasNoNaNs());
387   EXPECT_FALSE(FDiv->hasAllowReciprocal());
388 
389 }
390 
391 TEST_F(IRBuilderTest, WrapFlags) {
392   IRBuilder<NoFolder> Builder(BB);
393 
394   // Test instructions.
395   GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true,
396                                          GlobalValue::ExternalLinkage, nullptr);
397   Value *V = Builder.CreateLoad(G->getValueType(), G);
398   EXPECT_TRUE(
399       cast<BinaryOperator>(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap());
400   EXPECT_TRUE(
401       cast<BinaryOperator>(Builder.CreateNSWMul(V, V))->hasNoSignedWrap());
402   EXPECT_TRUE(
403       cast<BinaryOperator>(Builder.CreateNSWSub(V, V))->hasNoSignedWrap());
404   EXPECT_TRUE(cast<BinaryOperator>(
405                   Builder.CreateShl(V, V, "", /* NUW */ false, /* NSW */ true))
406                   ->hasNoSignedWrap());
407 
408   EXPECT_TRUE(
409       cast<BinaryOperator>(Builder.CreateNUWAdd(V, V))->hasNoUnsignedWrap());
410   EXPECT_TRUE(
411       cast<BinaryOperator>(Builder.CreateNUWMul(V, V))->hasNoUnsignedWrap());
412   EXPECT_TRUE(
413       cast<BinaryOperator>(Builder.CreateNUWSub(V, V))->hasNoUnsignedWrap());
414   EXPECT_TRUE(cast<BinaryOperator>(
415                   Builder.CreateShl(V, V, "", /* NUW */ true, /* NSW */ false))
416                   ->hasNoUnsignedWrap());
417 
418   // Test operators created with constants.
419   Constant *C = Builder.getInt32(42);
420   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
421                   ->hasNoSignedWrap());
422   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
423                   ->hasNoSignedWrap());
424   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
425                   ->hasNoSignedWrap());
426   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
427                   Builder.CreateShl(C, C, "", /* NUW */ false, /* NSW */ true))
428                   ->hasNoSignedWrap());
429 
430   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
431                   ->hasNoUnsignedWrap());
432   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
433                   ->hasNoUnsignedWrap());
434   EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
435                   ->hasNoUnsignedWrap());
436   EXPECT_TRUE(cast<OverflowingBinaryOperator>(
437                   Builder.CreateShl(C, C, "", /* NUW */ true, /* NSW */ false))
438                   ->hasNoUnsignedWrap());
439 }
440 
441 TEST_F(IRBuilderTest, RAIIHelpersTest) {
442   IRBuilder<> Builder(BB);
443   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
444   MDBuilder MDB(M->getContext());
445 
446   MDNode *FPMathA = MDB.createFPMath(0.01f);
447   MDNode *FPMathB = MDB.createFPMath(0.1f);
448 
449   Builder.setDefaultFPMathTag(FPMathA);
450 
451   {
452     IRBuilder<>::FastMathFlagGuard Guard(Builder);
453     FastMathFlags FMF;
454     FMF.setAllowReciprocal();
455     Builder.setFastMathFlags(FMF);
456     Builder.setDefaultFPMathTag(FPMathB);
457     EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
458     EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
459   }
460 
461   EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
462   EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());
463 
464   Value *F = Builder.CreateLoad(GV->getValueType(), GV);
465 
466   {
467     IRBuilder<>::InsertPointGuard Guard(Builder);
468     Builder.SetInsertPoint(cast<Instruction>(F));
469     EXPECT_EQ(F, &*Builder.GetInsertPoint());
470   }
471 
472   EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
473   EXPECT_EQ(BB, Builder.GetInsertBlock());
474 }
475 
476 TEST_F(IRBuilderTest, createFunction) {
477   IRBuilder<> Builder(BB);
478   DIBuilder DIB(*M);
479   auto File = DIB.createFile("error.swift", "/");
480   auto CU =
481       DIB.createCompileUnit(dwarf::DW_LANG_Swift, File, "swiftc", true, "", 0);
482   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
483   auto NoErr = DIB.createFunction(
484       CU, "noerr", "", File, 1, Type, 1, DINode::FlagZero,
485       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
486   EXPECT_TRUE(!NoErr->getThrownTypes());
487   auto Int = DIB.createBasicType("Int", 64, dwarf::DW_ATE_signed);
488   auto Error = DIB.getOrCreateArray({Int});
489   auto Err = DIB.createFunction(
490       CU, "err", "", File, 1, Type, 1, DINode::FlagZero,
491       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized, nullptr,
492       nullptr, Error.get());
493   EXPECT_TRUE(Err->getThrownTypes().get() == Error.get());
494   DIB.finalize();
495 }
496 
497 TEST_F(IRBuilderTest, DIBuilder) {
498   IRBuilder<> Builder(BB);
499   DIBuilder DIB(*M);
500   auto File = DIB.createFile("F.CBL", "/");
501   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
502                                   DIB.createFile("F.CBL", "/"), "llvm-cobol74",
503                                   true, "", 0);
504   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
505   auto SP = DIB.createFunction(
506       CU, "foo", "", File, 1, Type, 1, DINode::FlagZero,
507       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
508   F->setSubprogram(SP);
509   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
510   auto BarSP = DIB.createFunction(
511       CU, "bar", "", File, 1, Type, 1, DINode::FlagZero,
512       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
513   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);
514   I->setDebugLoc(DebugLoc::get(2, 0, BadScope));
515   DIB.finalize();
516   EXPECT_TRUE(verifyModule(*M));
517 }
518 
519 TEST_F(IRBuilderTest, createArtificialSubprogram) {
520   IRBuilder<> Builder(BB);
521   DIBuilder DIB(*M);
522   auto File = DIB.createFile("main.c", "/");
523   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C, File, "clang",
524                                   /*isOptimized=*/true, /*Flags=*/"",
525                                   /*Runtime Version=*/0);
526   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
527   auto SP = DIB.createFunction(
528       CU, "foo", /*LinkageName=*/"", File,
529       /*LineNo=*/1, Type, /*ScopeLine=*/2, DINode::FlagZero,
530       DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
531   EXPECT_TRUE(SP->isDistinct());
532 
533   F->setSubprogram(SP);
534   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
535   ReturnInst *R = Builder.CreateRetVoid();
536   I->setDebugLoc(DebugLoc::get(3, 2, SP));
537   R->setDebugLoc(DebugLoc::get(4, 2, SP));
538   DIB.finalize();
539   EXPECT_FALSE(verifyModule(*M));
540 
541   Function *G = Function::Create(F->getFunctionType(),
542                                  Function::ExternalLinkage, "", M.get());
543   BasicBlock *GBB = BasicBlock::Create(Ctx, "", G);
544   Builder.SetInsertPoint(GBB);
545   I->removeFromParent();
546   Builder.Insert(I);
547   Builder.CreateRetVoid();
548   EXPECT_FALSE(verifyModule(*M));
549 
550   DISubprogram *GSP = DIBuilder::createArtificialSubprogram(F->getSubprogram());
551   EXPECT_EQ(SP->getFile(), GSP->getFile());
552   EXPECT_EQ(SP->getType(), GSP->getType());
553   EXPECT_EQ(SP->getLine(), GSP->getLine());
554   EXPECT_EQ(SP->getScopeLine(), GSP->getScopeLine());
555   EXPECT_TRUE(GSP->isDistinct());
556 
557   G->setSubprogram(GSP);
558   EXPECT_TRUE(verifyModule(*M));
559 
560   auto *InlinedAtNode =
561       DILocation::getDistinct(Ctx, GSP->getScopeLine(), 0, GSP);
562   DebugLoc DL = I->getDebugLoc();
563   DenseMap<const MDNode *, MDNode *> IANodes;
564   auto IA = DebugLoc::appendInlinedAt(DL, InlinedAtNode, Ctx, IANodes);
565   auto NewDL = DebugLoc::get(DL.getLine(), DL.getCol(), DL.getScope(), IA);
566   I->setDebugLoc(NewDL);
567   EXPECT_FALSE(verifyModule(*M));
568 
569   EXPECT_EQ("foo", SP->getName());
570   EXPECT_EQ("foo", GSP->getName());
571   EXPECT_FALSE(SP->isArtificial());
572   EXPECT_TRUE(GSP->isArtificial());
573 }
574 
575 TEST_F(IRBuilderTest, InsertExtractElement) {
576   IRBuilder<> Builder(BB);
577 
578   auto VecTy = VectorType::get(Builder.getInt64Ty(), 4);
579   auto Elt1 = Builder.getInt64(-1);
580   auto Elt2 = Builder.getInt64(-2);
581   Value *Vec = UndefValue::get(VecTy);
582   Vec = Builder.CreateInsertElement(Vec, Elt1, Builder.getInt8(1));
583   Vec = Builder.CreateInsertElement(Vec, Elt2, 2);
584   auto X1 = Builder.CreateExtractElement(Vec, 1);
585   auto X2 = Builder.CreateExtractElement(Vec, Builder.getInt32(2));
586   EXPECT_EQ(Elt1, X1);
587   EXPECT_EQ(Elt2, X2);
588 }
589 
590 TEST_F(IRBuilderTest, CreateGlobalStringPtr) {
591   IRBuilder<> Builder(BB);
592 
593   auto String1a = Builder.CreateGlobalStringPtr("TestString", "String1a");
594   auto String1b = Builder.CreateGlobalStringPtr("TestString", "String1b", 0);
595   auto String2 = Builder.CreateGlobalStringPtr("TestString", "String2", 1);
596   auto String3 = Builder.CreateGlobalString("TestString", "String3", 2);
597 
598   EXPECT_TRUE(String1a->getType()->getPointerAddressSpace() == 0);
599   EXPECT_TRUE(String1b->getType()->getPointerAddressSpace() == 0);
600   EXPECT_TRUE(String2->getType()->getPointerAddressSpace() == 1);
601   EXPECT_TRUE(String3->getType()->getPointerAddressSpace() == 2);
602 }
603 
604 TEST_F(IRBuilderTest, DebugLoc) {
605   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
606                                     /*isVarArg=*/false);
607   auto Callee =
608       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
609 
610   DIBuilder DIB(*M);
611   auto File = DIB.createFile("tmp.cpp", "/");
612   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
613                                   DIB.createFile("tmp.cpp", "/"), "", true, "",
614                                   0);
615   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
616   auto SP =
617       DIB.createFunction(CU, "foo", "foo", File, 1, SPType, 1, DINode::FlagZero,
618                          DISubprogram::SPFlagDefinition);
619   DebugLoc DL1 = DILocation::get(Ctx, 2, 0, SP);
620   DebugLoc DL2 = DILocation::get(Ctx, 3, 0, SP);
621 
622   auto BB2 = BasicBlock::Create(Ctx, "bb2", F);
623   auto Br = BranchInst::Create(BB2, BB);
624   Br->setDebugLoc(DL1);
625 
626   IRBuilder<> Builder(Ctx);
627   Builder.SetInsertPoint(Br);
628   EXPECT_EQ(DL1, Builder.getCurrentDebugLocation());
629   auto Call1 = Builder.CreateCall(Callee, None);
630   EXPECT_EQ(DL1, Call1->getDebugLoc());
631 
632   Call1->setDebugLoc(DL2);
633   Builder.SetInsertPoint(Call1->getParent(), Call1->getIterator());
634   EXPECT_EQ(DL2, Builder.getCurrentDebugLocation());
635   auto Call2 = Builder.CreateCall(Callee, None);
636   EXPECT_EQ(DL2, Call2->getDebugLoc());
637 
638   DIB.finalize();
639 }
640 
641 TEST_F(IRBuilderTest, DIImportedEntity) {
642   IRBuilder<> Builder(BB);
643   DIBuilder DIB(*M);
644   auto F = DIB.createFile("F.CBL", "/");
645   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
646                                   F, "llvm-cobol74",
647                                   true, "", 0);
648   DIB.createImportedDeclaration(CU, nullptr, F, 1);
649   DIB.createImportedDeclaration(CU, nullptr, F, 1);
650   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
651   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
652   DIB.finalize();
653   EXPECT_TRUE(verifyModule(*M));
654   EXPECT_TRUE(CU->getImportedEntities().size() == 2);
655 }
656 
657 //  0: #define M0 V0          <-- command line definition
658 //  0: main.c                 <-- main file
659 //     3:   #define M1 V1     <-- M1 definition in main.c
660 //     5:   #include "file.h" <-- inclusion of file.h from main.c
661 //          1: #define M2     <-- M2 definition in file.h with no value
662 //     7:   #undef M1 V1      <-- M1 un-definition in main.c
663 TEST_F(IRBuilderTest, DIBuilderMacro) {
664   IRBuilder<> Builder(BB);
665   DIBuilder DIB(*M);
666   auto File1 = DIB.createFile("main.c", "/");
667   auto File2 = DIB.createFile("file.h", "/");
668   auto CU = DIB.createCompileUnit(
669       dwarf::DW_LANG_C, DIB.createFile("main.c", "/"), "llvm-c", true, "", 0);
670   auto MDef0 =
671       DIB.createMacro(nullptr, 0, dwarf::DW_MACINFO_define, "M0", "V0");
672   auto TMF1 = DIB.createTempMacroFile(nullptr, 0, File1);
673   auto MDef1 = DIB.createMacro(TMF1, 3, dwarf::DW_MACINFO_define, "M1", "V1");
674   auto TMF2 = DIB.createTempMacroFile(TMF1, 5, File2);
675   auto MDef2 = DIB.createMacro(TMF2, 1, dwarf::DW_MACINFO_define, "M2");
676   auto MUndef1 = DIB.createMacro(TMF1, 7, dwarf::DW_MACINFO_undef, "M1");
677 
678   EXPECT_EQ(dwarf::DW_MACINFO_define, MDef1->getMacinfoType());
679   EXPECT_EQ(3u, MDef1->getLine());
680   EXPECT_EQ("M1", MDef1->getName());
681   EXPECT_EQ("V1", MDef1->getValue());
682 
683   EXPECT_EQ(dwarf::DW_MACINFO_undef, MUndef1->getMacinfoType());
684   EXPECT_EQ(7u, MUndef1->getLine());
685   EXPECT_EQ("M1", MUndef1->getName());
686   EXPECT_EQ("", MUndef1->getValue());
687 
688   EXPECT_EQ(dwarf::DW_MACINFO_start_file, TMF2->getMacinfoType());
689   EXPECT_EQ(5u, TMF2->getLine());
690   EXPECT_EQ(File2, TMF2->getFile());
691 
692   DIB.finalize();
693 
694   SmallVector<Metadata *, 4> Elements;
695   Elements.push_back(MDef2);
696   auto MF2 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 5, File2,
697                               DIB.getOrCreateMacroArray(Elements));
698 
699   Elements.clear();
700   Elements.push_back(MDef1);
701   Elements.push_back(MF2);
702   Elements.push_back(MUndef1);
703   auto MF1 = DIMacroFile::get(Ctx, dwarf::DW_MACINFO_start_file, 0, File1,
704                               DIB.getOrCreateMacroArray(Elements));
705 
706   Elements.clear();
707   Elements.push_back(MDef0);
708   Elements.push_back(MF1);
709   auto MN0 = MDTuple::get(Ctx, Elements);
710   EXPECT_EQ(MN0, CU->getRawMacros());
711 
712   Elements.clear();
713   Elements.push_back(MDef1);
714   Elements.push_back(MF2);
715   Elements.push_back(MUndef1);
716   auto MN1 = MDTuple::get(Ctx, Elements);
717   EXPECT_EQ(MN1, MF1->getRawElements());
718 
719   Elements.clear();
720   Elements.push_back(MDef2);
721   auto MN2 = MDTuple::get(Ctx, Elements);
722   EXPECT_EQ(MN2, MF2->getRawElements());
723   EXPECT_TRUE(verifyModule(*M));
724 }
725 }
726