[InstCombine] canonicalize constant-minus-boolean to select-of-constants

[spatel]

Summary

This restores the half of:
https://reviews.llvm.org/rL75531
that was reverted at:
https://reviews.llvm.org/rL159230

For the x86 case mentioned there, we now produce:
leal 1(%rdi), %eax
subl %esi, %eax

We have target hooks to invert this in DAGCombiner (and x86 is enabled) with:
https://reviews.llvm.org/rL296977
https://reviews.llvm.org/rL311731

I think AArch64 and possibly other targets would benefit from enabling those hooks too. See PR30327:
https://bugs.llvm.org/show_bug.cgi?id=30327#c2

And now (finally), I can abandon D24480.

[spatel]

Ping.

[efriedma]

LGTM. We clearly should be canonicalizing expressions like this, and DAGCombine can reverse the transform if necessary.

llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp

Instruction *InstCombiner::visitSub(BinaryOperator &I) {
   if (I.getType()->isIntOrIntVectorTy(1))
     return BinaryOperator::CreateXor(Op0, Op1);
 
   // Replace (-1 - A) with (~A).
   if (match(Op0, m_AllOnes()))
     return BinaryOperator::CreateNot(Op1);
 
   if (Constant *C = dyn_cast<Constant>(Op0)) {
+    Value *X;
+    // C - zext(bool) -> bool ? C - 1 : C
+    if (match(Op1, m_ZExt(m_Value(X))) &&
+        X->getType()->getScalarSizeInBits() == 1)
+      return SelectInst::Create(X, SubOne(C), C);
+
     // C - ~X == X + (1+C)
-    Value *X = nullptr;
     if (match(Op1, m_Not(m_Value(X))))
       return BinaryOperator::CreateAdd(X, AddOne(C));
 
     // Try to fold constant sub into select arguments.
     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
       if (Instruction *R = FoldOpIntoSelect(I, SI))
         return R;
 

llvm/trunk/test/Transforms/InstCombine/zext-bool-add-sub.ll

;
   %conv3.neg = sub i32 0, %conv3
   %sub = add i32 %conv, 1
   %add = add i32 %sub, %conv3.neg
   ret i32 %add
 }
 
 define i32 @zextsub(i1 %x) {
 ; CHECK-LABEL: @zextsub(
-; CHECK-NEXT:    [[ZEXT:%.*]] = zext i1 %x to i32
-; CHECK-NEXT:    [[SUB:%.*]] = sub nsw i32 11, [[ZEXT]]
+; CHECK-NEXT:    [[SUB:%.*]] = select i1 %x, i32 10, i32 11
 ; CHECK-NEXT:    ret i32 [[SUB]]
 ;
   %zext = zext i1 %x to i32
   %sub = sub i32 11, %zext
   ret i32 %sub
 }
 
 define <2 x i32> @zextsub_splat(<2 x i1> %x) {
 ; CHECK-LABEL: @zextsub_splat(
-; CHECK-NEXT:    [[ZEXT:%.*]] = zext <2 x i1> %x to <2 x i32>
-; CHECK-NEXT:    [[SUB:%.*]] = sub nsw <2 x i32> <i32 42, i32 42>, [[ZEXT]]
+; CHECK-NEXT:    [[SUB:%.*]] = select <2 x i1> %x, <2 x i32> <i32 41, i32 41>, <2 x i32> <i32 42, i32 42>
 ; CHECK-NEXT:    ret <2 x i32> [[SUB]]
 ;
   %zext = zext <2 x i1> %x to <2 x i32>
   %sub = sub <2 x i32> <i32 42, i32 42>, %zext
   ret <2 x i32> %sub
 }
 
 define <2 x i32> @zextsub_vec(<2 x i1> %x) {
 ; CHECK-LABEL: @zextsub_vec(
-; CHECK-NEXT:    [[ZEXT:%.*]] = zext <2 x i1> %x to <2 x i32>
-; CHECK-NEXT:    [[SUB:%.*]] = sub nsw <2 x i32> <i32 11, i32 42>, [[ZEXT]]
+; CHECK-NEXT:    [[SUB:%.*]] = select <2 x i1> %x, <2 x i32> <i32 10, i32 41>, <2 x i32> <i32 11, i32 42>
 ; CHECK-NEXT:    ret <2 x i32> [[SUB]]
 ;
   %zext = zext <2 x i1> %x to <2 x i32>
   %sub = sub <2 x i32> <i32 11, i32 42>, %zext
   ret <2 x i32> %sub
 }
 
 define i32 @PR30273_select(i1 %a, i1 %b) {