[libc] Fix some math conversion warnings

libc/src/__support/FPUtil/ManipulationFunctions.h

LIBC_INLINE T logb(T x) {
   } else if (bits.is_nan()) {
     return x;
   } else if (bits.is_inf()) {
     // Return positive infinity.
     return T(FPBits<T>::inf());
   }
 
   NormalFloat<T> normal(bits);
-  return normal.exponent;
+  return static_cast<T>(normal.exponent);
 }
 
 template <typename T, cpp::enable_if_t<cpp::is_floating_point_v<T>, int> = 0>
 LIBC_INLINE T ldexp(T x, int exp) {
   if (LIBC_UNLIKELY(exp == 0))
     return x;
   FPBits<T> bits(x);
   if (LIBC_UNLIKELY(bits.is_zero() || bits.is_inf_or_nan()))

libc/src/__support/FPUtil/NearestIntegerOperations.h

if (bits.get_sign() == 0 || bits.get_mantissa() != 0) {
       set_domain_error_and_raise_invalid();
       return bits.get_sign() ? INTEGER_MIN : INTEGER_MAX;
     }
     // If the control reaches here, then it means that the rounded
     // value is the most negative number for the signed integer type I.
   }
 
   // For all other cases, if `x` can fit in the integer type `I`,
-  // we just return `x`. Implicit conversion will convert the
-  // floating point value to the exact integer value.
-  return x;
+  // we just return `x`. static_cast will convert the floating
+  // point value to the exact integer value.
+  return static_cast<I>(x);
 }
 
 } // namespace internal
 
 template <typename F, typename I,
           cpp::enable_if_t<cpp::is_floating_point_v<F> && cpp::is_integral_v<I>,
                            int> = 0>
 LIBC_INLINE I round_to_signed_integer(F x) {

libc/src/math/generic/acosf.cpp

if (LIBC_UNLIKELY(x_abs < 0x3a80'0000U)) {
       //   acos(x) = pi/2 - asin(x)
       //           ~ pi/2 - x - x^3 / 6
 
       // Check for exceptional values
       if (auto r = ACOSF_EXCEPTS.lookup(x_uint); LIBC_UNLIKELY(r.has_value()))
         return r.value();
 
       double xd = static_cast<double>(x);
-      return fputil::multiply_add(-0x1.5555555555555p-3 * xd, xd * xd,
-                                  M_MATH_PI_2 - xd);
+      return static_cast<float>(fputil::multiply_add(
+          -0x1.5555555555555p-3 * xd, xd * xd, M_MATH_PI_2 - xd));
     }
 
     // For |x| <= 0.5, we approximate acosf(x) by:
     //   acos(x) = pi/2 - asin(x) = pi/2 - x * P(x^2)
     // Where P(X^2) = Q(X) is a degree-20 minimax even polynomial approximating
     // asin(x)/x on [0, 0.5] generated by Sollya with:
     // > Q = fpminimax(asin(x)/x, [|0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20|],
     //                 [|1, D...|], [0, 0.5]);
     double xd = static_cast<double>(x);
     double xsq = xd * xd;
     double x3 = xd * xsq;
     double r = asin_eval(xsq);
-    return fputil::multiply_add(-x3, r, M_MATH_PI_2 - xd);
+    return static_cast<float>(fputil::multiply_add(-x3, r, M_MATH_PI_2 - xd));
   }
 
   // |x| > 1, return NaNs.
   if (LIBC_UNLIKELY(x_abs > 0x3f80'0000U)) {
     if (x_abs <= 0x7f80'0000U) {
       fputil::set_errno_if_required(EDOM);
       fputil::raise_except_if_required(FE_INVALID);
     }
LLVM_LIBC_FUNCTION(float, acosf, (float x)) {
 
   xbits.set_sign(false);
   double xd = static_cast<double>(xbits.get_val());
   double u = fputil::multiply_add(-0.5, xd, 0.5);
   double cv = 2 * fputil::sqrt(u);
 
   double r3 = asin_eval(u);
   double r = fputil::multiply_add(cv * u, r3, cv);
-  return x_sign ? M_MATH_PI - r : r;
+  return static_cast<float>(x_sign ? M_MATH_PI - r : r);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/acoshf.cpp

case 0x6eb1a8ec: // x = 0x1.6351d8p94f
       return round_result_slightly_down(0x1.08b512p6f);
     case 0x7997f30a: // x = 0x1.2fe614p116f
       return round_result_slightly_up(0x1.451436p6f);
     }
   }
 
   double x_d = static_cast<double>(x);
   // acosh(x) = log(x + sqrt(x^2 - 1))
-  return log_eval(x_d + fputil::sqrt(fputil::multiply_add(x_d, x_d, -1.0)));
+  return static_cast<float>(
+      log_eval(x_d + fputil::sqrt(fputil::multiply_add(x_d, x_d, -1.0))));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/asinf.cpp

#endif // LIBC_TARGET_CPU_HAS_FMA
     // > Q = fpminimax(asin(x)/x, [|0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20|],
     //                 [|1, D...|], [0, 0.5]);
     // An exhaustive test shows that this approximation works well up to a
     // little more than 0.5.
     double xd = static_cast<double>(x);
     double xsq = xd * xd;
     double x3 = xd * xsq;
     double r = asin_eval(xsq);
-    return fputil::multiply_add(x3, r, xd);
+    return static_cast<float>(fputil::multiply_add(x3, r, xd));
   }
 
   // |x| > 1, return NaNs.
   if (LIBC_UNLIKELY(x_abs > 0x3f80'0000U)) {
     if (x_abs <= 0x7f80'0000U) {
       fputil::set_errno_if_required(EDOM);
       fputil::raise_except_if_required(FE_INVALID);
     }
#endif // LIBC_TARGET_CPU_HAS_FMA
   double sign = SIGN[x_sign];
   double xd = static_cast<double>(xbits.get_val());
   double u = fputil::multiply_add(-0.5, xd, 0.5);
   double c1 = sign * (-2 * fputil::sqrt(u));
   double c2 = fputil::multiply_add(sign, M_MATH_PI_2, c1);
   double c3 = c1 * u;
 
   double r = asin_eval(u);
-  return fputil::multiply_add(c3, r, c2);
+  return static_cast<float>(fputil::multiply_add(c3, r, c2));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/asinhf.cpp

LLVM_LIBC_FUNCTION(float, asinhf, (float x)) {
   FPBits_t xbits(x);
   uint32_t x_u = xbits.uintval();
   uint32_t x_abs = x_u & FPBits_t::FloatProp::EXP_MANT_MASK;
 
   // |x| <= 2^-3
   if (LIBC_UNLIKELY(x_abs <= 0x3e80'0000U)) {
     // |x| <= 2^-26
     if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) {
-      return LIBC_UNLIKELY(x_abs == 0) ? x
-                                       : (x - 0x1.5555555555555p-3 * x * x * x);
+      return static_cast<float>(LIBC_UNLIKELY(x_abs == 0)
+                                    ? x
+                                    : (x - 0x1.5555555555555p-3 * x * x * x));
     }
 
     double x_d = x;
     double x_sq = x_d * x_d;
     // Generated by Sollya with:
     // > P = fpminimax(asinh(x)/x, [|0, 2, 4, 6, 8, 10, 12, 14, 16], [|D...|],
     //                 [0, 2^-2]);
     double p = fputil::polyeval(
         x_sq, 0.0, -0x1.555555555551ep-3, 0x1.3333333325495p-4,
         -0x1.6db6db5a7622bp-5, 0x1.f1c70f82928c6p-6, -0x1.6e893934266b7p-6,
         0x1.1c0b41d3fbe78p-6, -0x1.c0f47810b3c4fp-7, 0x1.2c8602690143dp-7);
-    return fputil::multiply_add(x_d, p, x_d);
+    return static_cast<float>(fputil::multiply_add(x_d, p, x_d));
   }
 
   const double SIGN[2] = {1.0, -1.0};
   double x_sign = SIGN[x_u >> 31];
   double x_d = x;
 
   // Helper functions to set results for exceptional cases.
   auto round_result_slightly_down = [x_sign](float r) -> float {
if (LIBC_UNLIKELY(x_abs >= 0x4bdd'65a5U)) {
     }
     if (LIBC_UNLIKELY(x_abs == 0x49d29048)) {
       // |x| = 0x1.a5209p20f
       return round_result_slightly_down(0x1.e1b92p3f);
     }
   }
 
   // asinh(x) = log(x + sqrt(x^2 + 1))
-  return x_sign *
-         log_eval(fputil::multiply_add(
-             x_d, x_sign, fputil::sqrt(fputil::multiply_add(x_d, x_d, 1.0))));
+  return static_cast<float>(
+      x_sign *
+          x_d, x_sign, fputil::sqrt(fputil::multiply_add(x_d, x_d, 1.0)))));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/atanf.cpp

 LLVM_LIBC_FUNCTION(float, atanf, (float x)) {
   using FPBits = typename fputil::FPBits<float>;
   FPBits xbits(x);
   bool sign = xbits.get_sign();
   xbits.set_sign(false);
 
   if (LIBC_UNLIKELY(xbits.is_inf_or_nan())) {
     if (xbits.is_inf())
-      return opt_barrier(sign ? -M_MATH_PI_2 : M_MATH_PI_2);
+      return static_cast<float>(opt_barrier(sign ? -M_MATH_PI_2 : M_MATH_PI_2));
     else
       return x;
   }
   // |x| == 0.06905200332403183
   if (LIBC_UNLIKELY(xbits.uintval() == 0x3d8d6b23U)) {
     if (fputil::get_round() == FE_TONEAREST) {
       // 0.06894256919622421
       FPBits br(0x3d8d31c3U);
if (LIBC_UNLIKELY(xbits.uintval() == 0x3feefcfbU)) {
     } else {
       if (rounding_mode == FE_UPWARD) {
         // 1.0790828466415405
         return FPBits(0x3f8a1f63U).get_val();
       }
     }
   }
 
-  return atan_eval(x);
+  return static_cast<float>(atan_eval(x));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/atanhf.cpp

if (x_abs == 0x3F80'0000U) {
       return FPBits::build_quiet_nan(0);
     }
   }
 
   // |x| < ~0.10
   if (LIBC_UNLIKELY(x_abs <= 0x3dcc'0000U)) {
     // |x| <= 2^-26
     if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) {
-      return LIBC_UNLIKELY(x_abs == 0) ? x
-                                       : (x + 0x1.5555555555555p-2 * x * x * x);
+      return static_cast<float>(LIBC_UNLIKELY(x_abs == 0)
+                                    ? x
+                                    : (x + 0x1.5555555555555p-2 * x * x * x));
     }
 
     double xdbl = x;
     double x2 = xdbl * xdbl;
     // Pure Taylor series.
     double pe = fputil::polyeval(x2, 0.0, 0x1.5555555555555p-2,
                                  0x1.999999999999ap-3, 0x1.2492492492492p-3,
                                  0x1.c71c71c71c71cp-4, 0x1.745d1745d1746p-4);
-    return fputil::multiply_add(xdbl, pe, xdbl);
+    return static_cast<float>(fputil::multiply_add(xdbl, pe, xdbl));
   }
   double xdbl = x;
-  return 0.5 * log_eval((xdbl + 1.0) / (xdbl - 1.0));
+  return static_cast<float>(0.5 * log_eval((xdbl + 1.0) / (xdbl - 1.0)));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/cosf.cpp

#endif // LIBC_TARGET_CPU_HAS_FMA
   //   cos(x) = cos((k + y)*pi/32)
   //          = cos(y*pi/32) * cos(k*pi/32) - sin(y*pi/32) * sin(k*pi/32)
   //          = cosm1_y * cos_k + sin_y * sin_k
   //          = (cosm1_y * cos_k + cos_k) + sin_y * sin_k
   double sin_k, cos_k, sin_y, cosm1_y;
 
   sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
 
-  return fputil::multiply_add(sin_y, -sin_k,
-                              fputil::multiply_add(cosm1_y, cos_k, cos_k));
+  return static_cast<float>(fputil::multiply_add(
+      sin_y, -sin_k, fputil::multiply_add(cosm1_y, cos_k, cos_k)));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/coshf.cpp

if (LIBC_UNLIKELY(x_u >= 0x42b4'0000U)) {
     return x + FPBits::inf().get_val();
   }
 
   // TODO: We should be able to reduce the latency and reciprocal throughput
   // further by using a low degree (maybe 3-7 ?) minimax polynomial for small
   // but not too small inputs, such as |x| < 2^-2, or |x| < 2^-3.
 
   // cosh(x) = (e^x + e^(-x)) / 2.
-  return exp_pm_eval</*is_sinh*/ false>(x);
+  return static_cast<float>(exp_pm_eval</*is_sinh*/ false>(x));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/exp10f.cpp

if (LIBC_UNLIKELY(x_u == 0xb25e'5bd9U)) { // x = -0x1.bcb7b2p-27f
         return 0x1.fffffep-1f;
     }
     // |x| < 2^-25
     // 10^x ~ 1 + log(10) * x
     if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) {
       return fputil::multiply_add(x, 0x1.26bb1cp+1f, 1.0f);
     }
 
-    return Exp10Base::powb_lo(x);
+    return static_cast<float>(Exp10Base::powb_lo(x));
   }
 
   // Exceptional value.
   if (LIBC_UNLIKELY(x_u == 0x3d14'd956U)) { // x = 0x1.29b2acp-5f
     if (fputil::get_round() == FE_UPWARD)
       return 0x1.1657c4p+0f;
   }
 
LLVM_LIBC_FUNCTION(float, exp10f, (float x)) {
   double c2 = multiply_add(rr.lo, Exp10Base::COEFFS[4], Exp10Base::COEFFS[3]);
   // p = c1 + c2 * lo^2
   //   = COEFFS[1] + COEFFS[2] * lo + COEFFS[3] * lo^2 + COEFFS[4] * lo^3
   double p = multiply_add(lo2, c2, c1);
   // 10^lo ~ c0 + p * lo^2
   // 10^x = 2^(mid + hi) * 10^lo
   //      ~ mh * (c0 + p * lo^2)
   //      = (mh * c0) + p * (mh * lo^2)
-  return multiply_add(p, lo2 * rr.mh, c0 * rr.mh);
+  return static_cast<float>(multiply_add(p, lo2 * rr.mh, c0 * rr.mh));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/exp2f.cpp

LLVM_LIBC_FUNCTION(float, exp2f, (float x)) {
   double c1 = fputil::multiply_add(dx, COEFFS[0], 1.0);
   double c2 = fputil::multiply_add(dx, COEFFS[2], COEFFS[1]);
   double c3 = fputil::multiply_add(dx, COEFFS[4], COEFFS[3]);
   double p = fputil::multiply_add(dx_sq, c3, c2);
   // 2^x = 2^(hi + mid + lo)
   //     = 2^(hi + mid) * 2^lo
   //     ~ mh * (1 + lo * P(lo))
   //     = mh + (mh*lo) * P(lo)
-  return fputil::multiply_add(p, dx_sq * mh, c1 * mh);
+  return static_cast<float>(fputil::multiply_add(p, dx_sq * mh, c1 * mh));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/log10.cpp

LLVM_LIBC_FUNCTION(double, log10, (double x)) {
   // log10(x) = log10(2^x_e * x_m)
   //          = x_e * log10(2) + log10(x_m)
 
   // Range reduction for log10(x_m):
   // For each x_m, we would like to find R such that:
   //   |R * x_m - 1| < C
   uint64_t x_u = xbits.uintval();
   int shifted = x_u >> 45;
-  size_t index = shifted & 0x7F;
+  int index = shifted & 0x7F;
   double r = R[index];
 
   x_e += (x_u >> 52) & 0x7FF;
   double e_x = static_cast<double>(x_e);
 
   int e_err = (e_x == -1) && (index == 0x7F);
   int logr_err = (index == 0);
 

libc/src/math/generic/log1pf.cpp

const double COEFFS[7] = {-0x1.0000000000000p-1, 0x1.5555555556aadp-2,
                             -0x1.0019db915ef6fp-3};
 
   double xsq = xd * xd;
   double c0 = fputil::multiply_add(xd, COEFFS[1], COEFFS[0]);
   double c1 = fputil::multiply_add(xd, COEFFS[3], COEFFS[2]);
   double c2 = fputil::multiply_add(xd, COEFFS[5], COEFFS[4]);
   double r = fputil::polyeval(xsq, xd, c0, c1, c2, COEFFS[6]);
 
-  return r;
+  return static_cast<float>(r);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/sincosf.cpp

#endif // LIBC_TARGET_CPU_HAS_FMA
   //   cos(x) = cos((k + y)*pi/32)
   //          = cos(y*pi/32) * cos(k*pi/32) - sin(y*pi/32) * sin(k*pi/32)
   //          = cosm1_y * cos_k + sin_y * sin_k
   //          = (cosm1_y * cos_k + cos_k) + sin_y * sin_k
   double sin_k, cos_k, sin_y, cosm1_y;
 
   sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
 
-  *sinp = fputil::multiply_add(sin_y, cos_k,
-                               fputil::multiply_add(cosm1_y, sin_k, sin_k));
-  *cosp = fputil::multiply_add(sin_y, -sin_k,
-                               fputil::multiply_add(cosm1_y, cos_k, cos_k));
+  *sinp = static_cast<float>(fputil::multiply_add(
+      sin_y, cos_k, fputil::multiply_add(cosm1_y, sin_k, sin_k)));
+  *cosp = static_cast<float>(fputil::multiply_add(
+      sin_y, -sin_k, fputil::multiply_add(cosm1_y, cos_k, cos_k)));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/sinf.cpp

#endif // LIBC_TARGET_CPU_HAS_FMA
     //          = x (1 + a_3 x^2 + ... + a_9 x^8)
     //          = x * P(x^2)
     // generated by Sollya with the following commands:
     // > display = hexadecimal;
     // > Q = fpminimax(sin(x)/x, [|0, 2, 4, 6, 8|], [|1, D...|], [0, pi/16]);
     double result =
         fputil::polyeval(xsq, 1.0, -0x1.55555555554c6p-3, 0x1.1111111085e65p-7,
                          -0x1.a019f70fb4d4fp-13, 0x1.718d179815e74p-19);
-    return xd * result;
+    return static_cast<float>(xd * result);
   }
 
   if (LIBC_UNLIKELY(x_abs == 0x4619'9998U)) { // x = 0x1.33333p13
     float r = -0x1.63f4bap-2f;
     int rounding = fputil::get_round();
     bool sign = xbits.get_sign();
     if ((rounding == FE_DOWNWARD && !sign) || (rounding == FE_UPWARD && sign))
       r = -0x1.63f4bcp-2f;
#endif // LIBC_TARGET_CPU_HAS_FMA
   //   sin(x) = sin((k + y)*pi/32)
   //          = sin(y*pi/32) * cos(k*pi/32) + cos(y*pi/32) * sin(k*pi/32)
   //          = sin_y * cos_k + (1 + cosm1_y) * sin_k
   //          = sin_y * cos_k + (cosm1_y * sin_k + sin_k)
   double sin_k, cos_k, sin_y, cosm1_y;
 
   sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
 
-  return fputil::multiply_add(sin_y, cos_k,
-                              fputil::multiply_add(cosm1_y, sin_k, sin_k));
+  return static_cast<float>(fputil::multiply_add(
+      sin_y, cos_k, fputil::multiply_add(cosm1_y, sin_k, sin_k)));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/sinhf.cpp

 LLVM_LIBC_FUNCTION(float, sinhf, (float x)) {
   using FPBits = typename fputil::FPBits<float>;
   FPBits xbits(x);
   bool sign = xbits.get_sign();
   uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK;
 
   // |x| <= 2^-26
   if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) {
-    return LIBC_UNLIKELY(x_abs == 0) ? x : (x + 0.25 * x * x * x);
+    return static_cast<float>(
+        LIBC_UNLIKELY(x_abs == 0) ? x : (x + 0.25 * x * x * x));
   }
 
   // When |x| >= 90, or x is inf or nan
   if (LIBC_UNLIKELY(x_abs >= 0x42b4'0000U)) {
     if (xbits.is_nan())
       return x + 1.0f; // sNaN to qNaN + signal
 
     if (xbits.is_inf())
if (LIBC_UNLIKELY(x_abs <= 0x3da0'0000U)) {
     double x2 = xdbl * xdbl;
     // Sollya: fpminimax(sinh(x),[|3,5,7|],[|D...|],[-1/16-1/64;1/16+1/64],x);
     // Sollya output: x * (0x1p0 + x^0x1p1 * (0x1.5555555556583p-3 + x^0x1p1
     //                  * (0x1.111110d239f1fp-7
     //                  + x^0x1p1 * 0x1.a02b5a284013cp-13)))
     // Therefore, output of Sollya = x * pe;
     double pe = fputil::polyeval(x2, 0.0, 0x1.5555555556583p-3,
                                  0x1.111110d239f1fp-7, 0x1.a02b5a284013cp-13);
-    return fputil::multiply_add(xdbl, pe, xdbl);
+    return static_cast<float>(fputil::multiply_add(xdbl, pe, xdbl));
   }
 
   // sinh(x) = (e^x - e^(-x)) / 2.
-  return exp_pm_eval</*is_sinh*/ true>(x);
+  return static_cast<float>(exp_pm_eval</*is_sinh*/ true>(x));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/tanf.cpp

#endif // LIBC_TARGET_CPU_HAS_FMA
     // |x| < pi/32
     double xsq = xd * xd;
 
     // Degree-9 minimax odd polynomial of tan(x) generated by Sollya with:
     // > P = fpminimax(tan(x)/x, [|0, 2, 4, 6, 8|], [|1, D...|], [0, pi/32]);
     double result =
         fputil::polyeval(xsq, 1.0, 0x1.555555553d022p-2, 0x1.111111ce442c1p-3,
                          0x1.ba180a6bbdecdp-5, 0x1.69c0a88a0b71fp-6);
-    return xd * result;
+    return static_cast<float>(xd * result);
   }
 
   // Check for exceptional values
   if (LIBC_UNLIKELY(x_abs == 0x3f8a1f62U)) {
     // |x| = 0x1.143ec4p0
     float sign = x_sign ? -1.0f : 1.0f;
 
     // volatile is used to prevent compiler (gcc) from optimizing the
#endif // LIBC_TARGET_CPU_HAS_FMA
 
   double xd = static_cast<double>(x);
   double sin_k, cos_k, sin_y, cosm1_y;
 
   sincosf_eval(xd, x_abs, sin_k, cos_k, sin_y, cosm1_y);
   // tan(x) = sin(x) / cos(x)
   //        = (sin_y * cos_k + cos_y * sin_k) / (cos_y * cos_k - sin_y * sin_k)
   using fputil::multiply_add;
-  return multiply_add(sin_y, cos_k, multiply_add(cosm1_y, sin_k, sin_k)) /
-         multiply_add(sin_y, -sin_k, multiply_add(cosm1_y, cos_k, cos_k));
+  return static_cast<float>(
+      multiply_add(sin_y, cos_k, multiply_add(cosm1_y, sin_k, sin_k)) /
+      multiply_add(sin_y, -sin_k, multiply_add(cosm1_y, cos_k, cos_k)));
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/tanhf.cpp

 LLVM_LIBC_FUNCTION(float, tanhf, (float x)) {
   using FPBits = typename fputil::FPBits<float>;
   FPBits xbits(x);
   bool sign = xbits.get_sign();
   uint32_t x_abs = xbits.uintval() & FPBits::FloatProp::EXP_MANT_MASK;
 
   // |x| <= 2^-26
   if (LIBC_UNLIKELY(x_abs <= 0x3280'0000U)) {
-    return LIBC_UNLIKELY(x_abs == 0) ? x
-                                     : (x - 0x1.5555555555555p-2 * x * x * x);
+    return static_cast<float>(
+        LIBC_UNLIKELY(x_abs == 0) ? x : (x - 0x1.5555555555555p-2 * x * x * x));
   }
 
   // When |x| >= 15, or x is inf or nan
   if (LIBC_UNLIKELY(x_abs >= 0x4170'0000U)) {
     if (xbits.is_nan())
       return x + 1.0f; // sNaN to qNaN + signal
 
     if (xbits.is_inf())
       return sign ? -1.0f : 1.0f;
 
     if (sign) {
       return -1.0f + opt_barrier(FPBits(FPBits::MIN_NORMAL).get_val());
     } else
       return 1.0f - opt_barrier(FPBits(FPBits::MIN_NORMAL).get_val());
   }
 
   // |x| <= 0.078125
   if (LIBC_UNLIKELY(x_abs <= 0x3da0'0000U)) {
     double xdbl = x;
     double x2 = xdbl * xdbl;
     // Pure Taylor series.
     double pe = fputil::polyeval(x2, 0.0, -0x1.5555555555555p-2,
                                  0x1.1111111111111p-3, -0x1.ba1ba1ba1ba1cp-5,
                                  0x1.664f4882c10fap-6, -0x1.226e355e6c23dp-7);
-    return fputil::multiply_add(xdbl, pe, xdbl);
+    return static_cast<float>(fputil::multiply_add(xdbl, pe, xdbl));
   }
 
   if (LIBC_UNLIKELY(xbits.bits == 0x4058'e0a3U)) {
     if (fputil::get_round() == FE_DOWNWARD)
       return FPBits(0x3f7f'6ad9U).get_val();
   }
 
   // Range reduction: e^(2x) = 2^(mid + hi) * e^lo
   auto ep = exp_b_range_reduc<ExpBase>(2.0f * x); // exp(2 * x)
   double r = ExpBase::powb_lo(ep.lo);
   // tanh(x) = (exp(2x) - 1) / (exp(2x) + 1)
 #if defined(LIBC_TARGET_CPU_HAS_FMA)
   return fputil::multiply_add(ep.mh, r, -1.0) /
          fputil::multiply_add(ep.mh, r, 1.0);
 #else
   double exp_x = ep.mh * r;
-  return (exp_x - 1.0) / (exp_x + 1.0);
+  return static_cast<float>((exp_x - 1.0) / (exp_x + 1.0));
 #endif // LIBC_TARGET_CPU_HAS_FMA
 }
 
 } // namespace __llvm_libc