Potential floating point optimizations

lib/fizzy/execute.cpp

@@ -332,6 +332,19 @@ inline constexpr T popcnt(T value) noexcept
     return static_cast<T>(popcount(value));
 }
 
+template <typename T>
+T signbit(T value) noexcept = delete;
+
+inline bool signbit(float value) noexcept
+{
+    return (bit_cast<uint32_t>(value) & F32SignMask) != 0;
+}
+
+inline bool signbit(double value) noexcept
+{
+    return (bit_cast<uint64_t>(value) & F64SignMask) != 0;
+}
+
 template <typename T>
 T fabs(T value) noexcept = delete;
 
@@ -362,6 +375,25 @@ inline double fneg(double value) noexcept
     return bit_cast<double>(bit_cast<uint64_t>(value) ^ F64SignMask);
 }
 
+template <typename T>
+T copysign(T a, T b) noexcept = delete;
+
+template <>
+inline float copysign(float a, float b) noexcept
+{
+    const auto a_u = bit_cast<uint32_t>(a);
+    const auto b_u = bit_cast<uint32_t>(b);
+    return bit_cast<float>((a_u & F32AbsMask) | (b_u & F32SignMask));
+}
+
+template <>
+inline double copysign(double a, double b) noexcept
+{
+    const auto a_u = bit_cast<uint64_t>(a);
+    const auto b_u = bit_cast<uint64_t>(b);
+    return bit_cast<double>((a_u & F64AbsMask) | (b_u & F64SignMask));
+}
+
 template <typename T>
 inline T fceil(T value) noexcept
 {
@@ -389,7 +421,7 @@ inline T ffloor(T value) noexcept
     // the __builtin_floor() outputs -0 where it should +0.
     // The following workarounds the issue by using the fact that the sign of
     // the output must always match the sign of the input value.
-    return std::copysign(result, value);
+    return copysign(result, value);
 }
 
 template <typename T>
@@ -419,8 +451,8 @@ T fnearest(T value) noexcept
 
     // This implementation is based on adjusting the result produced by trunc() by +-1 when needed.
     const auto t = std::trunc(value);
-    if (const auto diff = std::abs(value - t); diff > T{0.5} || (diff == T{0.5} && !is_even(t)))
-        return t + std::copysign(T{1}, value);
+    if (const auto diff = fabs(value - t); diff > T{0.5} || (diff == T{0.5} && !is_even(t)))
+        return t + copysign(T{1}, value);
     else
         return t;
 }
@@ -441,7 +473,7 @@ inline T fmin(T a, T b) noexcept
     if (std::isnan(a) || std::isnan(b))
         return std::numeric_limits<T>::quiet_NaN();  // Positive canonical NaN.
 
-    if (a == 0 && b == 0 && (std::signbit(a) == 1 || std::signbit(b) == 1))
+    if (a == 0 && b == 0 && (signbit(a) || signbit(b)))
         return -T{0};
 
     return b < a ? b : a;
@@ -455,30 +487,12 @@ inline T fmax(T a, T b) noexcept
     if (std::isnan(a) || std::isnan(b))
         return std::numeric_limits<T>::quiet_NaN();  // Positive canonical NaN.
 
-    if (a == 0 && b == 0 && (std::signbit(a) == 0 || std::signbit(b) == 0))
+    if (a == 0 && b == 0 && (!signbit(a) || !signbit(b)))
         return T{0};
 
     return a < b ? b : a;
 }
 
-template <typename T>
-T fcopysign(T a, T b) noexcept = delete;
-
-template <>
-inline float fcopysign(float a, float b) noexcept
-{
-    const auto a_u = bit_cast<uint32_t>(a);
-    const auto b_u = bit_cast<uint32_t>(b);
-    return bit_cast<float>((a_u & F32AbsMask) | (b_u & F32SignMask));
-}
-
-template <>
-inline double fcopysign(double a, double b) noexcept
-{
-    const auto a_u = bit_cast<uint64_t>(a);
-    const auto b_u = bit_cast<uint64_t>(b);
-    return bit_cast<double>((a_u & F64AbsMask) | (b_u & F64SignMask));
-}
 
 __attribute__((no_sanitize("float-cast-overflow"))) inline constexpr float demote(
     double value) noexcept
@@ -1347,7 +1361,7 @@ ExecutionResult execute(
         }
         case Instr::f32_copysign:
         {
-            binary_op(stack, fcopysign<float>);
+            binary_op(stack, copysign<float>);
             break;
         }
 
@@ -1419,7 +1433,7 @@ ExecutionResult execute(
         }
         case Instr::f64_copysign:
         {
-            binary_op(stack, fcopysign<double>);
+            binary_op(stack, copysign<double>);
             break;
         }