[InstCombine] Remove instructions before non-terminator unreachable

Treat non-terminator unreachable the same as unreachable, and
remove guaranteed-to-transfer instructions before it.

Author: nikic

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

@@ -661,6 +661,7 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
 
   bool tryToSinkInstruction(Instruction *I, BasicBlock *DestBlock);
 
+  bool removeInstructionsBeforeUnreachable(Instruction &I);
   bool handleUnreachableFrom(Instruction *I);
   bool handlePotentiallyDeadSuccessors(BasicBlock *BB, BasicBlock *LiveSucc);
 };

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

@@ -1561,8 +1561,10 @@ Instruction *InstCombinerImpl::visitStoreInst(StoreInst &SI) {
 
   // This is a non-terminator unreachable marker. Don't remove it.
   if (isa<UndefValue>(Ptr)) {
-    // Remove unreachable instructions after the marker.
-    if (handleUnreachableFrom(SI.getNextNode()))
+    // Remove all instructions after the marker and guaranteed-to-transfer
+    // instructions before the marker.
+    if (handleUnreachableFrom(SI.getNextNode()) ||
+        removeInstructionsBeforeUnreachable(SI))
       return &SI;
     return nullptr;
   }

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

@@ -2611,30 +2611,35 @@ Instruction *InstCombinerImpl::visitReturnInst(ReturnInst &RI) {
 }
 
 // WARNING: keep in sync with SimplifyCFGOpt::simplifyUnreachable()!
-Instruction *InstCombinerImpl::visitUnreachableInst(UnreachableInst &I) {
+bool InstCombinerImpl::removeInstructionsBeforeUnreachable(Instruction &I) {
   // Try to remove the previous instruction if it must lead to unreachable.
   // This includes instructions like stores and "llvm.assume" that may not get
   // removed by simple dead code elimination.
+  bool Changed = false;
   while (Instruction *Prev = I.getPrevNonDebugInstruction()) {
     // While we theoretically can erase EH, that would result in a block that
     // used to start with an EH no longer starting with EH, which is invalid.
     // To make it valid, we'd need to fixup predecessors to no longer refer to
     // this block, but that changes CFG, which is not allowed in InstCombine.
     if (Prev->isEHPad())
-      return nullptr; // Can not drop any more instructions. We're done here.
+      break; // Can not drop any more instructions. We're done here.
 
     if (!isGuaranteedToTransferExecutionToSuccessor(Prev))
-      return nullptr; // Can not drop any more instructions. We're done here.
+      break; // Can not drop any more instructions. We're done here.
     // Otherwise, this instruction can be freely erased,
     // even if it is not side-effect free.
 
     // A value may still have uses before we process it here (for example, in
     // another unreachable block), so convert those to poison.
     replaceInstUsesWith(*Prev, PoisonValue::get(Prev->getType()));
     eraseInstFromFunction(*Prev);
+    Changed = true;
   }
-  assert(I.getParent()->sizeWithoutDebug() == 1 && "The block is now empty.");
-  // FIXME: recurse into unconditional predecessors?
+  return Changed;
+}
+
+Instruction *InstCombinerImpl::visitUnreachableInst(UnreachableInst &I) {
+  removeInstructionsBeforeUnreachable(I);
   return nullptr;
 }
 

llvm/test/Transforms/InstCombine/struct-assign-tbaa-new.ll

@@ -26,9 +26,8 @@ entry:
 
 define ptr @test2() {
 ; CHECK-LABEL: @test2(
-; CHECK-NEXT:    [[TMP:%.*]] = alloca [[B:%.*]], align 8
 ; CHECK-NEXT:    store i1 true, ptr poison, align 1
-; CHECK-NEXT:    ret ptr [[TMP]]
+; CHECK-NEXT:    ret ptr poison
 ;
   %tmp = alloca %B, align 8
   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 undef, i64 8, i1 false), !tbaa !7  ; TAG_B

llvm/test/Transforms/InstCombine/struct-assign-tbaa.ll

@@ -26,9 +26,8 @@ entry:
 
 define ptr @test2() {
 ; CHECK-LABEL: @test2(
-; CHECK-NEXT:    [[TMP:%.*]] = alloca [[STRUCT_TEST2:%.*]], align 8
 ; CHECK-NEXT:    store i1 true, ptr poison, align 1
-; CHECK-NEXT:    ret ptr [[TMP]]
+; CHECK-NEXT:    ret ptr poison
 ;
   %tmp = alloca %struct.test2, align 8
   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 undef, i64 8, i1 false), !tbaa.struct !4

llvm/test/Transforms/InstCombine/unreachable-code.ll

@@ -193,7 +193,6 @@ default:
 define void @non_term_unreachable() {
 ; CHECK-LABEL: define void @non_term_unreachable() {
 ; CHECK-NEXT:    call void @dummy()
-; CHECK-NEXT:    call void @dummy() #[[ATTR0:[0-9]+]]
 ; CHECK-NEXT:    store i1 true, ptr poison, align 1
 ; CHECK-NEXT:    ret void
 ;