[InstCombine] fold add(zext(xor X, C), C) --> sext X when C is INT_MIN in the source type

[spatel]

Summary

The pattern may look more obviously like a sext if written as:

define i32 @g(i16 %x) {
  %zext = zext i16 %x to i32
  %xor = xor i32 %zext, 32768
  %add = add i32 %xor, -32768
  ret i32 %add
}

We already have that fold in visitAdd().

And that probably gives away how I got here: I was testing if we had any missing folds if we make D22271 more liberal about pulling logic ops ahead of zexts.

[majnemer]

lib/Transforms/InstCombine/InstCombineAddSub.cpp

1054

Why m_OneUse ?

[majnemer]

The transform LGTM

[spatel]

lib/Transforms/InstCombine/InstCombineAddSub.cpp

1054

I was being conservative, but given that we'd at least shorten the dependency chain for this result regardless of other uses of the zext/xor, we don't need those checks.

I can remove the m_OneUse and add some more tests to this patch, or if you prefer, I'll add a TODO and follow-up patch.

[majnemer]

lib/Transforms/InstCombine/InstCombineAddSub.cpp

1054

It seems much more canonical, I'd just remove the OneUse.

lib/Transforms/InstCombine/InstCombineAddSub.cpp

Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
   if (Value *V = SimplifyUsingDistributiveLaws(I))
     return replaceInstUsesWith(I, V);
 
   const APInt *Val;
   if (match(RHS, m_APInt(Val))) {
     // X + (signbit) --> X ^ signbit
     if (Val->isSignBit())
       return BinaryOperator::CreateXor(LHS, RHS);
+
+    // Is this add the last step in a convoluted sext?
+    Value *X;
+    const APInt *C;
+    if (match(LHS, m_OneUse(m_ZExt(m_OneUse(m_Xor(m_Value(X), m_APInt(C)))))) &&
+        C->isMinSignedValue() &&
+        C->sext(LHS->getType()->getScalarSizeInBits()) == *Val) {
+      // add(zext(xor i16 X, -32768), -32768) --> sext X
+      return CastInst::Create(Instruction::SExt, X, LHS->getType());
+    }
   }
 
   // FIXME: Use the match above instead of dyn_cast to allow these transforms
   // for splat vectors.
   if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
     // See if SimplifyDemandedBits can simplify this.  This handles stuff like
     // (X & 254)+1 -> (X&254)|1
     if (SimplifyDemandedInstructionBits(I))

test/Transforms/InstCombine/apint-add.ll

 ;
   %tmp.2 = and i49 %x, 562949953421310
   %tmp.4 = add i49 %tmp.2, 1
   ret i49 %tmp.4
 }
 
 define i7 @sext(i4 %x) {
 ; CHECK-LABEL: @sext(
-; CHECK-NEXT:    [[XOR:%.*]] = xor i4 %x, -8
-; CHECK-NEXT:    [[ZEXT:%.*]] = zext i4 [[XOR]] to i7
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw i7 [[ZEXT]], -8
+; CHECK-NEXT:    [[ADD:%.*]] = sext i4 %x to i7
 ; CHECK-NEXT:    ret i7 [[ADD]]
 ;
   %xor = xor i4 %x, -8
   %zext = zext i4 %xor to i7
   %add = add nsw i7 %zext, -8
   ret i7 %add
 }
 
 define <2 x i10> @sext_vec(<2 x i3> %x) {
 ; CHECK-LABEL: @sext_vec(
-; CHECK-NEXT:    [[XOR:%.*]] = xor <2 x i3> %x, <i3 -4, i3 -4>
-; CHECK-NEXT:    [[ZEXT:%.*]] = zext <2 x i3> [[XOR]] to <2 x i10>
-; CHECK-NEXT:    [[ADD:%.*]] = add nsw <2 x i10> [[ZEXT]], <i10 -4, i10 -4>
+; CHECK-NEXT:    [[ADD:%.*]] = sext <2 x i3> %x to <2 x i10>
 ; CHECK-NEXT:    ret <2 x i10> [[ADD]]
 ;
   %xor = xor <2 x i3> %x, <i3 -4, i3 -4>
   %zext = zext <2 x i3> %xor to <2 x i10>
   %add = add nsw <2 x i10> %zext, <i10 -4, i10 -4>
   ret <2 x i10> %add
 }