[InstCombine] Support non-splat vectors in icmp eq + add/sub fold

[nikic]

Summary

For the icmp eq (add X, C1), C2 => icmp eq X, C2-C1 and icmp eq (sub C1, X), C2 => icmp eq X, C1-C2 folds, this allows C1 to be non-splat and contain undefs. C2 is still splat, due to the structure of the code.

This is to address the remaining part of the regression in D73411, where demanded element analysis replaces some elements with undef.

[lebedev.ri]

This LG.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

2933

:/

2971–2972

Add a comment that we don't handle the case where we have constant on RHS because we expect it to get folded to add and the add fold above to happen?

[nikic]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

2933

IIRC that one actually has a somewhat sensible motivation... it prevents post-inc IVs from being converted to pre-inc IVs, which LSR cannot always recover.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

if (C.isNullValue() && BO->hasOneUse()) {
         Value *NewRem = Builder.CreateURem(BOp0, BOp1, BO->getName());
         return new ICmpInst(Pred, NewRem,
                             Constant::getNullValue(BO->getType()));
       }
     }
     break;
   case Instruction::Add: {
     // Replace ((add A, B) != C) with (A != C-B) if B & C are constants.
-    const APInt *BOC;
-    if (match(BOp1, m_APInt(BOC))) {
-      if (BO->hasOneUse()) {
-        Constant *SubC = ConstantExpr::getSub(RHS, cast<Constant>(BOp1));
-        return new ICmpInst(Pred, BOp0, SubC);
-      }
+    if (Constant *BOC = dyn_cast<Constant>(BOp1)) {
+      if (BO->hasOneUse())
+        return new ICmpInst(Pred, BOp0, ConstantExpr::getSub(RHS, BOC));
     } else if (C.isNullValue()) {
       // Replace ((add A, B) != 0) with (A != -B) if A or B is
       // efficiently invertible, or if the add has just this one use.
       if (Value *NegVal = dyn_castNegVal(BOp1))
         return new ICmpInst(Pred, BOp0, NegVal);
       if (Value *NegVal = dyn_castNegVal(BOp0))
         return new ICmpInst(Pred, NegVal, BOp1);
       if (BO->hasOneUse()) {
if (BO->hasOneUse()) {
       } else if (C.isNullValue()) {
         // Replace ((xor A, B) != 0) with (A != B)
         return new ICmpInst(Pred, BOp0, BOp1);
       }
     }
     break;
   case Instruction::Sub:
     if (BO->hasOneUse()) {
-      const APInt *BOC;
-      if (match(BOp0, m_APInt(BOC))) {
+      // Only check for constant LHS here, as constant RHS will be canonicalized
+      // to add and use the fold above.
+      if (Constant *BOC = dyn_cast<Constant>(BOp0)) {
         // Replace ((sub BOC, B) != C) with (B != BOC-C).
-        Constant *SubC = ConstantExpr::getSub(cast<Constant>(BOp0), RHS);
-        return new ICmpInst(Pred, BOp1, SubC);
+        return new ICmpInst(Pred, BOp1, ConstantExpr::getSub(BOC, RHS));
       } else if (C.isNullValue()) {
         // Replace ((sub A, B) != 0) with (A != B).
         return new ICmpInst(Pred, BOp0, BOp1);
       }
     }
     break;
   case Instruction::Or: {
     const APInt *BOC;
     if (match(BOp1, m_APInt(BOC)) && BO->hasOneUse() && RHS->isAllOnesValue()) {
       // Comparing if all bits outside of a constant mask are set?
       // Replace (X | C) == -1 with (X & ~C) == ~C.
       // This removes the -1 constant.
       Constant *NotBOC = ConstantExpr::getNot(cast<Constant>(BOp1));

llvm/test/Transforms/InstCombine/icmp-add.ll

;
   %cmp = icmp eq i8 %add1, %add2
   call void @use1(i1 %cmp)
   call void @use8(i8 %add1)
   ret void
 }
 
 define <2 x i1> @icmp_eq_add_undef(<2 x i32> %a) {
 ; CHECK-LABEL: @icmp_eq_add_undef(
-; CHECK-NEXT:    [[ADD:%.*]] = add <2 x i32> [[A:%.*]], <i32 5, i32 undef>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[ADD]], <i32 10, i32 10>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[A:%.*]], <i32 5, i32 undef>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %add = add <2 x i32> %a, <i32 5, i32 undef>
   %cmp = icmp eq <2 x i32> %add, <i32 10, i32 10>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_eq_add_non_splat(<2 x i32> %a) {
 ; CHECK-LABEL: @icmp_eq_add_non_splat(
-; CHECK-NEXT:    [[ADD:%.*]] = add <2 x i32> [[A:%.*]], <i32 5, i32 6>
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[ADD]], <i32 10, i32 10>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[A:%.*]], <i32 5, i32 4>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %add = add <2 x i32> %a, <i32 5, i32 6>
   %cmp = icmp eq <2 x i32> %add, <i32 10, i32 10>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_eq_add_undef2(<2 x i32> %a) {

llvm/test/Transforms/InstCombine/icmp-sub.ll

 ;
   %s = sub <2 x i8> <i8 255, i8 255>, %y
   %z = icmp eq <2 x i8> %s, <i8 255, i8 255>
   ret <2 x i1> %z
 }
 
 define <2 x i1> @icmp_eq_sub_undef(<2 x i32> %a) {
 ; CHECK-LABEL: @icmp_eq_sub_undef(
-; CHECK-NEXT:    [[SUB:%.*]] = sub <2 x i32> <i32 15, i32 undef>, [[A:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[SUB]], <i32 10, i32 10>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[A:%.*]], <i32 5, i32 undef>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = sub <2 x i32> <i32 15, i32 undef>, %a
   %cmp = icmp eq <2 x i32> %sub, <i32 10, i32 10>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_eq_sub_non_splat(<2 x i32> %a) {
 ; CHECK-LABEL: @icmp_eq_sub_non_splat(
-; CHECK-NEXT:    [[SUB:%.*]] = sub <2 x i32> <i32 15, i32 16>, [[A:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[SUB]], <i32 10, i32 10>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq <2 x i32> [[A:%.*]], <i32 5, i32 6>
 ; CHECK-NEXT:    ret <2 x i1> [[CMP]]
 ;
   %sub = sub <2 x i32> <i32 15, i32 16>, %a
   %cmp = icmp eq <2 x i32> %sub, <i32 10, i32 10>
   ret <2 x i1> %cmp
 }
 
 define <2 x i1> @icmp_eq_sub_undef2(<2 x i32> %a) {