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