[InstCombine] Instruction sinking: fix check for function terminating block

[lebedev.ri]

Summary

Checking for specific function terminating opcodes
means we don't handle other non-hardcoded ones :)

This should probably be generalized to something
similar to the IsBlockFollowedByDeoptOrUnreachable().

[spatel]

LGTM

[lebedev.ri]

In D117810#3259021, @spatel wrote:

LGTM

Thank you for the review.

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

auto getOptionalSinkBlockForInst =
       if (UserParent == BB || !DT.isReachableFromEntry(UserParent))
         return None;
 
       auto *Term = UserParent->getTerminator();
       // See if the user is one of our successors that has only one
       // predecessor, so that we don't have to split the critical edge.
       // Another option where we can sink is a block that ends with a
       // terminator that does not pass control to other block (such as
-      // return or unreachable). In this case:
+      // return or unreachable or resume). In this case:
       //   - I dominates the User (by SSA form);
       //   - the User will be executed at most once.
       // So sinking I down to User is always profitable or neutral.
-      if (UserParent->getUniquePredecessor() == BB ||
-          (isa<ReturnInst>(Term) || isa<UnreachableInst>(Term))) {
+      if (UserParent->getUniquePredecessor() == BB || succ_empty(Term)) {
         assert(DT.dominates(BB, UserParent) && "Dominance relation broken?");
         return UserParent;
       }
       return None;
     };
 
     auto OptBB = getOptionalSinkBlockForInst(I);
     if (OptBB) {

llvm/test/Transforms/InstCombine/sink-into-resume-block.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 ; Check that InstCombine can sink instructions to the landingpad of the invoke.
 
 define void @t0_noop(i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: @t0_noop(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[C:%.*]] = call i1 @cond()
-; CHECK-NEXT:    [[V0:%.*]] = add i32 [[ARG:%.*]], 42
 ; CHECK-NEXT:    br i1 [[C]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    invoke void @simple_throw()
 ; CHECK-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[LPAD:%.*]]
 ; CHECK:       invoke.cont:
 ; CHECK-NEXT:    unreachable
 ; CHECK:       lpad:
 ; CHECK-NEXT:    [[EH:%.*]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:    cleanup
+; CHECK-NEXT:    [[V0:%.*]] = add i32 [[ARG:%.*]], 42
 ; CHECK-NEXT:    call void @consume(i32 [[V0]])
 ; CHECK-NEXT:    call void @destructor()
 ; CHECK-NEXT:    resume { i8*, i32 } [[EH]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[V1:%.*]] = add i32 [[ARG]], 24
 ; CHECK-NEXT:    call void @consume(i32 [[V1]])
 ; CHECK-NEXT:    call void @sideeffect()
 ; CHECK-NEXT:    ret void