[InstCombine] Fix worklist management in return combine

[nikic]

Summary

There are two related bugs here: First, we don't add the operand we're replacing to the worklist, which means it may not get DCEd (see test change). Second, usually this would just get picked up in the next iteration, but we also do not report the instruction as changed. This means that we don't get that extra instcombine iteration, and more importantly, may break the pass pipeline, as the function is not marked as changed.

[spatel]

LGTM

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

 }
 
 Instruction *InstCombiner::visitReturnInst(ReturnInst &RI) {
   if (RI.getNumOperands() == 0) // ret void
     return nullptr;
 
   Value *ResultOp = RI.getOperand(0);
   Type *VTy = ResultOp->getType();
-  if (!VTy->isIntegerTy())
+  if (!VTy->isIntegerTy() || isa<Constant>(ResultOp))
     return nullptr;
 
   // There might be assume intrinsics dominating this return that completely
   // determine the value. If so, constant fold it.
   KnownBits Known = computeKnownBits(ResultOp, 0, &RI);
-  if (Known.isConstant())
+  if (Known.isConstant()) {
+    Worklist.AddValue(ResultOp);
     RI.setOperand(0, Constant::getIntegerValue(VTy, Known.getConstant()));
+    return &RI;
+  }
 
   return nullptr;
 }
 
 Instruction *InstCombiner::visitBranchInst(BranchInst &BI) {
   // Change br (not X), label True, label False to: br X, label False, True
   Value *X = nullptr;
   if (match(&BI, m_Br(m_Not(m_Value(X)), m_BasicBlock(), m_BasicBlock())) &&

llvm/test/Transforms/InstCombine/assume.ll

entry:
 
   %cmp2 = icmp eq i32 %a, %b
   tail call void @llvm.assume(i1 %cmp2)
 
   ret i32 %and1
 }
 
 define i32 @icmp1(i32 %a) #0 {
-; EXPENSIVE-ON-LABEL: @icmp1(
-; EXPENSIVE-ON-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A:%.*]], 5
-; EXPENSIVE-ON-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
-; EXPENSIVE-ON-NEXT:    ret i32 1
-;
-; EXPENSIVE-OFF-LABEL: @icmp1(
-; EXPENSIVE-OFF-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A:%.*]], 5
-; EXPENSIVE-OFF-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
-; EXPENSIVE-OFF-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
-; EXPENSIVE-OFF-NEXT:    ret i32 1
+; CHECK-LABEL: @icmp1(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A:%.*]], 5
+; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
+; CHECK-NEXT:    ret i32 1
 ;
   %cmp = icmp sgt i32 %a, 5
   tail call void @llvm.assume(i1 %cmp)
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @icmp2(i32 %a) #0 {