[ConstantFolding] Refactor math functions to use LLVM ones (NFC)

[evandro]

Summary

When possible, replace calls to library routines on the host with equivalent ones in LLVM.

[efriedma]

LGTM

llvm/trunk/lib/Analysis/ConstantFolding.cpp

if (IntrinsicID == Intrinsic::convert_to_fp16) {
       Val.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &lost);
 
       return ConstantInt::get(Ty->getContext(), Val.bitcastToAPInt());
     }
 
     if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
       return nullptr;
 
-    if (IntrinsicID == Intrinsic::round) {
-      APFloat V = Op->getValueAPF();
-      V.roundToIntegral(APFloat::rmNearestTiesToAway);
-      return ConstantFP::get(Ty->getContext(), V);
+    // Use internal versions of these intrinsics.
+    APFloat U = Op->getValueAPF();
+
+    if (IntrinsicID == Intrinsic::nearbyint || IntrinsicID == Intrinsic::rint) {
+      U.roundToIntegral(APFloat::rmNearestTiesToEven);
+      return ConstantFP::get(Ty->getContext(), U);
     }
 
-    if (IntrinsicID == Intrinsic::floor) {
-      APFloat V = Op->getValueAPF();
-      V.roundToIntegral(APFloat::rmTowardNegative);
-      return ConstantFP::get(Ty->getContext(), V);
+    if (IntrinsicID == Intrinsic::round) {
+      U.roundToIntegral(APFloat::rmNearestTiesToAway);
+      return ConstantFP::get(Ty->getContext(), U);
     }
 
     if (IntrinsicID == Intrinsic::ceil) {
-      APFloat V = Op->getValueAPF();
-      V.roundToIntegral(APFloat::rmTowardPositive);
-      return ConstantFP::get(Ty->getContext(), V);
+      U.roundToIntegral(APFloat::rmTowardPositive);
+      return ConstantFP::get(Ty->getContext(), U);
     }
 
-    if (IntrinsicID == Intrinsic::trunc) {
-      APFloat V = Op->getValueAPF();
-      V.roundToIntegral(APFloat::rmTowardZero);
-      return ConstantFP::get(Ty->getContext(), V);
+    if (IntrinsicID == Intrinsic::floor) {
+      U.roundToIntegral(APFloat::rmTowardNegative);
+      return ConstantFP::get(Ty->getContext(), U);
     }
 
-    if (IntrinsicID == Intrinsic::rint) {
-      APFloat V = Op->getValueAPF();
-      V.roundToIntegral(APFloat::rmNearestTiesToEven);
-      return ConstantFP::get(Ty->getContext(), V);
+    if (IntrinsicID == Intrinsic::trunc) {
+      U.roundToIntegral(APFloat::rmTowardZero);
+      return ConstantFP::get(Ty->getContext(), U);
     }
 
-    if (IntrinsicID == Intrinsic::nearbyint) {
-      APFloat V = Op->getValueAPF();
-      V.roundToIntegral(APFloat::rmNearestTiesToEven);
-      return ConstantFP::get(Ty->getContext(), V);
+    if (IntrinsicID == Intrinsic::fabs) {
+      U.clearSign();
+      return ConstantFP::get(Ty->getContext(), U);
     }
 
     /// We only fold functions with finite arguments. Folding NaN and inf is
     /// likely to be aborted with an exception anyway, and some host libms
     /// have known errors raising exceptions.
     if (Op->getValueAPF().isNaN() || Op->getValueAPF().isInfinity())
       return nullptr;
 
     /// Currently APFloat versions of these functions do not exist, so we use
     /// the host native double versions.  Float versions are not called
     /// directly but for all these it is true (float)(f((double)arg)) ==
     /// f(arg).  Long double not supported yet.
     double V = getValueAsDouble(Op);
 
     switch (IntrinsicID) {
       default: break;
-      case Intrinsic::fabs:
-        return ConstantFoldFP(fabs, V, Ty);
       case Intrinsic::log:
         return ConstantFoldFP(log, V, Ty);
       case Intrinsic::log2:
         // TODO: What about hosts that lack a C99 library?
         return ConstantFoldFP(Log2, V, Ty);
       case Intrinsic::log10:
         // TODO: What about hosts that lack a C99 library?
         return ConstantFoldFP(log10, V, Ty);
switch (IntrinsicID) {
         return ConstantFoldFP(sqrt, V, Ty);
     }
 
     if (!TLI)
       return nullptr;
 
     LibFunc Func = NotLibFunc;
     TLI->getLibFunc(Name, Func);
-
     switch (Func) {
     default:
       break;
     case LibFunc_acos:
     case LibFunc_acosf:
     case LibFunc_acos_finite:
     case LibFunc_acosf_finite:
       if (TLI->has(Func))
         return ConstantFoldFP(acos, V, Ty);
       break;
     case LibFunc_asin:
     case LibFunc_asinf:
     case LibFunc_asin_finite:
     case LibFunc_asinf_finite:
       if (TLI->has(Func))
         return ConstantFoldFP(asin, V, Ty);
       break;
     case LibFunc_atan:
     case LibFunc_atanf:
       if (TLI->has(Func))
         return ConstantFoldFP(atan, V, Ty);
       break;
     case LibFunc_ceil:
     case LibFunc_ceilf:
-      if (TLI->has(Func))
-        return ConstantFoldFP(ceil, V, Ty);
+      if (TLI->has(Func)) {
+        U.roundToIntegral(APFloat::rmTowardPositive);
+        return ConstantFP::get(Ty->getContext(), U);
+      }
       break;
     case LibFunc_cos:
     case LibFunc_cosf:
       if (TLI->has(Func))
         return ConstantFoldFP(cos, V, Ty);
       break;
     case LibFunc_cosh:
     case LibFunc_coshf:
if (auto *Op = dyn_cast<ConstantFP>(Operands[0])) {
     case LibFunc_exp2_finite:
     case LibFunc_exp2f_finite:
       if (TLI->has(Func))
         // Fold exp2(x) as pow(2, x), in case the host lacks a C99 library.
         return ConstantFoldBinaryFP(pow, 2.0, V, Ty);
       break;
     case LibFunc_fabs:
     case LibFunc_fabsf:
-      if (TLI->has(Func))
-        return ConstantFoldFP(fabs, V, Ty);
+      if (TLI->has(Func)) {
+        U.clearSign();
+        return ConstantFP::get(Ty->getContext(), U);
+      }
       break;
     case LibFunc_floor:
     case LibFunc_floorf:
-      if (TLI->has(Func))
-        return ConstantFoldFP(floor, V, Ty);
+      if (TLI->has(Func)) {
+        U.roundToIntegral(APFloat::rmTowardNegative);
+        return ConstantFP::get(Ty->getContext(), U);
+      }
       break;
     case LibFunc_log:
     case LibFunc_logf:
+
     case LibFunc_log_finite:
     case LibFunc_logf_finite:
       if (V > 0.0 && TLI->has(Func))
         return ConstantFoldFP(log, V, Ty);
       break;
     case LibFunc_log10:
     case LibFunc_log10f:
     case LibFunc_log10_finite:
     case LibFunc_log10f_finite:
       if (V > 0.0 && TLI->has(Func))
         // TODO: What about hosts that lack a C99 library?
         return ConstantFoldFP(log10, V, Ty);
       break;
     case LibFunc_round:
     case LibFunc_roundf:
-      if (TLI->has(Func))
-        return ConstantFoldFP(round, V, Ty);
+      if (TLI->has(Func)) {
+        U.roundToIntegral(APFloat::rmNearestTiesToAway);
+        return ConstantFP::get(Ty->getContext(), U);
+      }
       break;
     case LibFunc_sin:
     case LibFunc_sinf:
       if (TLI->has(Func))
         return ConstantFoldFP(sin, V, Ty);
       break;
     case LibFunc_sinh:
     case LibFunc_sinhf:
if (auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
       case LibFunc_powf:
       case LibFunc_pow_finite:
       case LibFunc_powf_finite:
         if (TLI->has(Func))
           return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
         break;
       case LibFunc_fmod:
       case LibFunc_fmodf:
-        if (TLI->has(Func))
-          // TODO: What about hosts that lack a C99 library?
-          return ConstantFoldBinaryFP(fmod, Op1V, Op2V, Ty);
+        if (TLI->has(Func)) {
+          APFloat V = Op1->getValueAPF();
+          if (APFloat::opStatus::opOK == V.mod(Op2->getValueAPF()))
+            return ConstantFP::get(Ty->getContext(), V);
+        }
         break;
       case LibFunc_atan2:
       case LibFunc_atan2f:
       case LibFunc_atan2_finite:
       case LibFunc_atan2f_finite:
         if (TLI->has(Func))
           return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
         break;