Fix tests and handle signed zeros

Author: HendrikHuebner

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

@@ -1962,37 +1962,45 @@ Value *LibCallSimplifier::optimizeCAbs(CallInst *CI, IRBuilderBase &B) {
   Value *Real, *Imag;
 
   if (CI->arg_size() == 1) {
+
+    if (!CI->isFast())
+      return nullptr;
+
     Value *Op = CI->getArgOperand(0);
     assert(Op->getType()->isArrayTy() && "Unexpected signature for cabs!");
+
     Real = B.CreateExtractValue(Op, 0, "real");
     Imag = B.CreateExtractValue(Op, 1, "imag");
 
   } else {
     assert(CI->arg_size() == 2 && "Unexpected signature for cabs!");
+
     Real = CI->getArgOperand(0);
     Imag = CI->getArgOperand(1);
-  }
 
-  // if real or imaginary part is zero, simplify to abs(cimag(z))
-  // or abs(creal(z))
-  if (ConstantFP *ConstReal = dyn_cast<ConstantFP>(Real)) {
-    if (ConstReal->isZeroValue()) {
-      IRBuilderBase::FastMathFlagGuard Guard(B);
-      B.setFastMathFlags(CI->getFastMathFlags());
-      return copyFlags(
-          *CI, B.CreateUnaryIntrinsic(Intrinsic::fabs, Imag, nullptr, "cabs"));
+    // if real or imaginary part is zero, simplify to abs(cimag(z))
+    // or abs(creal(z))
+    Value *AbsOp = nullptr;
+    if (ConstantFP *ConstReal = dyn_cast<ConstantFP>(Real)) {
+      if (ConstReal->isZero())
+        AbsOp = Imag;
+
+    } else if (ConstantFP *ConstImag = dyn_cast<ConstantFP>(Imag)) {
+      if (ConstImag->isZero())
+        AbsOp = Real;
     }
-  } else if (ConstantFP *ConstReal = dyn_cast<ConstantFP>(Imag)) {
-    if (ConstReal->isZeroValue()) {
+
+    if (AbsOp) {
       IRBuilderBase::FastMathFlagGuard Guard(B);
       B.setFastMathFlags(CI->getFastMathFlags());
+
       return copyFlags(
-          *CI, B.CreateUnaryIntrinsic(Intrinsic::fabs, Real, nullptr, "cabs"));
+          *CI, B.CreateUnaryIntrinsic(Intrinsic::fabs, AbsOp, nullptr, "cabs"));
     }
-  }
 
-  if (!CI->isFast())
-    return nullptr;
+    if (!CI->isFast())
+      return nullptr;
+  }
 
   // Propagate fast-math flags from the existing call to new instructions.
   IRBuilderBase::FastMathFlagGuard Guard(B);

llvm/test/Transforms/InstCombine/cabs-discrete.ll

@@ -49,6 +49,15 @@ define double @fast_cabs_zero_real(double %imag) {
   ret double %call
 }
 
+define double @fast_cabs_neg_zero_real(double %imag) {
+; CHECK-LABEL: @fast_cabs_neg_zero_real(
+; CHECK-NEXT:    [[CABS:%.*]] = tail call double @llvm.fabs.f64(double [[IMAG:%.*]])
+; CHECK-NEXT:    ret double [[CABS]]
+;
+  %call = tail call double @cabs(double -0.0, double %imag)
+  ret double %call
+}
+
 define double @fast_cabs_zero_imag(double %real) {
 ; CHECK-LABEL: @fast_cabs_zero_imag(
 ; CHECK-NEXT:    [[CABS:%.*]] = tail call double @llvm.fabs.f64(double [[REAL:%.*]])
@@ -79,9 +88,18 @@ define float @fast_cabsf_zero_real(float %imag) {
   ret float %call
 }
 
+define float @fast_cabsf_neg_zero_real(float %imag) {
+; CHECK-LABEL: @fast_cabsf_neg_zero_real(
+; CHECK-NEXT:    [[CABS:%.*]] = tail call float @llvm.fabs.f32(float [[IMAG:%.*]])
+; CHECK-NEXT:    ret float [[CABS]]
+;
+  %call = tail call float @cabsf(float -0.0, float %imag)
+  ret float %call
+}
+
 define float @fast_cabsf_zero_imag(float %real) {
 ; CHECK-LABEL: @fast_cabsf_zero_imag(
-; CHECK-NEXT:    [[CABS:%.*]] = tail call float @llvm.fabs.f64(float [[REAL:%.*]])
+; CHECK-NEXT:    [[CABS:%.*]] = tail call float @llvm.fabs.f32(float [[REAL:%.*]])
 ; CHECK-NEXT:    ret float [[CABS]]
 ;
   %call = tail call float @cabsf(float %real, float 0.0)
@@ -102,10 +120,10 @@ define fp128 @fast_cabsl(fp128 %real, fp128 %imag) {
 
 define fp128 @fast_cabsl_zero_real(fp128 %imag) {
 ; CHECK-LABEL: @fast_cabsl_zero_real(
-; CHECK-NEXT:    [[CABS:%.*]] = tail call fp128 @llvm.fabsl.f128(fp128 [[IMAG:%.*]])
+; CHECK-NEXT:    [[CABS:%.*]] = tail call fp128 @llvm.fabs.f128(fp128 [[IMAG:%.*]])
 ; CHECK-NEXT:    ret fp128 [[CABS]]
 ;
-  %call = tail call fp128 @cabsl(double 0.0, fp128 %imag)
+  %call = tail call fp128 @cabsl(fp128 0xL00000000000000000000000000000000, fp128 %imag)
   ret fp128 %call
 }
 
@@ -114,7 +132,16 @@ define fp128 @fast_cabsl_zero_imag(fp128 %real) {
 ; CHECK-NEXT:    [[CABS:%.*]] = tail call fp128 @llvm.fabs.f128(fp128 [[REAL:%.*]])
 ; CHECK-NEXT:    ret fp128 [[CABS]]
 ;
-  %call = tail call fp128 @cabsl(fp128 %real, fp128 0.0)
+  %call = tail call fp128 @cabsl(fp128 %real, fp128 0xL00000000000000000000000000000000)
+  ret fp128 %call
+}
+
+define fp128 @fast_cabsl_neg_zero_imag(fp128 %real) {
+; CHECK-LABEL: @fast_cabsl_neg_zero_imag(
+; CHECK-NEXT:    [[CABS:%.*]] = tail call fp128 @llvm.fabs.f128(fp128 [[REAL:%.*]])
+; CHECK-NEXT:    ret fp128 [[CABS]]
+;
+  %call = tail call fp128 @cabsl(fp128 %real, fp128 0xL80000000000000000000000000000000)
   ret fp128 %call
 }