[InstCombine] x /c fabs(x) -> copysign(1.0, x)

[xbolva00]

Summary

x / fabs(x) -> copysign(1.0, x)
fabs(x) / x -> copysign(1.0, x)

[RKSimon]

vector tests?

[xbolva00]

Added vector test

[spatel]

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1237

Do we want to handle the commuted pattern too?
fabs(X) / X

1240

Do we need the one-use restriction?

test/Transforms/InstCombine/fabs-copysign.ll

43

This is supposed to be an extra use test, but there's no extra use?

[xbolva00]

Addressed review notes

[xbolva00]

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1240

Dropped.

[xbolva00]

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1246

I tried

match(&I, m_FDiv(m_Value(X), m_Intrinsic<Intrinsic::fabs>(m_Specific(X)))) and it failed to match.. uh.

(this blocked me to possibly introduce m_c_FDiv)

[spatel]

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1246

You need to use m_Deferred() for that case when matching commutatively (cc @lebedev.ri ).
But I don't think it's worth adding a commutative matcher for fdiv since it isn't a commutative operation. Not too many cases like this where it can be used?

test/Transforms/InstCombine/fabs-copysign.ll

22–30

Please push the new tests with baseline CHECKs as a preliminary step.

[xbolva00]

Use m_Deferred

[xbolva00]

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1246

Thanks!

(and agree)

[spatel]

LGTM

[xbolva00]

Thanks

[spatel]

In D65898#1625141, @xbolva00 wrote:

Thanks

Wait - there was a vector test here at 1 point, but now it's gone? Please adjust the type on one of the positive tests, so we still have that coverage.

[xbolva00]

Uh, that’s interesting how that test was lost.

I will add it again, sorry.

[xbolva00]

Readded vector tests

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

Instruction *InstCombiner::visitFDiv(BinaryOperator &I) {
   // We can ignore the possibility that X is infinity because INF/INF is NaN.
   if (I.hasNoNaNs() && I.hasAllowReassoc() &&
       match(Op1, m_c_FMul(m_Specific(Op0), m_Value(Y)))) {
     I.setOperand(0, ConstantFP::get(I.getType(), 1.0));
     I.setOperand(1, Y);
     return &I;
   }
 
+  // X / fabs(X) -> copysign(1.0, X)
+  if (I.hasNoNaNs() && I.hasNoInfs() &&
+      match(Op1, m_Intrinsic<Intrinsic::fabs>(m_Specific(Op0))) &&
+      Op1->hasOneUse()) {
+    Value *V = Builder.CreateBinaryIntrinsic(
+        Intrinsic::copysign, ConstantFP::get(I.getType(), 1.0), Op0, &I);
+    return replaceInstUsesWith(I, V);
+  }
   return nullptr;
 }
 
 /// This function implements the transforms common to both integer remainder
 /// instructions (urem and srem). It is called by the visitors to those integer
 /// remainder instructions.
 /// Common integer remainder transforms
 Instruction *InstCombiner::commonIRemTransforms(BinaryOperator &I) {
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
 

test/Transforms/InstCombine/fabs-copysign.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 declare double @llvm.fabs.f64(double)
 declare float @llvm.fabs.f32(float)
+declare <4 x double> @llvm.fabs.v4f64(<4 x double>)
 declare void @use(double)
 
 declare double @llvm.copysign.f64(double, double)
 declare float @llvm.copysign.f32(float, float)
 
 define double @fabs_copysign(double %x) {
 ; CHECK-LABEL: @fabs_copysign(
-; CHECK-NEXT:    [[F:%.*]] = tail call double @llvm.fabs.f64(double [[X:%.*]])
-; CHECK-NEXT:    [[DIV:%.*]] = fdiv nnan ninf double [[X]], [[F]]
-; CHECK-NEXT:    ret double [[DIV]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf double @llvm.copysign.f64(double 1.000000e+00, double [[X:%.*]])
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %f = tail call double @llvm.fabs.f64(double %x)
   %div = fdiv nnan ninf double %x, %f
   ret double %div
 }
 
+define <4 x double> @fabs_copysign_vec(<4 x double> %x) {
+; CHECK-LABEL: @fabs_copysign_vec(
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf <4 x double> @llvm.copysign.v4f64(<4 x double> <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00>, <4 x double> [[X:%.*]])
+; CHECK-NEXT:    ret <4 x double> [[TMP1]]
+;
+  %f = call <4 x double> @llvm.fabs.v4f64(<4 x double> %x)
+  %div = fdiv nnan ninf <4 x double> %x, %f
+  ret <4 x double> %div
+}
+
 
 define float @fabs_copysignf(float %x) {
 ; CHECK-LABEL: @fabs_copysignf(
-; CHECK-NEXT:    [[F:%.*]] = tail call float @llvm.fabs.f32(float [[X:%.*]])
-; CHECK-NEXT:    [[DIV:%.*]] = fdiv nnan ninf float [[X]], [[F]]
-; CHECK-NEXT:    ret float [[DIV]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf float @llvm.copysign.f32(float 1.000000e+00, float [[X:%.*]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %f = tail call float @llvm.fabs.f32(float %x)
   %div = fdiv nnan ninf float %x, %f
   ret float %div
 }
 
 define double @fabs_copysign_use(double %x) {
 ; CHECK-LABEL: @fabs_copysign_use(
-; CHECK-NEXT:    [[F:%.*]] = tail call double @llvm.fabs.f64(double [[X:%.*]])
-; CHECK-NEXT:    [[DIV:%.*]] = fdiv nnan ninf double [[X]], [[F]]
-; CHECK-NEXT:    ret double [[DIV]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf double @llvm.copysign.f64(double 1.000000e+00, double [[X:%.*]])
+; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %f = tail call double @llvm.fabs.f64(double %x)
   %div = fdiv nnan ninf double %x, %f
   ret double %div
 }
 
 ; Negative tests
 
 define double @fabs_copysign_mismatch(double %x, double %y) {
 ; CHECK-LABEL: @fabs_copysign_mismatch(
 ; CHECK-NEXT:    [[F:%.*]] = tail call double @llvm.fabs.f64(double [[Y:%.*]])
-; CHECK-NEXT:    [[DIV:%.*]] = fdiv double [[X:%.*]], [[F]]
+; CHECK-NEXT:    [[DIV:%.*]] = fdiv nnan ninf double [[X:%.*]], [[F]]
 ; CHECK-NEXT:    ret double [[DIV]]
 ;
   %f = tail call double @llvm.fabs.f64(double %y)
-  %div = fdiv double %x, %f
+  %div = fdiv nnan ninf double %x, %f
   ret double %div
 }
 
 define double @fabs_copysign_no_nnan(double %x) {
 ; CHECK-LABEL: @fabs_copysign_no_nnan(
 ; CHECK-NEXT:    [[F:%.*]] = tail call double @llvm.fabs.f64(double [[X:%.*]])
 ; CHECK-NEXT:    [[DIV:%.*]] = fdiv ninf double [[X]], [[F]]
 ; CHECK-NEXT:    ret double [[DIV]]