[InstSimplify] Fold degenerate abs of abs form

[nikic]

Summary

This addresses the remaining issue from D87188. Due to a series of folds, we may end up with abs-of-abs represented as x == 0 ? -abs(x) : abs(x). Rather than recognizing this as a special abs pattern and doing an abs-of-abs fold on it afterwards, I'm directly folding this to one of the select operands in InstSimplify.

The general pattern falls into the "select with operand replaced" category, but that fold is not powerful enough to recognize that both hands of the select are the same for value zero.

[efriedma]

It doesn't matter that the constant is 0 specifically, does it? Should work for any constant besides INT_MIN with the correct sign.

Is it worth trying to generalize this? It seems like something along the lines of SimplifyWithOpReplaced should be able to simplify this.

[nikic]

In D87197#2257839, @efriedma wrote:

It doesn't matter that the constant is 0 specifically, does it? Should work for any constant besides INT_MIN with the correct sign.

I believe this is only valid for 0 specifically, because that's where abs(X) == -abs(X). (Well, and for INT_MIN in the non-poisoning case, as both abs and neg preserve it as well.)

Is it worth trying to generalize this? It seems like something along the lines of SimplifyWithOpReplaced should be able to simplify this.

Yes, conceptually this could be handled by SimplifyWithOpReplaced. However, it requires replacing operands two levels up (in an abs that is used by a neg that is used by the select). Given the still open correctness issues from https://bugs.llvm.org/show_bug.cgi?id=47322, it seems dangerous to try and generalize it further.

[efriedma]

LGTM

In D87197#2257842, @nikic wrote:

In D87197#2257839, @efriedma wrote:

It doesn't matter that the constant is 0 specifically, does it? Should work for any constant besides INT_MIN with the correct sign.

I believe this is only valid for 0 specifically, because that's where abs(X) == -abs(X). (Well, and for INT_MIN in the non-poisoning case, as both abs and neg preserve it as well.)

Oh, right, it returns a value with the opposite sign.

Given the still open correctness issues from https://bugs.llvm.org/show_bug.cgi?id=47322, it seems dangerous to try and generalize it further.

I think it's worth doing something here eventually, but this is fine for now, sure.

llvm/lib/Analysis/InstructionSimplify.cpp

auto isRotate = m_CombineOr(m_Intrinsic<Intrinsic::fshl>(m_Value(X),
                                 m_Intrinsic<Intrinsic::fshr>(m_Value(X),
                                                              m_Deferred(X),
                                                              m_Value(ShAmt)));
     // (ShAmt == 0) ? X : fshl(X, X, ShAmt) --> fshl(X, X, ShAmt)
     // (ShAmt == 0) ? X : fshr(X, X, ShAmt) --> fshr(X, X, ShAmt)
     if (match(FalseVal, isRotate) && TrueVal == X && CmpLHS == ShAmt &&
         Pred == ICmpInst::ICMP_EQ)
       return FalseVal;
+
+    // X == 0 ? abs(X) : -abs(X) --> -abs(X)
+    // X == 0 ? -abs(X) : abs(X) --> abs(X)
+    if (match(TrueVal, m_Intrinsic<Intrinsic::abs>(m_Value(X))) &&
+        match(FalseVal, m_Neg(m_Intrinsic<Intrinsic::abs>(m_Specific(X)))))
+      return FalseVal;
+    if (match(TrueVal, m_Neg(m_Intrinsic<Intrinsic::abs>(m_Value(X)))) &&
+        match(FalseVal, m_Intrinsic<Intrinsic::abs>(m_Specific(X))))
+      return FalseVal;
   }
 
   // Check for other compares that behave like bit test.
   if (Value *V = simplifySelectWithFakeICmpEq(CmpLHS, CmpRHS, Pred,
                                               TrueVal, FalseVal))
     return V;
 
   // If we have an equality comparison, then we know the value in one of the

llvm/test/Transforms/InstSimplify/abs_intrinsic.ll

;
   %abs = call i8 @llvm.abs.i8(i8 %x, i1 false)
   %c = icmp ule i8 %abs, 128
   ret i1 %c
 }
 
 define i32 @select_abs_of_abs_eq(i32 %x) {
 ; CHECK-LABEL: @select_abs_of_abs_eq(
 ; CHECK-NEXT:    [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 false)
-; CHECK-NEXT:    [[NEG:%.*]] = sub i32 0, [[ABS]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[X]], 0
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i32 [[NEG]], i32 [[ABS]]
-; CHECK-NEXT:    ret i32 [[SEL]]
+; CHECK-NEXT:    ret i32 [[ABS]]
 ;
   %abs = call i32 @llvm.abs.i32(i32 %x, i1 false)
   %neg = sub i32 0, %abs
   %cmp = icmp eq i32 %x, 0
   %sel = select i1 %cmp, i32 %neg, i32 %abs
   ret i32 %sel
 }
 
 define i32 @select_abs_of_abs_ne(i32 %x) {
 ; CHECK-LABEL: @select_abs_of_abs_ne(
 ; CHECK-NEXT:    [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 false)
-; CHECK-NEXT:    [[NEG:%.*]] = sub i32 0, [[ABS]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[X]], 0
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i32 [[ABS]], i32 [[NEG]]
-; CHECK-NEXT:    ret i32 [[SEL]]
+; CHECK-NEXT:    ret i32 [[ABS]]
 ;
   %abs = call i32 @llvm.abs.i32(i32 %x, i1 false)
   %neg = sub i32 0, %abs
   %cmp = icmp ne i32 %x, 0
   %sel = select i1 %cmp, i32 %abs, i32 %neg
   ret i32 %sel
 }
 
 define i32 @select_nabs_of_abs_eq(i32 %x) {
 ; CHECK-LABEL: @select_nabs_of_abs_eq(
 ; CHECK-NEXT:    [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 false)
 ; CHECK-NEXT:    [[NEG:%.*]] = sub i32 0, [[ABS]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[X]], 0
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i32 [[ABS]], i32 [[NEG]]
-; CHECK-NEXT:    ret i32 [[SEL]]
+; CHECK-NEXT:    ret i32 [[NEG]]
 ;
   %abs = call i32 @llvm.abs.i32(i32 %x, i1 false)
   %neg = sub i32 0, %abs
   %cmp = icmp eq i32 %x, 0
   %sel = select i1 %cmp, i32 %abs, i32 %neg
   ret i32 %sel
 }
 
 define i32 @select_nabs_of_abs_ne(i32 %x) {
 ; CHECK-LABEL: @select_nabs_of_abs_ne(
 ; CHECK-NEXT:    [[ABS:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 false)
 ; CHECK-NEXT:    [[NEG:%.*]] = sub i32 0, [[ABS]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[X]], 0
-; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[CMP]], i32 [[NEG]], i32 [[ABS]]
-; CHECK-NEXT:    ret i32 [[SEL]]
+; CHECK-NEXT:    ret i32 [[NEG]]
 ;
   %abs = call i32 @llvm.abs.i32(i32 %x, i1 false)
   %neg = sub i32 0, %abs
   %cmp = icmp ne i32 %x, 0
   %sel = select i1 %cmp, i32 %neg, i32 %abs
   ret i32 %sel
 }