[LoopUnswitch] Trivial simplification: remove trivial dead condition after unswitch

[skatkov]

Summary

Non trivial loop unswitch can keep the dead condition instruction.
CL adds trivial dead code elimination for unused condition.

[asbirlea]

I think in general the pass is not trying to do DCE too, but here it looks cheap to clean the dead code left by the conditional.
Please have MSSA updated though.

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

1156

RecursivelyDeleteTriviallyDeadInstructions(ClonedConditionToErase, nullptr, MSSAU);

[skatkov]

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

1156

Thanks, will do before landing.

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/GenericDomTree.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <algorithm>
 #include <cassert>
 #include <iterator>
 #include <numeric>
 #include <utility>
 
for (auto *SuccBB : successors(ParentBB)) {
 
     ClonedSuccBB->removePredecessor(ClonedParentBB,
                                     /*KeepOneInputPHIs*/ true);
   }
 
   // Replace the cloned branch with an unconditional branch to the cloned
   // unswitched successor.
   auto *ClonedSuccBB = cast<BasicBlock>(VMap.lookup(UnswitchedSuccBB));
-  ClonedParentBB->getTerminator()->eraseFromParent();
+  Instruction *ClonedTerminator = ClonedParentBB->getTerminator();
+  // Trivial Simplification. If Terminator is a conditional branch and
+  // condition becomes dead - erase it.
+  Value *ClonedConditionToErase = nullptr;
+  if (auto *BI = dyn_cast<BranchInst>(ClonedTerminator))
+    ClonedConditionToErase = BI->getCondition();
+  else if (auto *SI = dyn_cast<SwitchInst>(ClonedTerminator))
+    ClonedConditionToErase = SI->getCondition();
+
+  ClonedTerminator->eraseFromParent();
   BranchInst::Create(ClonedSuccBB, ClonedParentBB);
 
+  if (ClonedConditionToErase)
+    RecursivelyDeleteTriviallyDeadInstructions(ClonedConditionToErase, nullptr,
+                                               MSSAU);
+
   // If there are duplicate entries in the PHI nodes because of multiple edges
   // to the unswitched successor, we need to nuke all but one as we replaced it
   // with a direct branch.
   for (PHINode &PN : ClonedSuccBB->phis()) {
     bool Found = false;
     // Loop over the incoming operands backwards so we can easily delete as we
     // go without invalidating the index.
     for (int i = PN.getNumOperands() - 1; i >= 0; --i) {

llvm/test/Transforms/SimpleLoopUnswitch/nontrivial-unswitch.ll

loop_a:
   call i32 @a()
   br label %latch
 ; The 'loop_a' unswitched loop.
 ;
 ; CHECK:       entry.split.us:
 ; CHECK-NEXT:    br label %loop_begin.us
 ;
 ; CHECK:       loop_begin.us:
-; CHECK-NEXT:    %[[V1_US:.*]] = load i1, i1* %ptr
-; CHECK-NEXT:    %[[OR_US:.*]] = or i1 %[[V1_US]], true
 ; CHECK-NEXT:    br label %loop_a.us
 ;
 ; CHECK:       loop_a.us:
 ; CHECK-NEXT:    call i32 @a()
 ; CHECK-NEXT:    br label %latch.us
 ;
 ; CHECK:       latch.us:
 ; CHECK-NEXT:    %[[V2_US:.*]] = load i1, i1* %ptr
loop_begin:
   %cond_and3 = and i1 %cond_and2, %cond3
   br i1 %cond_and3, label %loop_a, label %loop_b
 ; The 'loop_b' unswitched loop.
 ;
 ; CHECK:       entry.split.us:
 ; CHECK-NEXT:    br label %loop_begin.us
 ;
 ; CHECK:       loop_begin.us:
-; CHECK-NEXT:    %[[V1_US:.*]] = load i1, i1* %ptr1
-; CHECK-NEXT:    %[[V2_US:.*]] = load i1, i1* %ptr2
-; CHECK-NEXT:    %[[AND1_US:.*]] = and i1 %[[V1_US]], %cond1
-; CHECK-NEXT:    %[[OR1_US:.*]] = or i1 %[[V2_US]], %cond2
-; CHECK-NEXT:    %[[AND2_US:.*]] = and i1 %[[AND1_US]], %[[OR1_US]]
-; CHECK-NEXT:    %[[AND3_US:.*]] = and i1 %[[AND2_US]], %cond3
 ; CHECK-NEXT:    br label %loop_b.us
 ;
 ; CHECK:       loop_b.us:
 ; CHECK-NEXT:    call i32 @b()
 ; CHECK-NEXT:    br label %latch.us
 ;
 ; CHECK:       latch.us:
 ; CHECK-NEXT:    %[[V3_US:.*]] = load i1, i1* %ptr3
loop_begin:
   %cond_or3 = or i1 %cond_or2, %cond3
   br i1 %cond_or3, label %loop_b, label %loop_a
 ; The 'loop_b' unswitched loop.
 ;
 ; CHECK:       entry.split.us:
 ; CHECK-NEXT:    br label %loop_begin.us
 ;
 ; CHECK:       loop_begin.us:
-; CHECK-NEXT:    %[[V1_US:.*]] = load i1, i1* %ptr1
-; CHECK-NEXT:    %[[V2_US:.*]] = load i1, i1* %ptr2
-; CHECK-NEXT:    %[[OR1_US:.*]] = or i1 %[[V1_US]], %cond1
-; CHECK-NEXT:    %[[AND1_US:.*]] = and i1 %[[V2_US]], %cond2
-; CHECK-NEXT:    %[[OR2_US:.*]] = or i1 %[[OR1_US]], %[[AND1_US]]
-; CHECK-NEXT:    %[[OR3_US:.*]] = or i1 %[[OR2_US]], %cond3
 ; CHECK-NEXT:    br label %loop_b.us
 ;
 ; CHECK:       loop_b.us:
 ; CHECK-NEXT:    call i32 @b()
 ; CHECK-NEXT:    br label %latch.us
 ;
 ; CHECK:       latch.us:
 ; CHECK-NEXT:    %[[V3_US:.*]] = load i1, i1* %ptr3