[InstCombine] allow Negator to fold multi-use select with constant arms

[spatel]

Summary

The motivating test is reduced from:
https://llvm.org/PR52261

Note that the more general problem of folding any binop into a multi-use select of constants is still there. We need to ease the restriction in InstCombinerImpl::FoldOpIntoSelect() to catch those. But these examples never reach that code because Negator exclusively handles negation patterns within visitSub().

[lebedev.ri]

Could you please precommit the tests?

[spatel]

In D112657#3091521, @lebedev.ri wrote:

Could you please precommit the tests?

Sorry - I had those queued up locally, but had not pushed:
e42c8bab4771

[lebedev.ri]

This is only following the existing framework, which is wrong, but i'm out of energy.

llvm/lib/Transforms/InstCombine/InstCombineNegator.cpp

case Instruction::ZExt:
     // `*ext` of i1 is always negatible
     if (I->getOperand(0)->getType()->isIntOrIntVectorTy(1))
       return I->getOpcode() == Instruction::SExt
                  ? Builder.CreateZExt(I->getOperand(0), I->getType(),
                                       I->getName() + ".neg")
                  : Builder.CreateSExt(I->getOperand(0), I->getType(),
                                       I->getName() + ".neg");
     break;
+  case Instruction::Select: {
+    // If both arms of the select are constants, we don't need to recurse.
+    // Therefore, this transform is not limited by uses.
+    auto *Sel = cast<SelectInst>(I);
+    Constant *TrueC, *FalseC;
+    if (match(Sel->getTrueValue(), m_ImmConstant(TrueC)) &&
+        match(Sel->getFalseValue(), m_ImmConstant(FalseC))) {
+      Constant *NegTrueC = ConstantExpr::getNeg(TrueC);
+      Constant *NegFalseC = ConstantExpr::getNeg(FalseC);
+      return Builder.CreateSelect(Sel->getCondition(), NegTrueC, NegFalseC,
+                                  I->getName() + ".neg", /*MDFrom=*/I);
+    }
+    break;
+  }
   default:
     break; // Other instructions require recursive reasoning.
   }
 
   if (I->getOpcode() == Instruction::Sub &&
       (I->hasOneUse() || match(I->getOperand(0), m_ImmConstant()))) {
     // `sub` is always negatible.
     // However, only do this either if the old `sub` doesn't stick around, or

llvm/test/Transforms/InstCombine/sub-of-negatible.ll

 ;
   %t0 = select i1 %y, i8 -42, i8 44
   %t1 = sub i8 %x, %t0
   ret i8 %t1
 }
 
 define i8 @select_of_constants_multi_use(i1 %b) {
 ; CHECK-LABEL: @select_of_constants_multi_use(
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i8 42, i8 -2
+; CHECK-NEXT:    [[S_NEG:%.*]] = select i1 [[B:%.*]], i8 -42, i8 2
+; CHECK-NEXT:    [[S:%.*]] = select i1 [[B]], i8 42, i8 -2
 ; CHECK-NEXT:    call void @use8(i8 [[S]])
-; CHECK-NEXT:    [[N:%.*]] = sub nsw i8 0, [[S]]
-; CHECK-NEXT:    ret i8 [[N]]
+; CHECK-NEXT:    ret i8 [[S_NEG]]
 ;
   %s = select i1 %b, i8 42, i8 -2
   call void @use8(i8 %s)
   %n = sub i8 0, %s
   ret i8 %n
 }
 
 define i32 @PR52261(i1 %b) {
 ; CHECK-LABEL: @PR52261(
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[B:%.*]], i32 2, i32 -2
-; CHECK-NEXT:    [[N:%.*]] = sub nsw i32 0, [[S]]
-; CHECK-NEXT:    [[A:%.*]] = and i32 [[S]], [[N]]
-; CHECK-NEXT:    ret i32 [[A]]
+; CHECK-NEXT:    ret i32 2
 ;
   %s = select i1 %b, i32 2, i32 -2
   %n = sub nsw i32 0, %s
   %a = and i32 %s, %n
   ret i32 %a
 }
 
 define i8 @n4(i8 %x, i1 %y) {