authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-05-09 22:23:44-04:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-05-10 15:16:50-04:00
logc5b96c7447efde0d10de9689f03d151afcafbad5
tree5defce62f9cca4ee233197487c786ac197a7fb75
parent2d2d79a05b8423c7638348dc5a89793c1e0cafce

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

Closes #15611

6 files changed, 55 insertions(+), 23 deletions(-)

lib/std/math.zig+1
......@@ -37,6 +37,7 @@ pub const sqrt2 = 1.414213562373095048801688724209698079;
3737/// 1/sqrt(2)
3838pub const sqrt1_2 = 0.707106781186547524400844362104849039;
3939
40pub const floatBits = @import("math/float.zig").floatBits;
4041pub const floatExponentBits = @import("math/float.zig").floatExponentBits;
4142pub const floatMantissaBits = @import("math/float.zig").floatMantissaBits;
4243pub const floatFractionalBits = @import("math/float.zig").floatFractionalBits;
lib/std/math/copysign.zig+8-7
......@@ -4,16 +4,17 @@ const expect = std.testing.expect;
44
55/// Returns a value with the magnitude of `magnitude` and the sign of `sign`.
66pub fn copysign(magnitude: anytype, sign: @TypeOf(magnitude)) @TypeOf(magnitude) {
7 const T = @TypeOf(magnitude);
8 const TBits = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
9 const sign_bit_mask = @as(TBits, 1) << (@bitSizeOf(T) - 1);
10 const mag = @bitCast(TBits, magnitude) & ~sign_bit_mask;
11 const sgn = @bitCast(TBits, sign) & sign_bit_mask;
12 return @bitCast(T, mag | sgn);
7 const bits = math.floatBits(@TypeOf(magnitude));
8 const FBits = @Type(.{ .Float = .{ .bits = bits } });
9 const TBits = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = bits } });
10 const sign_bit_mask = @as(TBits, 1) << (bits - 1);
11 const mag = @bitCast(TBits, @as(FBits, magnitude)) & ~sign_bit_mask;
12 const sgn = @bitCast(TBits, @as(FBits, sign)) & sign_bit_mask;
13 return @bitCast(FBits, mag | sgn);
1314}
1415
1516test "math.copysign" {
16 inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| {
17 inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble, comptime_float }) |T| {
1718 try expect(copysign(@as(T, 1.0), @as(T, 1.0)) == 1.0);
1819 try expect(copysign(@as(T, 2.0), @as(T, -2.0)) == -2.0);
1920 try expect(copysign(@as(T, -3.0), @as(T, 3.0)) == 3.0);
lib/std/math/float.zig+17-12
......@@ -4,21 +4,29 @@ const expect = std.testing.expect;
44
55/// Creates a raw "1.0" mantissa for floating point type T. Used to dedupe f80 logic.
66inline fn mantissaOne(comptime T: type) comptime_int {
7 return if (@typeInfo(T).Float.bits == 80) 1 << floatFractionalBits(T) else 0;
7 return 1 << floatFractionalBits(T) & ((1 << floatMantissaBits(T)) - 1);
88}
99
1010/// Creates floating point type T from an unbiased exponent and raw mantissa.
1111inline fn reconstructFloat(comptime T: type, comptime exponent: comptime_int, comptime mantissa: comptime_int) T {
12 const TBits = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = @bitSizeOf(T) } });
12 const FBits = @Type(.{ .Float = .{ .bits = floatBits(T) } });
13 const TBits = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = floatBits(T) } });
1314 const biased_exponent = @as(TBits, exponent + floatExponentMax(T));
14 return @bitCast(T, (biased_exponent << floatMantissaBits(T)) | @as(TBits, mantissa));
15 return @bitCast(FBits, (biased_exponent << floatMantissaBits(T)) | @as(TBits, mantissa));
16}
17
18/// Returns the number of bits in floating point type T.
19pub inline fn floatBits(comptime T: type) comptime_int {
20 return switch (@typeInfo(T)) {
21 .Float => |info| info.bits,
22 .ComptimeFloat => 128,
23 else => @compileError(@typeName(T) ++ " is not a floating point type"),
24 };
1525}
1626
1727/// Returns the number of bits in the exponent of floating point type T.
1828pub inline fn floatExponentBits(comptime T: type) comptime_int {
19 comptime assert(@typeInfo(T) == .Float);
20
21 return switch (@typeInfo(T).Float.bits) {
29 return switch (floatBits(T)) {
2230 16 => 5,
2331 32 => 8,
2432 64 => 11,
......@@ -30,9 +38,7 @@ pub inline fn floatExponentBits(comptime T: type) comptime_int {
3038
3139/// Returns the number of bits in the mantissa of floating point type T.
3240pub inline fn floatMantissaBits(comptime T: type) comptime_int {
33 comptime assert(@typeInfo(T) == .Float);
34
35 return switch (@typeInfo(T).Float.bits) {
41 return switch (floatBits(T)) {
3642 16 => 10,
3743 32 => 23,
3844 64 => 52,
......@@ -44,12 +50,10 @@ pub inline fn floatMantissaBits(comptime T: type) comptime_int {
4450
4551/// Returns the number of fractional bits in the mantissa of floating point type T.
4652pub inline fn floatFractionalBits(comptime T: type) comptime_int {
47 comptime assert(@typeInfo(T) == .Float);
48
4953 // standard IEEE floats have an implicit 0.m or 1.m integer part
5054 // f80 is special and has an explicitly stored bit in the MSB
5155 // this function corresponds to `MANT_DIG - 1' from C
52 return switch (@typeInfo(T).Float.bits) {
56 return switch (floatBits(T)) {
5357 16 => 10,
5458 32 => 23,
5559 64 => 52,
......@@ -101,6 +105,7 @@ test "float bits" {
101105 inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {
102106 // (1 +) for the sign bit, since it is separate from the other bits
103107 const size = 1 + floatExponentBits(T) + floatMantissaBits(T);
108 try expect(floatBits(T) == size);
104109 try expect(@bitSizeOf(T) == size);
105110
106111 // for machine epsilon, assert expmin <= -prec <= expmax
lib/std/math/nan.zig+2-2
......@@ -2,13 +2,13 @@ const math = @import("../math.zig");
22
33/// Returns the nan representation for type T.
44pub inline fn nan(comptime T: type) T {
5 return switch (@typeInfo(T).Float.bits) {
5 return switch (math.floatBits(T)) {
66 16 => math.nan_f16,
77 32 => math.nan_f32,
88 64 => math.nan_f64,
99 80 => math.nan_f80,
1010 128 => math.nan_f128,
11 else => @compileError("unreachable"),
11 else => @compileError("unknown floating point type " ++ @typeName(T)),
1212 };
1313}
1414
src/codegen/llvm.zig+2-2
......@@ -7034,7 +7034,7 @@ pub const FuncGen = struct {
70347034 const rhs = try self.resolveInst(bin_op.rhs);
70357035 const scalar_ty = self.air.typeOfIndex(inst).scalarType();
70367036
7037 if (scalar_ty.isAnyFloat()) return self.builder.buildMinNum(lhs, rhs, "");
7037 if (scalar_ty.isAnyFloat()) return self.buildFloatOp(.fmin, scalar_ty, 2, .{ lhs, rhs });
70387038 if (scalar_ty.isSignedInt()) return self.builder.buildSMin(lhs, rhs, "");
70397039 return self.builder.buildUMin(lhs, rhs, "");
70407040 }
......@@ -7045,7 +7045,7 @@ pub const FuncGen = struct {
70457045 const rhs = try self.resolveInst(bin_op.rhs);
70467046 const scalar_ty = self.air.typeOfIndex(inst).scalarType();
70477047
7048 if (scalar_ty.isAnyFloat()) return self.builder.buildMaxNum(lhs, rhs, "");
7048 if (scalar_ty.isAnyFloat()) return self.buildFloatOp(.fmax, scalar_ty, 2, .{ lhs, rhs });
70497049 if (scalar_ty.isSignedInt()) return self.builder.buildSMax(lhs, rhs, "");
70507050 return self.builder.buildUMax(lhs, rhs, "");
70517051 }
test/behavior/maximum_minimum.zig+25
......@@ -96,6 +96,31 @@ test "@min for vectors" {
9696 comptime try S.doTheTest();
9797}
9898
99test "@min/max for floats" {
100 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
101 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
102 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
103 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
104 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
105
106 const S = struct {
107 fn doTheTest(comptime T: type) !void {
108 var x: T = -3.14;
109 var y: T = 5.27;
110 try expectEqual(x, @min(x, y));
111 try expectEqual(x, @min(y, x));
112 try expectEqual(y, @max(x, y));
113 try expectEqual(y, @max(y, x));
114 }
115 };
116
117 inline for (.{ f16, f32, f64, f80, f128, c_longdouble }) |T| {
118 try S.doTheTest(T);
119 comptime try S.doTheTest(T);
120 }
121 comptime try S.doTheTest(comptime_float);
122}
123
99124test "@min/@max on lazy values" {
100125 const A = extern struct { u8_4: [4]u8 };
101126 const B = extern struct { u8_16: [16]u8 };