llvm/unittests/IR/BasicBlockTest.cpp

   1 //===- llvm/unittest/IR/BasicBlockTest.cpp - BasicBlock unit 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/BasicBlock.h"
  10 #include "llvm/ADT/STLExtras.h"
  11 #include "llvm/AsmParser/Parser.h"
  12 #include "llvm/IR/Function.h"
  13 #include "llvm/IR/IRBuilder.h"
  14 #include "llvm/IR/Instructions.h"
  15 #include "llvm/IR/LLVMContext.h"
  16 #include "llvm/IR/Module.h"
  17 #include "llvm/IR/NoFolder.h"
  18 #include "llvm/IR/Verifier.h"
  19 #include "llvm/Support/SourceMgr.h"
  20 #include "gmock/gmock-matchers.h"
  21 #include "gtest/gtest.h"
  22 #include <memory>
  23
  24 namespace llvm {
  25 namespace {
  26
  27 TEST(BasicBlockTest, PhiRange) {
  28   LLVMContext Context;
  29
  30   // Create the main block.
  31   std::unique_ptr<BasicBlock> BB(BasicBlock::Create(Context));
  32
  33   // Create some predecessors of it.
  34   std::unique_ptr<BasicBlock> BB1(BasicBlock::Create(Context));
  35   BranchInst::Create(BB.get(), BB1.get());
  36   std::unique_ptr<BasicBlock> BB2(BasicBlock::Create(Context));
  37   BranchInst::Create(BB.get(), BB2.get());
  38
  39   // Make sure this doesn't crash if there are no phis.
  40   int PhiCount = 0;
  41   for (auto &PN : BB->phis()) {
  42     (void)PN;
  43     PhiCount++;
  44   }
  45   ASSERT_EQ(PhiCount, 0) << "empty block should have no phis";
  46
  47   // Make it a cycle.
  48   auto *BI = BranchInst::Create(BB.get(), BB.get());
  49
  50   // Now insert some PHI nodes.
  51   auto *Int32Ty = Type::getInt32Ty(Context);
  52   auto *P1 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.1",
  53                              BI->getIterator());
  54   auto *P2 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.2",
  55                              BI->getIterator());
  56   auto *P3 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.3",
  57                              BI->getIterator());
  58
  59   // Some non-PHI nodes.
  60   auto *Sum = BinaryOperator::CreateAdd(P1, P2, "sum", BI->getIterator());
  61
  62   // Now wire up the incoming values that are interesting.
  63   P1->addIncoming(P2, BB.get());
  64   P2->addIncoming(P1, BB.get());
  65   P3->addIncoming(Sum, BB.get());
  66
  67   // Finally, let's iterate them, which is the thing we're trying to test.
  68   // We'll use this to wire up the rest of the incoming values.
  69   for (auto &PN : BB->phis()) {
  70     PN.addIncoming(PoisonValue::get(Int32Ty), BB1.get());
  71     PN.addIncoming(PoisonValue::get(Int32Ty), BB2.get());
  72   }
  73
  74   // Test that we can use const iterators and generally that the iterators
  75   // behave like iterators.
  76   BasicBlock::const_phi_iterator CI;
  77   CI = BB->phis().begin();
  78   EXPECT_NE(CI, BB->phis().end());
  79
  80   // Test that filtering iterators work with basic blocks.
  81   auto isPhi = [](Instruction &I) { return isa<PHINode>(&I); };
  82   auto Phis = make_filter_range(*BB, isPhi);
  83   auto ReversedPhis = reverse(make_filter_range(*BB, isPhi));
  84   EXPECT_EQ(std::distance(Phis.begin(), Phis.end()), 3);
  85   EXPECT_EQ(&*Phis.begin(), P1);
  86   EXPECT_EQ(std::distance(ReversedPhis.begin(), ReversedPhis.end()), 3);
  87   EXPECT_EQ(&*ReversedPhis.begin(), P3);
  88
  89   // And iterate a const range.
  90   for (const auto &PN : const_cast<const BasicBlock *>(BB.get())->phis()) {
  91     EXPECT_EQ(BB.get(), PN.getIncomingBlock(0));
  92     EXPECT_EQ(BB1.get(), PN.getIncomingBlock(1));
  93     EXPECT_EQ(BB2.get(), PN.getIncomingBlock(2));
  94   }
  95 }
  96
  97 #define CHECK_ITERATORS(Range1, Range2)                                        \
  98   EXPECT_EQ(std::distance(Range1.begin(), Range1.end()),                       \
  99             std::distance(Range2.begin(), Range2.end()));                      \
 100   for (auto Pair : zip(Range1, Range2))                                        \
 101     EXPECT_EQ(&std::get<0>(Pair), std::get<1>(Pair));
 102
 103 TEST(BasicBlockTest, TestInstructionsWithoutDebug) {
 104   LLVMContext Ctx;
 105
 106   Module *M = new Module("MyModule", Ctx);
 107   Type *ArgTy1[] = {PointerType::getUnqual(Ctx)};
 108   FunctionType *FT = FunctionType::get(Type::getVoidTy(Ctx), ArgTy1, false);
 109   Argument *V = new Argument(Type::getInt32Ty(Ctx));
 110   Function *F = Function::Create(FT, Function::ExternalLinkage, "", M);
 111
 112   Function *DbgDeclare =
 113       Intrinsic::getOrInsertDeclaration(M, Intrinsic::dbg_declare);
 114   Function *DbgValue =
 115       Intrinsic::getOrInsertDeclaration(M, Intrinsic::dbg_value);
 116   Value *DIV = MetadataAsValue::get(Ctx, (Metadata *)nullptr);
 117   SmallVector<Value *, 3> Args = {DIV, DIV, DIV};
 118
 119   BasicBlock *BB1 = BasicBlock::Create(Ctx, "", F);
 120   const BasicBlock *BBConst = BB1;
 121   IRBuilder<> Builder1(BB1);
 122
 123   AllocaInst *Var = Builder1.CreateAlloca(Builder1.getInt8Ty());
 124   Builder1.CreateCall(DbgValue, Args);
 125   Instruction *AddInst = cast<Instruction>(Builder1.CreateAdd(V, V));
 126   Instruction *MulInst = cast<Instruction>(Builder1.CreateMul(AddInst, V));
 127   Builder1.CreateCall(DbgDeclare, Args);
 128   Instruction *SubInst = cast<Instruction>(Builder1.CreateSub(MulInst, V));
 129
 130   SmallVector<Instruction *, 4> Exp = {Var, AddInst, MulInst, SubInst};
 131   CHECK_ITERATORS(BB1->instructionsWithoutDebug(), Exp);
 132   CHECK_ITERATORS(BBConst->instructionsWithoutDebug(), Exp);
 133
 134   EXPECT_EQ(static_cast<size_t>(BB1->sizeWithoutDebug()), Exp.size());
 135   EXPECT_EQ(static_cast<size_t>(BBConst->sizeWithoutDebug()), Exp.size());
 136
 137   delete M;
 138   delete V;
 139 }
 140
 141 TEST(BasicBlockTest, ComesBefore) {
 142   const char *ModuleString = R"(define i32 @f(i32 %x) {
 143                                   %add = add i32 %x, 42
 144                                   ret i32 %add
 145                                 })";
 146   LLVMContext Ctx;
 147   SMDiagnostic Err;
 148   auto M = parseAssemblyString(ModuleString, Err, Ctx);
 149   ASSERT_TRUE(M.get());
 150
 151   Function *F = M->getFunction("f");
 152   BasicBlock &BB = F->front();
 153   BasicBlock::iterator I = BB.begin();
 154   Instruction *Add = &*I++;
 155   Instruction *Ret = &*I++;
 156
 157   // Intentionally duplicated to verify cached and uncached are the same.
 158   EXPECT_FALSE(BB.isInstrOrderValid());
 159   EXPECT_FALSE(Add->comesBefore(Add));
 160   EXPECT_TRUE(BB.isInstrOrderValid());
 161   EXPECT_FALSE(Add->comesBefore(Add));
 162   BB.invalidateOrders();
 163   EXPECT_FALSE(BB.isInstrOrderValid());
 164   EXPECT_TRUE(Add->comesBefore(Ret));
 165   EXPECT_TRUE(BB.isInstrOrderValid());
 166   EXPECT_TRUE(Add->comesBefore(Ret));
 167   BB.invalidateOrders();
 168   EXPECT_FALSE(Ret->comesBefore(Add));
 169   EXPECT_FALSE(Ret->comesBefore(Add));
 170   BB.invalidateOrders();
 171   EXPECT_FALSE(Ret->comesBefore(Ret));
 172   EXPECT_FALSE(Ret->comesBefore(Ret));
 173 }
 174
 175 class InstrOrderInvalidationTest : public ::testing::Test {
 176 protected:
 177   void SetUp() override {
 178     M.reset(new Module("MyModule", Ctx));
 179     Nop = Intrinsic::getOrInsertDeclaration(M.get(), Intrinsic::donothing);
 180     FunctionType *FT = FunctionType::get(Type::getVoidTy(Ctx), {}, false);
 181     Function *F = Function::Create(FT, Function::ExternalLinkage, "foo", *M);
 182     BB = BasicBlock::Create(Ctx, "entry", F);
 183
 184     IRBuilder<> Builder(BB);
 185     I1 = Builder.CreateCall(Nop);
 186     I2 = Builder.CreateCall(Nop);
 187     I3 = Builder.CreateCall(Nop);
 188     Ret = Builder.CreateRetVoid();
 189   }
 190
 191   LLVMContext Ctx;
 192   std::unique_ptr<Module> M;
 193   Function *Nop = nullptr;
 194   BasicBlock *BB = nullptr;
 195   Instruction *I1 = nullptr;
 196   Instruction *I2 = nullptr;
 197   Instruction *I3 = nullptr;
 198   Instruction *Ret = nullptr;
 199 };
 200
 201 TEST_F(InstrOrderInvalidationTest, InsertInvalidation) {
 202   EXPECT_FALSE(BB->isInstrOrderValid());
 203   EXPECT_TRUE(I1->comesBefore(I2));
 204   EXPECT_TRUE(BB->isInstrOrderValid());
 205   EXPECT_TRUE(I2->comesBefore(I3));
 206   EXPECT_TRUE(I3->comesBefore(Ret));
 207   EXPECT_TRUE(BB->isInstrOrderValid());
 208
 209   // Invalidate orders.
 210   IRBuilder<> Builder(BB, I2->getIterator());
 211   Instruction *I1a = Builder.CreateCall(Nop);
 212   EXPECT_FALSE(BB->isInstrOrderValid());
 213   EXPECT_TRUE(I1->comesBefore(I1a));
 214   EXPECT_TRUE(BB->isInstrOrderValid());
 215   EXPECT_TRUE(I1a->comesBefore(I2));
 216   EXPECT_TRUE(I2->comesBefore(I3));
 217   EXPECT_TRUE(I3->comesBefore(Ret));
 218   EXPECT_TRUE(BB->isInstrOrderValid());
 219 }
 220
 221 TEST_F(InstrOrderInvalidationTest, SpliceInvalidation) {
 222   EXPECT_TRUE(I1->comesBefore(I2));
 223   EXPECT_TRUE(I2->comesBefore(I3));
 224   EXPECT_TRUE(I3->comesBefore(Ret));
 225   EXPECT_TRUE(BB->isInstrOrderValid());
 226
 227   // Use Instruction::moveBefore, which uses splice.
 228   I2->moveBefore(I1);
 229   EXPECT_FALSE(BB->isInstrOrderValid());
 230
 231   EXPECT_TRUE(I2->comesBefore(I1));
 232   EXPECT_TRUE(I1->comesBefore(I3));
 233   EXPECT_TRUE(I3->comesBefore(Ret));
 234   EXPECT_TRUE(BB->isInstrOrderValid());
 235 }
 236
 237 TEST_F(InstrOrderInvalidationTest, RemoveNoInvalidation) {
 238   // Cache the instruction order.
 239   EXPECT_FALSE(BB->isInstrOrderValid());
 240   EXPECT_TRUE(I1->comesBefore(I2));
 241   EXPECT_TRUE(BB->isInstrOrderValid());
 242
 243   // Removing does not invalidate instruction order.
 244   I2->removeFromParent();
 245   I2->deleteValue();
 246   I2 = nullptr;
 247   EXPECT_TRUE(BB->isInstrOrderValid());
 248   EXPECT_TRUE(I1->comesBefore(I3));
 249   EXPECT_EQ(std::next(I1->getIterator()), I3->getIterator());
 250 }
 251
 252 TEST_F(InstrOrderInvalidationTest, EraseNoInvalidation) {
 253   // Cache the instruction order.
 254   EXPECT_FALSE(BB->isInstrOrderValid());
 255   EXPECT_TRUE(I1->comesBefore(I2));
 256   EXPECT_TRUE(BB->isInstrOrderValid());
 257
 258   // Removing does not invalidate instruction order.
 259   I2->eraseFromParent();
 260   I2 = nullptr;
 261   EXPECT_TRUE(BB->isInstrOrderValid());
 262   EXPECT_TRUE(I1->comesBefore(I3));
 263   EXPECT_EQ(std::next(I1->getIterator()), I3->getIterator());
 264 }
 265
 266 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
 267   SMDiagnostic Err;
 268   std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
 269   if (!Mod)
 270     Err.print(__FILE__, errs());
 271   return Mod;
 272 }
 273
 274 TEST(BasicBlockTest, SpliceFromBB) {
 275   LLVMContext Ctx;
 276   std::unique_ptr<Module> M = parseIR(Ctx, R"(
 277     define void @f(i32 %a) {
 278      from:
 279        %fromInstr1 = add i32 %a, %a
 280        %fromInstr2 = sub i32 %a, %a
 281        br label %to
 282
 283      to:
 284        %toInstr1 = mul i32 %a, %a
 285        %toInstr2 = sdiv i32 %a, %a
 286        ret void
 287     }
 288 )");
 289   Function *F = &*M->begin();
 290   auto BBIt = F->begin();
 291   BasicBlock *FromBB = &*BBIt++;
 292   BasicBlock *ToBB = &*BBIt++;
 293
 294   auto FromBBIt = FromBB->begin();
 295   Instruction *FromI1 = &*FromBBIt++;
 296   Instruction *FromI2 = &*FromBBIt++;
 297   Instruction *FromBr = &*FromBBIt++;
 298
 299   auto ToBBIt = ToBB->begin();
 300   Instruction *ToI1 = &*ToBBIt++;
 301   Instruction *ToI2 = &*ToBBIt++;
 302   Instruction *ToRet = &*ToBBIt++;
 303   ToBB->splice(ToI1->getIterator(), FromBB);
 304
 305   EXPECT_TRUE(FromBB->empty());
 306
 307   auto It = ToBB->begin();
 308   EXPECT_EQ(&*It++, FromI1);
 309   EXPECT_EQ(&*It++, FromI2);
 310   EXPECT_EQ(&*It++, FromBr);
 311   EXPECT_EQ(&*It++, ToI1);
 312   EXPECT_EQ(&*It++, ToI2);
 313   EXPECT_EQ(&*It++, ToRet);
 314 }
 315
 316 TEST(BasicBlockTest, SpliceOneInstr) {
 317   LLVMContext Ctx;
 318   std::unique_ptr<Module> M = parseIR(Ctx, R"(
 319     define void @f(i32 %a) {
 320      from:
 321        %fromInstr1 = add i32 %a, %a
 322        %fromInstr2 = sub i32 %a, %a
 323        br label %to
 324
 325      to:
 326        %toInstr1 = mul i32 %a, %a
 327        %toInstr2 = sdiv i32 %a, %a
 328        ret void
 329     }
 330 )");
 331   Function *F = &*M->begin();
 332   auto BBIt = F->begin();
 333   BasicBlock *FromBB = &*BBIt++;
 334   BasicBlock *ToBB = &*BBIt++;
 335
 336   auto FromBBIt = FromBB->begin();
 337   Instruction *FromI1 = &*FromBBIt++;
 338   Instruction *FromI2 = &*FromBBIt++;
 339   Instruction *FromBr = &*FromBBIt++;
 340
 341   auto ToBBIt = ToBB->begin();
 342   Instruction *ToI1 = &*ToBBIt++;
 343   Instruction *ToI2 = &*ToBBIt++;
 344   Instruction *ToRet = &*ToBBIt++;
 345   ToBB->splice(ToI1->getIterator(), FromBB, FromI2->getIterator());
 346
 347   EXPECT_EQ(FromBB->size(), 2u);
 348   EXPECT_EQ(ToBB->size(), 4u);
 349
 350   auto It = FromBB->begin();
 351   EXPECT_EQ(&*It++, FromI1);
 352   EXPECT_EQ(&*It++, FromBr);
 353
 354   It = ToBB->begin();
 355   EXPECT_EQ(&*It++, FromI2);
 356   EXPECT_EQ(&*It++, ToI1);
 357   EXPECT_EQ(&*It++, ToI2);
 358   EXPECT_EQ(&*It++, ToRet);
 359 }
 360
 361 TEST(BasicBlockTest, SpliceOneInstrWhenFromIsSameAsTo) {
 362   LLVMContext Ctx;
 363   std::unique_ptr<Module> M = parseIR(Ctx, R"(
 364     define void @f(i32 %a) {
 365      bb:
 366        %instr1 = add i32 %a, %a
 367        %instr2 = sub i32 %a, %a
 368        ret void
 369     }
 370 )");
 371   Function *F = &*M->begin();
 372   auto BBIt = F->begin();
 373   BasicBlock *BB = &*BBIt++;
 374
 375   auto It = BB->begin();
 376   Instruction *Instr1 = &*It++;
 377   Instruction *Instr2 = &*It++;
 378   Instruction *Ret = &*It++;
 379
 380   // According to ilist's splice() a single-element splice where dst == src
 381   // should be a noop.
 382   BB->splice(Instr1->getIterator(), BB, Instr1->getIterator());
 383
 384   It = BB->begin();
 385   EXPECT_EQ(&*It++, Instr1);
 386   EXPECT_EQ(&*It++, Instr2);
 387   EXPECT_EQ(&*It++, Ret);
 388   EXPECT_EQ(BB->size(), 3u);
 389 }
 390
 391 TEST(BasicBlockTest, SpliceLastInstr) {
 392   LLVMContext Ctx;
 393   std::unique_ptr<Module> M = parseIR(Ctx, R"(
 394     define void @f(i32 %a) {
 395      from:
 396        %fromInstr1 = add i32 %a, %a
 397        %fromInstr2 = sub i32 %a, %a
 398        br label %to
 399
 400      to:
 401        %toInstr1 = mul i32 %a, %a
 402        %toInstr2 = sdiv i32 %a, %a
 403        ret void
 404     }
 405 )");
 406   Function *F = &*M->begin();
 407   auto BBIt = F->begin();
 408   BasicBlock *FromBB = &*BBIt++;
 409   BasicBlock *ToBB = &*BBIt++;
 410
 411   auto FromBBIt = FromBB->begin();
 412   Instruction *FromI1 = &*FromBBIt++;
 413   Instruction *FromI2 = &*FromBBIt++;
 414   Instruction *FromBr = &*FromBBIt++;
 415
 416   auto ToBBIt = ToBB->begin();
 417   Instruction *ToI1 = &*ToBBIt++;
 418   Instruction *ToI2 = &*ToBBIt++;
 419   Instruction *ToRet = &*ToBBIt++;
 420   ToBB->splice(ToI1->getIterator(), FromBB, FromI2->getIterator(),
 421                FromBr->getIterator());
 422
 423   EXPECT_EQ(FromBB->size(), 2u);
 424   auto It = FromBB->begin();
 425   EXPECT_EQ(&*It++, FromI1);
 426   EXPECT_EQ(&*It++, FromBr);
 427
 428   EXPECT_EQ(ToBB->size(), 4u);
 429   It = ToBB->begin();
 430   EXPECT_EQ(&*It++, FromI2);
 431   EXPECT_EQ(&*It++, ToI1);
 432   EXPECT_EQ(&*It++, ToI2);
 433   EXPECT_EQ(&*It++, ToRet);
 434 }
 435
 436 TEST(BasicBlockTest, SpliceInstrRange) {
 437   LLVMContext Ctx;
 438   std::unique_ptr<Module> M = parseIR(Ctx, R"(
 439     define void @f(i32 %a) {
 440      from:
 441        %fromInstr1 = add i32 %a, %a
 442        %fromInstr2 = sub i32 %a, %a
 443        br label %to
 444
 445      to:
 446        %toInstr1 = mul i32 %a, %a
 447        %toInstr2 = sdiv i32 %a, %a
 448        ret void
 449     }
 450 )");
 451   Function *F = &*M->begin();
 452   auto BBIt = F->begin();
 453   BasicBlock *FromBB = &*BBIt++;
 454   BasicBlock *ToBB = &*BBIt++;
 455
 456   auto FromBBIt = FromBB->begin();
 457   Instruction *FromI1 = &*FromBBIt++;
 458   Instruction *FromI2 = &*FromBBIt++;
 459   Instruction *FromBr = &*FromBBIt++;
 460
 461   auto ToBBIt = ToBB->begin();
 462   Instruction *ToI1 = &*ToBBIt++;
 463   Instruction *ToI2 = &*ToBBIt++;
 464   Instruction *ToRet = &*ToBBIt++;
 465   ToBB->splice(ToI2->getIterator(), FromBB, FromBB->begin(), FromBB->end());
 466
 467   EXPECT_EQ(FromBB->size(), 0u);
 468
 469   EXPECT_EQ(ToBB->size(), 6u);
 470   auto It = ToBB->begin();
 471   EXPECT_EQ(&*It++, ToI1);
 472   EXPECT_EQ(&*It++, FromI1);
 473   EXPECT_EQ(&*It++, FromI2);
 474   EXPECT_EQ(&*It++, FromBr);
 475   EXPECT_EQ(&*It++, ToI2);
 476   EXPECT_EQ(&*It++, ToRet);
 477 }
 478
 479 #ifdef EXPENSIVE_CHECKS
 480 TEST(BasicBlockTest, SpliceEndBeforeBegin) {
 481   LLVMContext Ctx;
 482   std::unique_ptr<Module> M = parseIR(Ctx, R"(
 483     define void @f(i32 %a) {
 484      from:
 485        %fromInstr1 = add i32 %a, %a
 486        %fromInstr2 = sub i32 %a, %a
 487        br label %to
 488
 489      to:
 490        %toInstr1 = mul i32 %a, %a
 491        %toInstr2 = sdiv i32 %a, %a
 492        ret void
 493     }
 494 )");
 495   Function *F = &*M->begin();
 496   auto BBIt = F->begin();
 497   BasicBlock *FromBB = &*BBIt++;
 498   BasicBlock *ToBB = &*BBIt++;
 499
 500   auto FromBBIt = FromBB->begin();
 501   Instruction *FromI1 = &*FromBBIt++;
 502   Instruction *FromI2 = &*FromBBIt++;
 503
 504   auto ToBBIt = ToBB->begin();
 505   Instruction *ToI2 = &*ToBBIt++;
 506
 507   EXPECT_DEATH(ToBB->splice(ToI2->getIterator(), FromBB, FromI2->getIterator(),
 508                             FromI1->getIterator()),
 509                "FromBeginIt not before FromEndIt!");
 510 }
 511 #endif //EXPENSIVE_CHECKS
 512
 513 TEST(BasicBlockTest, EraseRange) {
 514   LLVMContext Ctx;
 515   std::unique_ptr<Module> M = parseIR(Ctx, R"(
 516     define void @f(i32 %a) {
 517      bb0:
 518        %instr1 = add i32 %a, %a
 519        %instr2 = sub i32 %a, %a
 520        ret void
 521     }
 522 )");
 523   Function *F = &*M->begin();
 524
 525   auto BB0It = F->begin();
 526   BasicBlock *BB0 = &*BB0It;
 527
 528   auto It = BB0->begin();
 529   Instruction *Instr1 = &*It++;
 530   Instruction *Instr2 = &*It++;
 531
 532   EXPECT_EQ(BB0->size(), 3u);
 533
 534   // Erase no instruction
 535   BB0->erase(Instr1->getIterator(), Instr1->getIterator());
 536   EXPECT_EQ(BB0->size(), 3u);
 537
 538   // Erase %instr1
 539   BB0->erase(Instr1->getIterator(), Instr2->getIterator());
 540   EXPECT_EQ(BB0->size(), 2u);
 541   EXPECT_EQ(&*BB0->begin(), Instr2);
 542
 543   // Erase all instructions
 544   BB0->erase(BB0->begin(), BB0->end());
 545   EXPECT_TRUE(BB0->empty());
 546 }
 547
 548 TEST(BasicBlockTest, DiscardValueNames) {
 549   const char *ModuleString = "declare void @f(i32 %dangling)";
 550   SMDiagnostic Err;
 551   LLVMContext Ctx;
 552   { // Scope of M.
 553     auto M = parseAssemblyString(ModuleString, Err, Ctx);
 554     ASSERT_TRUE(M.get());
 555     EXPECT_FALSE(Ctx.shouldDiscardValueNames());
 556   }
 557   { // Scope of M.
 558     auto M = parseAssemblyString(ModuleString, Err, Ctx);
 559     ASSERT_TRUE(M.get());
 560     Ctx.setDiscardValueNames(true);
 561   }
 562 }
 563
 564 TEST(BasicBlockTest, DiscardValueNames2) {
 565   SMDiagnostic Err;
 566   LLVMContext Ctx;
 567   Module M("Mod", Ctx);
 568   auto FTy = FunctionType::get(Type::getVoidTy(M.getContext()),
 569                                {Type::getInt32Ty(Ctx)}, /*isVarArg=*/false);
 570   { // Scope of F.
 571     Function *F = Function::Create(FTy, Function::ExternalLinkage, "f", &M);
 572     F->getArg(0)->setName("dangling");
 573     F->removeFromParent();
 574     EXPECT_FALSE(Ctx.shouldDiscardValueNames());
 575     delete F;
 576   }
 577   { // Scope of F.
 578     Function *F = Function::Create(FTy, Function::ExternalLinkage, "f", &M);
 579     F->getArg(0)->setName("dangling");
 580     F->removeFromParent();
 581     Ctx.setDiscardValueNames(true);
 582     delete F;
 583   }
 584 }
 585
 586 } // End anonymous namespace.
 587 } // End llvm namespace.