[InstCombine] enhance freelyNegateValue() by handling xor

[spatel]

Summary

Negation is equivalent to bitwise-not + 1, so try to convert more subtracts into adds using this relationship:
0 - (A ^ C) => ((A ^ C) ^ -1) + 1 => A ^ ~C + 1

I doubt this will recover the regression noted in rGf2fbdf76d8d0, but seems like we're going to need to improve here and/or revive D68408?

Alive2 proofs:
http://volta.cs.utah.edu:8080/z/Re5tMU
http://volta.cs.utah.edu:8080/z/An-uns

[lebedev.ri]

lg

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

if (!I->hasOneUse())
     return nullptr;
 
   switch (I->getOpcode()) {
   // 0-(A-B)  =>  B-A
   case Instruction::Sub:
     return Builder.CreateSub(
         I->getOperand(1), I->getOperand(0), I->getName() + ".neg");
 
+  // Negation is equivalent to bitwise-not + 1:
+  // 0 - (A ^ C)  =>  ((A ^ C) ^ -1) + 1  =>  A ^ ~C + 1
+  case Instruction::Xor: {
+    Constant *C;
+    if (match(I->getOperand(1), m_Constant(C))) {
+      Value *Xor = Builder.CreateXor(I->getOperand(0), ConstantExpr::getNot(C));
+      return Builder.CreateAdd(Xor, ConstantInt::get(Xor->getType(), 1),
+                               I->getName() + ".neg");
+    }
+    return nullptr;
+  }
+
   // 0-(A sdiv C)  =>  A sdiv (0-C)  provided the negation doesn't overflow.
   case Instruction::SDiv: {
     Constant *C = dyn_cast<Constant>(I->getOperand(1));
     if (C && !C->containsUndefElement() && C->isNotMinSignedValue() &&
         C->isNotOneValue())
       return Builder.CreateSDiv(I->getOperand(0), ConstantExpr::getNeg(C),
           I->getName() + ".neg", cast<BinaryOperator>(I)->isExact());
     return nullptr;

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

;
   %t1 = trunc i16 %t0 to i8
   call void @use8(i8 %t1)
   %t2 = sub i8 %x, %t1
   ret i8 %t2
 }
 
 define i4 @negate_xor(i4 %x) {
 ; CHECK-LABEL: @negate_xor(
-; CHECK-NEXT:    [[O:%.*]] = xor i4 [[X:%.*]], 5
-; CHECK-NEXT:    [[R:%.*]] = sub i4 0, [[O]]
-; CHECK-NEXT:    ret i4 [[R]]
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i4 [[X:%.*]], -6
+; CHECK-NEXT:    [[O_NEG:%.*]] = add i4 [[TMP1]], 1
+; CHECK-NEXT:    ret i4 [[O_NEG]]
 ;
   %o = xor i4 %x, 5
   %r = sub i4 0, %o
   ret i4 %r
 }
 
 define <2 x i4> @negate_xor_vec(<2 x i4> %x) {
 ; CHECK-LABEL: @negate_xor_vec(
-; CHECK-NEXT:    [[O:%.*]] = xor <2 x i4> [[X:%.*]], <i4 5, i4 -6>
-; CHECK-NEXT:    [[R:%.*]] = sub <2 x i4> zeroinitializer, [[O]]
-; CHECK-NEXT:    ret <2 x i4> [[R]]
+; CHECK-NEXT:    [[TMP1:%.*]] = xor <2 x i4> [[X:%.*]], <i4 -6, i4 5>
+; CHECK-NEXT:    [[O_NEG:%.*]] = add <2 x i4> [[TMP1]], <i4 1, i4 1>
+; CHECK-NEXT:    ret <2 x i4> [[O_NEG]]
 ;
   %o = xor <2 x i4> %x, <i4 5, i4 10>
   %r = sub <2 x i4> zeroinitializer, %o
   ret <2 x i4> %r
 }
 
 define i8 @negate_xor_use(i8 %x) {
 ; CHECK-LABEL: @negate_xor_use(
 ; CHECK-NEXT:    [[O:%.*]] = xor i8 [[X:%.*]], 5
 ; CHECK-NEXT:    call void @use8(i8 [[O]])
 ; CHECK-NEXT:    [[R:%.*]] = sub i8 0, [[O]]
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %o = xor i8 %x, 5
   call void @use8(i8 %o)
   %r = sub i8 0, %o
   ret i8 %r
 }
 
 define i4 @negate_shl_xor(i4 %x, i4 %y) {
 ; CHECK-LABEL: @negate_shl_xor(
-; CHECK-NEXT:    [[O:%.*]] = xor i4 [[X:%.*]], 5
-; CHECK-NEXT:    [[S:%.*]] = shl i4 [[O]], [[Y:%.*]]
-; CHECK-NEXT:    [[R:%.*]] = sub i4 0, [[S]]
-; CHECK-NEXT:    ret i4 [[R]]
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i4 [[X:%.*]], -6
+; CHECK-NEXT:    [[O_NEG:%.*]] = add i4 [[TMP1]], 1
+; CHECK-NEXT:    [[S_NEG:%.*]] = shl i4 [[O_NEG]], [[Y:%.*]]
+; CHECK-NEXT:    ret i4 [[S_NEG]]
 ;
   %o = xor i4 %x, 5
   %s = shl i4 %o, %y
   %r = sub i4 0, %s
   ret i4 %r
 }