[InstCombine] Fold (mul(abs(x),abs(x))) -> (mul(x,x)) (PR39476)

[RKSimon]

Summary

This patch adds support for discarding integer absolutes (abs + nabs variants) from self-multiplications.

ABS Alive2: http://volta.cs.utah.edu:8080/z/rwcc8W
NABS Alive: http://volta.cs.utah.edu:8080/z/jZXUwQ

This is an InstCombine version of D79304 - I'm not sure yet if we'll need D79304 or not after this.

[lebedev.ri]

LG, thank you

[craig.topper]

SPF_ABS doesn't check the nsw flag on the negation subtract, but all the tests and the Alive proofs have nsw. It look like its still valid without the nsw so just wanted to mention it.

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (match(Op0, m_OneUse(m_Add(m_Value(X), m_Constant(C1))))) {
       Value *Mul = Builder.CreateMul(C1, Op1);
       // Only go forward with the transform if C1*CI simplifies to a tidier
       // constant.
       if (!match(Mul, m_Mul(m_Value(), m_Value())))
         return BinaryOperator::CreateAdd(Builder.CreateMul(X, Op1), Mul);
     }
   }
 
+  // abs(X) * abs(X) -> X * X
+  // nabs(X) * nabs(X) -> X * X
+  if (Op0 == Op1) {
+    Value *X, *Y;
+    SelectPatternFlavor SPF = matchSelectPattern(Op0, X, Y).Flavor;
+    if (SPF == SPF_ABS || SPF == SPF_NABS)
+      return BinaryOperator::CreateMul(X, X);
+  }
+
   // -X * C --> X * -C
   Value *X, *Y;
   Constant *Op1C;
   if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Constant(Op1C)))
     return BinaryOperator::CreateMul(X, ConstantExpr::getNeg(Op1C));
 
   // -X * -Y --> X * Y
   if (match(Op0, m_Neg(m_Value(X))) && match(Op1, m_Neg(m_Value(Y)))) {

llvm/test/Transforms/InstCombine/mul.ll

;
   %sel = select i1 %c, i32 %div, i32 1
   %mul = mul i32 %sel, %y
   ret i32 %mul
 }
 
 ; fold mul(abs(x),abs(x)) -> mul(x,x)
 define i31 @combine_mul_abs_i31(i31 %0) {
 ; CHECK-LABEL: @combine_mul_abs_i31(
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i31 [[TMP0:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = sub nsw i31 0, [[TMP0]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[C]], i31 [[S]], i31 [[TMP0]]
-; CHECK-NEXT:    [[M:%.*]] = mul i31 [[R]], [[R]]
+; CHECK-NEXT:    [[M:%.*]] = mul i31 [[TMP0:%.*]], [[TMP0]]
 ; CHECK-NEXT:    ret i31 [[M]]
 ;
   %c = icmp slt i31 %0, 0
   %s = sub nsw i31 0, %0
   %r = select i1 %c, i31 %s, i31 %0
   %m = mul i31 %r, %r
   ret i31 %m
 }
 
 define i32 @combine_mul_abs_i32(i32 %0) {
 ; CHECK-LABEL: @combine_mul_abs_i32(
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i32 [[TMP0:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = sub nsw i32 0, [[TMP0]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[C]], i32 [[S]], i32 [[TMP0]]
-; CHECK-NEXT:    [[M:%.*]] = mul i32 [[R]], [[R]]
+; CHECK-NEXT:    [[M:%.*]] = mul i32 [[TMP0:%.*]], [[TMP0]]
 ; CHECK-NEXT:    ret i32 [[M]]
 ;
   %c = icmp slt i32 %0, 0
   %s = sub nsw i32 0, %0
   %r = select i1 %c, i32 %s, i32 %0
   %m = mul i32 %r, %r
   ret i32 %m
 }
 
 define <4 x i32> @combine_mul_abs_v4i32(<4 x i32> %0) {
 ; CHECK-LABEL: @combine_mul_abs_v4i32(
-; CHECK-NEXT:    [[C:%.*]] = icmp slt <4 x i32> [[TMP0:%.*]], zeroinitializer
-; CHECK-NEXT:    [[S:%.*]] = sub nsw <4 x i32> zeroinitializer, [[TMP0]]
-; CHECK-NEXT:    [[R:%.*]] = select <4 x i1> [[C]], <4 x i32> [[S]], <4 x i32> [[TMP0]]
-; CHECK-NEXT:    [[M:%.*]] = mul <4 x i32> [[R]], [[R]]
+; CHECK-NEXT:    [[M:%.*]] = mul <4 x i32> [[TMP0:%.*]], [[TMP0]]
 ; CHECK-NEXT:    ret <4 x i32> [[M]]
 ;
   %c = icmp slt <4 x i32> %0, zeroinitializer
   %s = sub nsw <4 x i32> zeroinitializer, %0
   %r = select <4 x i1> %c, <4 x i32> %s, <4 x i32> %0
   %m = mul <4 x i32> %r, %r
   ret <4 x i32> %m
 }
 
 ; fold mul(nabs(x),nabs(x)) -> mul(x,x)
 define i31 @combine_mul_nabs_i31(i31 %0) {
 ; CHECK-LABEL: @combine_mul_nabs_i31(
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i31 [[TMP0:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = sub nsw i31 0, [[TMP0]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[C]], i31 [[TMP0]], i31 [[S]]
-; CHECK-NEXT:    [[M:%.*]] = mul i31 [[R]], [[R]]
+; CHECK-NEXT:    [[M:%.*]] = mul i31 [[TMP0:%.*]], [[TMP0]]
 ; CHECK-NEXT:    ret i31 [[M]]
 ;
   %c = icmp slt i31 %0, 0
   %s = sub nsw i31 0, %0
   %r = select i1 %c, i31 %0, i31 %s
   %m = mul i31 %r, %r
   ret i31 %m
 }
 
 define i32 @combine_mul_nabs_i32(i32 %0) {
 ; CHECK-LABEL: @combine_mul_nabs_i32(
-; CHECK-NEXT:    [[C:%.*]] = icmp slt i32 [[TMP0:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = sub nsw i32 0, [[TMP0]]
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[C]], i32 [[TMP0]], i32 [[S]]
-; CHECK-NEXT:    [[M:%.*]] = mul i32 [[R]], [[R]]
+; CHECK-NEXT:    [[M:%.*]] = mul i32 [[TMP0:%.*]], [[TMP0]]
 ; CHECK-NEXT:    ret i32 [[M]]
 ;
   %c = icmp slt i32 %0, 0
   %s = sub nsw i32 0, %0
   %r = select i1 %c, i32 %0, i32 %s
   %m = mul i32 %r, %r
   ret i32 %m
 }
 
 define <4 x i32> @combine_mul_nabs_v4i32(<4 x i32> %0) {
 ; CHECK-LABEL: @combine_mul_nabs_v4i32(
-; CHECK-NEXT:    [[C:%.*]] = icmp slt <4 x i32> [[TMP0:%.*]], zeroinitializer
-; CHECK-NEXT:    [[S:%.*]] = sub nsw <4 x i32> zeroinitializer, [[TMP0]]
-; CHECK-NEXT:    [[R:%.*]] = select <4 x i1> [[C]], <4 x i32> [[TMP0]], <4 x i32> [[S]]
-; CHECK-NEXT:    [[M:%.*]] = mul <4 x i32> [[R]], [[R]]
+; CHECK-NEXT:    [[M:%.*]] = mul <4 x i32> [[TMP0:%.*]], [[TMP0]]
 ; CHECK-NEXT:    ret <4 x i32> [[M]]
 ;
   %c = icmp slt <4 x i32> %0, zeroinitializer
   %s = sub nsw <4 x i32> zeroinitializer, %0
   %r = select <4 x i1> %c, <4 x i32> %0, <4 x i32> %s
   %m = mul <4 x i32> %r, %r
   ret <4 x i32> %m
 }