[InstCombine] Fix worklist management when removing guard intrinsic

[nikic]

Summary

When multiple guard intrinsics are merged into one, currently the result of eraseInstFromFunction() is returned -- however, this should only be done if the current instruction is being removed. In this case we're removing a different instruction and should instead report that the current one has been modified by returning it.

For this test case, this reduces the number of instcombine iterations from 5 to 2 (the minimum possible).

[lebedev.ri]

Sorry, i don't know what @llvm.experimental.guard() is.

[spatel]

I don't know anything about experimental.guard either, but the change LGTM based on similar transforms.
Instcombine's visit* contract is:

// Visitation implementation - Implement instruction combining for different
// instruction types.  The semantics are as follows:
// Return Value:
//    null        - No change was made
//     I          - Change was made, I is still valid, I may be dead though
//   otherwise    - Change was made, replace I with returned instruction

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

for (unsigned i = 0; i < GuardWideningWindow; i++) {
       NextInst = NextInst->getNextNonDebugInstruction();
     }
     Value *NextCond = nullptr;
     if (match(NextInst,
               m_Intrinsic<Intrinsic::experimental_guard>(m_Value(NextCond)))) {
       Value *CurrCond = II->getArgOperand(0);
 
       // Remove a guard that it is immediately preceded by an identical guard.
-      if (CurrCond == NextCond)
-        return eraseInstFromFunction(*NextInst);
-
       // Otherwise canonicalize guard(a); guard(b) -> guard(a & b).
+      if (CurrCond != NextCond) {
         Instruction *MoveI = II->getNextNonDebugInstruction();
         while (MoveI != NextInst) {
           auto *Temp = MoveI;
           MoveI = MoveI->getNextNonDebugInstruction();
           Temp->moveBefore(II);
         }
         II->setArgOperand(0, Builder.CreateAnd(CurrCond, NextCond));
-      return eraseInstFromFunction(*NextInst);
+      }
+      eraseInstFromFunction(*NextInst);
+      return II;
     }
     break;
   }
   }
   return visitCallBase(*II);
 }
 
 // Fence instruction simplification

llvm/test/Transforms/InstCombine/call-guard.ll

-; RUN: opt < %s -instcombine -S | FileCheck %s
+; RUN: opt < %s -instcombine -instcombine-infinite-loop-threshold=2 -S | FileCheck %s
 ; RUN: opt < %s -instcombine -S -debugify-each | FileCheck %s
 
 declare void @llvm.experimental.guard(i1, ...)
 
 define void @test_guard_adjacent_same_cond(i1 %A) {
 ; CHECK-LABEL: @test_guard_adjacent_same_cond(
 ; CHECK-NEXT:    call void (i1, ...) @llvm.experimental.guard(i1 %A) [ "deopt"() ]
 ; CHECK-NEXT:    ret void