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