[ConstantFolding] Constant-fold llvm.sqrt(x) like other intrinsics.

[jlebar]

Summary

Currently we return undef, but we're in the process of changing the
LangRef so that llvm.sqrt behaves like the other math intrinsics,
matching the return value of the standard libcall but not setting errno.

This change is legal even without the LangRef change because currently
calling llvm.sqrt(x) where x is negative is spec'ed to be UB. But in
practice it's also safe because we're simply constant-folding fewer
inputs: Inputs >= -0 get constant-folded as before, but inputs < -0 now
aren't constant-folded, because ConstantFoldFP aborts if the host math
function raises an fp exception.

[efriedma]

llvm/test/Transforms/InstCombine/constant-fold-math.ll

54 ↗

(On Diff #85064)

Leave the test, and just update the CHECK line?

[jlebar]

llvm/test/Transforms/InstCombine/constant-fold-math.ll

54 ↗

(On Diff #85064)

The CHECK in this case would be checking that the sqrt is not constant-folded. (sqrt(-2) raises an fp exception, and we don't currently constant-fold intrinsics whose libm equivalents raise exceptions.) I didn't think this was an interesting test, because it's a limitation of the compiler that we don't currently constant-fold it, not a correctness issue.

[efriedma]

llvm/test/Transforms/InstCombine/constant-fold-math.ll

54 ↗

(On Diff #85064)

Well, we'd like to know if the compiler is doing something unexpected. We can update the test when we teach the compiler that sqrt(-1) == NaN.

[jlebar]

Add test checking that we don't constant-fold llvm.sqrt(-2).

[jlebar]

llvm/test/Transforms/InstCombine/constant-fold-math.ll

54 ↗

(On Diff #85064)

OK, done.

[efriedma]

Looks fine.

llvm/trunk/lib/Analysis/ConstantFolding.cpp

if (auto *Op = dyn_cast<ConstantFP>(Operands[0])) {
         case Intrinsic::exp:
           return ConstantFoldFP(exp, V, Ty);
         case Intrinsic::exp2:
           return ConstantFoldFP(exp2, V, Ty);
         case Intrinsic::sin:
           return ConstantFoldFP(sin, V, Ty);
         case Intrinsic::cos:
           return ConstantFoldFP(cos, V, Ty);
+        case Intrinsic::sqrt:
+          return ConstantFoldFP(sqrt, V, Ty);
       }
 
       if (!TLI)
         return nullptr;
 
       switch (Name[0]) {
       case 'a':
         if ((Name == "acos" && TLI->has(LibFunc::acos)) ||
if (auto *Op = dyn_cast<ConstantFP>(Operands[0])) {
         break;
       case 'l':
         if ((Name == "log" && V > 0 && TLI->has(LibFunc::log)) ||
             (Name == "logf" && V > 0 && TLI->has(LibFunc::logf)))
           return ConstantFoldFP(log, V, Ty);
         else if ((Name == "log10" && V > 0 && TLI->has(LibFunc::log10)) ||
                  (Name == "log10f" && V > 0 && TLI->has(LibFunc::log10f)))
           return ConstantFoldFP(log10, V, Ty);
-        else if (IntrinsicID == Intrinsic::sqrt &&
-                 (Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy())) {
-          if (V >= -0.0)
-            return ConstantFoldFP(sqrt, V, Ty);
-          else {
-            // Unlike the sqrt definitions in C/C++, POSIX, and IEEE-754 - which
-            // all guarantee or favor returning NaN - the square root of a
-            // negative number is not defined for the LLVM sqrt intrinsic.
-            // This is because the intrinsic should only be emitted in place of
-            // libm's sqrt function when using "no-nans-fp-math".
-            return UndefValue::get(Ty);
-          }
-        }
         break;
       case 'r':
         if ((Name == "round" && TLI->has(LibFunc::round)) ||
             (Name == "roundf" && TLI->has(LibFunc::roundf)))
           return ConstantFoldFP(round, V, Ty);
       case 's':
         if ((Name == "sin" && TLI->has(LibFunc::sin)) ||
             (Name == "sinf" && TLI->has(LibFunc::sinf)))

llvm/trunk/test/Transforms/InstCombine/constant-fold-math.ll

 
 ; CHECK-LABEL: @constant_fold_fmuladd_f64
 ; CHECK-NEXT: ret double 6.000000e+00
 define double @constant_fold_fmuladd_f64() #0 {
   %x = call double @llvm.fmuladd.f64(double 1.0, double 2.0, double 4.0) #0
   ret double %x
 }
 
-; The sqrt intrinsic is undefined for negative inputs besides -0.0.
+; Currently we don't constant-fold intrinsics whose corresponding libcalls
+; raise an fp exception.
 ; CHECK-LABEL: @bad_sqrt
-; CHECK-NEXT: ret double undef
+; CHECK-NEXT: call double @llvm.sqrt.f64(double -2
 define double @bad_sqrt() {
   %x = call double @llvm.sqrt.f64(double -2.000000e+00)
   ret double %x
 }
 
 attributes #0 = { nounwind readnone }