llvm: fix `@max`/`@min` of unsupported float types

Closes #15611

3 files changed, 27 insertions, 21 deletions

diff --git a/lib/std/math/copysign.zig b/lib/std/math/copysign.zig
index b5fd6d4d9a..1f2da915c0 100644
--- a/lib/std/math/copysign.zig
+++ b/lib/std/math/copysign.zig
@@ -4,16 +4,17 @@ const expect = std.testing.expect;
 
 /// Returns a value with the magnitude of `magnitude` and the sign of `sign`.
 pub fn copysign(magnitude: anytype, sign: @TypeOf(magnitude)) @TypeOf(magnitude) {
-    const T = @TypeOf(magnitude);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
-    const sign_bit_mask = @as(TBits, 1) << (@bitSizeOf(T) - 1);
-    const mag = @bitCast(TBits, magnitude) & ~sign_bit_mask;
-    const sgn = @bitCast(TBits, sign) & sign_bit_mask;
-    return @bitCast(T, mag | sgn);
+    const bits = math.floatBits(@TypeOf(magnitude));
+    const FBits = @Type(.{ .Float = .{ .bits = bits } });
+    const TBits = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = bits } });
+    const sign_bit_mask = @as(TBits, 1) << (bits - 1);
+    const mag = @bitCast(TBits, @as(FBits, magnitude)) & ~sign_bit_mask;
+    const sgn = @bitCast(TBits, @as(FBits, sign)) & sign_bit_mask;
+    return @bitCast(FBits, mag | sgn);
 }
 
 test "math.copysign" {
-    inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
+    inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble, comptime_float }) |T| {
         try expect(copysign(@as(T, 1.0), @as(T, 1.0)) == 1.0);
         try expect(copysign(@as(T, 2.0), @as(T, -2.0)) == -2.0);
         try expect(copysign(@as(T, -3.0), @as(T, 3.0)) == 3.0);
diff --git a/lib/std/math/float.zig b/lib/std/math/float.zig
index 768cc03285..134277b91d 100644
--- a/lib/std/math/float.zig
+++ b/lib/std/math/float.zig
@@ -4,21 +4,29 @@ const expect = std.testing.expect;
 
 /// Creates a raw "1.0" mantissa for floating point type T. Used to dedupe f80 logic.
 inline fn mantissaOne(comptime T: type) comptime_int {
-    return if (@typeInfo(T).Float.bits == 80) 1 << floatFractionalBits(T) else 0;
+    return 1 << floatFractionalBits(T) & ((1 << floatMantissaBits(T)) - 1);
 }
 
 /// Creates floating point type T from an unbiased exponent and raw mantissa.
 inline fn reconstructFloat(comptime T: type, comptime exponent: comptime_int, comptime mantissa: comptime_int) T {
-    const TBits = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = @bitSizeOf(T) } });
+    const FBits = @Type(.{ .Float = .{ .bits = floatBits(T) } });
+    const TBits = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = floatBits(T) } });
     const biased_exponent = @as(TBits, exponent + floatExponentMax(T));
-    return @bitCast(T, (biased_exponent << floatMantissaBits(T)) | @as(TBits, mantissa));
+    return @bitCast(FBits, (biased_exponent << floatMantissaBits(T)) | @as(TBits, mantissa));
+}
+
+/// Returns the number of bits in floating point type T.
+pub inline fn floatBits(comptime T: type) comptime_int {
+    return switch (@typeInfo(T)) {
+        .Float => |info| info.bits,
+        .ComptimeFloat => 128,
+        else => @compileError(@typeName(T) ++ " is not a floating point type"),
+    };
 }
 
 /// Returns the number of bits in the exponent of floating point type T.
 pub inline fn floatExponentBits(comptime T: type) comptime_int {
-    comptime assert(@typeInfo(T) == .Float);
-
-    return switch (@typeInfo(T).Float.bits) {
+    return switch (floatBits(T)) {
         16 => 5,
         32 => 8,
         64 => 11,
@@ -30,9 +38,7 @@ pub inline fn floatExponentBits(comptime T: type) comptime_int {
 
 /// Returns the number of bits in the mantissa of floating point type T.
 pub inline fn floatMantissaBits(comptime T: type) comptime_int {
-    comptime assert(@typeInfo(T) == .Float);
-
-    return switch (@typeInfo(T).Float.bits) {
+    return switch (floatBits(T)) {
         16 => 10,
         32 => 23,
         64 => 52,
@@ -44,12 +50,10 @@ pub inline fn floatMantissaBits(comptime T: type) comptime_int {
 
 /// Returns the number of fractional bits in the mantissa of floating point type T.
 pub inline fn floatFractionalBits(comptime T: type) comptime_int {
-    comptime assert(@typeInfo(T) == .Float);
-
     // standard IEEE floats have an implicit 0.m or 1.m integer part
     // f80 is special and has an explicitly stored bit in the MSB
     // this function corresponds to `MANT_DIG - 1' from C
-    return switch (@typeInfo(T).Float.bits) {
+    return switch (floatBits(T)) {
         16 => 10,
         32 => 23,
         64 => 52,
@@ -101,6 +105,7 @@ test "float bits" {
     inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {
         // (1 +) for the sign bit, since it is separate from the other bits
         const size = 1 + floatExponentBits(T) + floatMantissaBits(T);
+        try expect(floatBits(T) == size);
         try expect(@bitSizeOf(T) == size);
 
         // for machine epsilon, assert expmin <= -prec <= expmax
diff --git a/lib/std/math/nan.zig b/lib/std/math/nan.zig
index 8a27937242..3f3fd4a139 100644
--- a/lib/std/math/nan.zig
+++ b/lib/std/math/nan.zig
@@ -2,13 +2,13 @@ const math = @import("../math.zig");
 
 /// Returns the nan representation for type T.
 pub inline fn nan(comptime T: type) T {
-    return switch (@typeInfo(T).Float.bits) {
+    return switch (math.floatBits(T)) {
         16 => math.nan_f16,
         32 => math.nan_f32,
         64 => math.nan_f64,
         80 => math.nan_f80,
         128 => math.nan_f128,
-        else => @compileError("unreachable"),
+        else => @compileError("unknown floating point type " ++ @typeName(T)),
     };
 }