[unittests] demonstrate User::replaceUsesOfWith() breaking CallBrInst

[nickdesaulniers]

Summary

Also, refactor CallBrInstruction IRTest. Run via:

$ ninja IRTests
$ ./unittests/IR/IRTests --gtest_filter=InstructionsTest.CallBrInstruction

Link: https://github.com/ClangBuiltLinux/linux/issues/896

[nickdesaulniers]

whoops, didn't mean to commit all that, let me drop some of this.

[nickdesaulniers]

• drop mistakenly committed hacked up files

[nickdesaulniers]

• git-clang-format HEAD~2

[nickdesaulniers]

Can't land this test as is, because it would be red, due to User::replaceUsesOfWith() not updating the asm's argparam.

[nickdesaulniers]

• I hate phab

[nickdesaulniers]

F!#$ I updated the wrong phab link!!!!!!!!!!!

[nickdesaulniers]

• restore to rebased version

[nickdesaulniers]

This is no longer an issue after https://github.com/llvm/llvm-project/commit/2a721374aef3 since we now use !i placeholders to denote that these inputs are implicit; they're no longer listed twice in the operand list.

llvm/unittests/IR/InstructionsTest.cpp

TEST(InstructionsTest, FNegInstruction) {
   EXPECT_FALSE(FNeg->hasAllowReciprocal());
   EXPECT_FALSE(FNeg->hasAllowContract());
   EXPECT_FALSE(FNeg->hasAllowReassoc());
   EXPECT_FALSE(FNeg->hasApproxFunc());
   FAdd->deleteValue();
   FNeg->deleteValue();
 }
 
+void VerifyCallBr(const CallBrInst &CBI, const BasicBlock &Expected,
+                  const std::string &F) {
+  BlockAddress *IndirectBA = BlockAddress::get(CBI.getIndirectDest(0));
+  BlockAddress *ArgBA = cast<BlockAddress>(CBI.getArgOperand(0));
+  EXPECT_EQ(IndirectBA, ArgBA)
+      << "After " << F << ", callbr had an indirect destination of '"
+      << CBI.getIndirectDest(0)->getName() << "', but a argument of '"
+      << ArgBA->getBasicBlock()->getName() << "'. These should always match:\n"
+      << CBI;
+  EXPECT_EQ(IndirectBA->getBasicBlock(), &Expected);
+  EXPECT_EQ(ArgBA->getBasicBlock(), &Expected);
+}
+
 TEST(InstructionsTest, CallBrInstruction) {
   LLVMContext Context;
   std::unique_ptr<Module> M = parseIR(Context, R"(
 define void @foo() {
 entry:
-  callbr void asm sideeffect "// XXX: ${0:l}", "X"(i8* blockaddress(@foo, %branch_test.exit))
+  callbr void asm sideeffect "", "X"(i8* blockaddress(@foo, %branch_test.exit))
           to label %land.rhs.i [label %branch_test.exit]
 
 land.rhs.i:
   br label %branch_test.exit
 
 branch_test.exit:
-  %0 = phi i1 [ true, %entry ], [ false, %land.rhs.i ]
-  br i1 %0, label %if.end, label %if.then
+  br label %if.then
 
 if.then:
   ret void
-
-if.end:
-  ret void
 }
 )");
   Function *Foo = M->getFunction("foo");
   auto BBs = Foo->getBasicBlockList().begin();
   CallBrInst &CBI = cast<CallBrInst>(BBs->front());
   ++BBs;
   ++BBs;
   BasicBlock &BranchTestExit = *BBs;
   ++BBs;
   BasicBlock &IfThen = *BBs;
 
   // Test that setting the first indirect destination of callbr updates the dest
   EXPECT_EQ(&BranchTestExit, CBI.getIndirectDest(0));
   CBI.setIndirectDest(0, &IfThen);
   EXPECT_EQ(&IfThen, CBI.getIndirectDest(0));
 
   // Further, test that changing the indirect destination updates the arg
   // operand to use the block address of the new indirect destination basic
   // block. This is a critical invariant of CallBrInst.
-  BlockAddress *IndirectBA = BlockAddress::get(CBI.getIndirectDest(0));
-  BlockAddress *ArgBA = cast<BlockAddress>(CBI.getArgOperand(0));
-  EXPECT_EQ(IndirectBA, ArgBA)
-      << "After setting the indirect destination, callbr had an indirect "
-         "destination of '"
-      << CBI.getIndirectDest(0)->getName() << "', but a argument of '"
-      << ArgBA->getBasicBlock()->getName() << "'. These should always match:\n"
-      << CBI;
-  EXPECT_EQ(IndirectBA->getBasicBlock(), &IfThen);
-  EXPECT_EQ(ArgBA->getBasicBlock(), &IfThen);
+  VerifyCallBr(CBI, IfThen, "CallBrInst::setIndirectDest()");
+
+  // Now try changing it back with User::replaceUsesOfWith().
+  CBI.replaceUsesOfWith(CBI.getIndirectDest(0), &BranchTestExit);
+  VerifyCallBr(CBI, BranchTestExit, "User::replaceUsesOfWith()");
 }
 
 TEST(InstructionsTest, UnaryOperator) {
   LLVMContext Context;
   IRBuilder<> Builder(Context);
   Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0);
   Value *F = Builder.CreateFNeg(I);