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