authorgravatar for paul.verigo@gmail.comPavel Verigo <paul.verigo@gmail.com> 2026-04-07 01:05:53+02:00
committergravatar for paul.verigo@gmail.comPavel Verigo <paul.verigo@gmail.com> 2026-04-09 00:14:09+02:00
logfff887874e917e2955002c323fb0286cedfbfd84
treef8ecc364dda29f2f6c2fd793f8ec7e989194ab36
parentdf79ea941bc3c355dfcb51c1de3d2d4fd186dd46

stage2-wasm: @intFromFloat and @floatFromInt

3 files changed, 116 insertions(+), 6 deletions(-)

src/codegen/wasm/CodeGen.zig+48-6
...@@ -4413,7 +4413,34 @@ fn intFromFloat(cg: *CodeGen, dest_ty: IntType, src_ty: FloatType, operand: WVal...@@ -4413,7 +4413,34 @@ fn intFromFloat(cg: *CodeGen, dest_ty: IntType, src_ty: FloatType, operand: WVal
4413 return cg.callIntrinsic(intrinsic, &.{.f128_type}, Type.u128, &.{operand});4413 return cg.callIntrinsic(intrinsic, &.{.f128_type}, Type.u128, &.{operand});
4414 },4414 },
4415 },4415 },
4416 else => return cg.fail("TODO: Support intFromFloat for integer bitsize: {d}", .{dest_ty.bits}),4416 else => {
4417 const result = try cg.allocInt(dest_ty);
4418
4419 switch (src_ty) {
4420 .f16 => {
4421 const intrinsic: Mir.Intrinsic = if (dest_ty.is_signed) .__fixhfei else .__fixunshfei;
4422 _ = try cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type, .f16_type }, .void, &.{ result, .{ .imm32 = dest_ty.bits }, operand });
4423 },
4424 .f32 => {
4425 const intrinsic: Mir.Intrinsic = if (dest_ty.is_signed) .__fixsfei else .__fixunssfei;
4426 _ = try cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type, .f32_type }, .void, &.{ result, .{ .imm32 = dest_ty.bits }, operand });
4427 },
4428 .f64 => {
4429 const intrinsic: Mir.Intrinsic = if (dest_ty.is_signed) .__fixdfei else .__fixunsdfei;
4430 _ = try cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type, .f64_type }, .void, &.{ result, .{ .imm32 = dest_ty.bits }, operand });
4431 },
4432 .f80 => {
4433 const intrinsic: Mir.Intrinsic = if (dest_ty.is_signed) .__fixxfei else .__fixunsxfei;
4434 _ = try cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type, .f80_type }, .void, &.{ result, .{ .imm32 = dest_ty.bits }, operand });
4435 },
4436 .f128 => {
4437 const intrinsic: Mir.Intrinsic = if (dest_ty.is_signed) .__fixtfei else .__fixunstfei;
4438 _ = try cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type, .f128_type }, .void, &.{ result, .{ .imm32 = dest_ty.bits }, operand });
4439 },
4440 }
4441
4442 return result;
4443 },
4417 }4444 }
4418}4445}
44194446
...@@ -4433,7 +4460,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal...@@ -4433,7 +4460,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal
4433 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattihf else .__floatuntihf;4460 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattihf else .__floatuntihf;
4434 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f16, &.{operand});4461 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f16, &.{operand});
4435 },4462 },
4436 else => return cg.fail("TODO: Support floatFromInt for {d}-bit int to 16-bit float", .{src_ty.bits}),4463 else => {
4464 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floateihf else .__floatuneihf;
4465 return cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type }, Type.f16, &.{ operand, .{ .imm32 = src_ty.bits }});
4466 },
4437 },4467 },
4438 .f32 => switch (src_ty.bits) {4468 .f32 => switch (src_ty.bits) {
4439 0 => unreachable,4469 0 => unreachable,
...@@ -4451,7 +4481,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal...@@ -4451,7 +4481,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal
4451 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattisf else .__floatuntisf;4481 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattisf else .__floatuntisf;
4452 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f32, &.{operand});4482 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f32, &.{operand});
4453 },4483 },
4454 else => return cg.fail("TODO: Support floatFromInt for {d}-bit int to 32-bit float", .{src_ty.bits}),4484 else => {
4485 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floateisf else .__floatuneisf;
4486 return cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type }, Type.f32, &.{ operand, .{ .imm32 = src_ty.bits }});
4487 },
4455 },4488 },
4456 .f64 => switch (src_ty.bits) {4489 .f64 => switch (src_ty.bits) {
4457 0 => unreachable,4490 0 => unreachable,
...@@ -4469,7 +4502,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal...@@ -4469,7 +4502,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal
4469 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattidf else .__floatuntidf;4502 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattidf else .__floatuntidf;
4470 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f64, &.{operand});4503 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f64, &.{operand});
4471 },4504 },
4472 else => return cg.fail("TODO: Support floatFromInt for {d}-bit int to 64-bit float", .{src_ty.bits}),4505 else => {
4506 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floateidf else .__floatuneidf;
4507 return cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type }, Type.f64, &.{ operand, .{ .imm32 = src_ty.bits }});
4508 },
4473 },4509 },
4474 .f80 => switch (src_ty.bits) {4510 .f80 => switch (src_ty.bits) {
4475 0 => unreachable,4511 0 => unreachable,
...@@ -4485,7 +4521,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal...@@ -4485,7 +4521,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal
4485 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattixf else .__floatuntixf;4521 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattixf else .__floatuntixf;
4486 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f80, &.{operand});4522 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f80, &.{operand});
4487 },4523 },
4488 else => return cg.fail("TODO: Support floatFromInt for {d}-bit int to 80-bit float", .{src_ty.bits}),4524 else => {
4525 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floateixf else .__floatuneixf;
4526 return cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type }, Type.f80, &.{ operand, .{ .imm32 = src_ty.bits }});
4527 },
4489 },4528 },
4490 .f128 => switch (src_ty.bits) {4529 .f128 => switch (src_ty.bits) {
4491 0 => unreachable,4530 0 => unreachable,
...@@ -4501,7 +4540,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal...@@ -4501,7 +4540,10 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal
4501 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattitf else .__floatuntitf;4540 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floattitf else .__floatuntitf;
4502 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f128, &.{operand});4541 return cg.callIntrinsic(intrinsic, &.{.i128_type}, Type.f128, &.{operand});
4503 },4542 },
4504 else => return cg.fail("TODO: Support floatFromInt for {d}-bit int to 128-bit float", .{src_ty.bits}),4543 else => {
4544 const intrinsic: Mir.Intrinsic = if (src_ty.is_signed) .__floateitf else .__floatuneitf;
4545 return cg.callIntrinsic(intrinsic, &.{ .usize_type, .usize_type }, Type.f128, &.{ operand, .{ .imm32 = src_ty.bits }});
4546 },
4505 },4547 },
4506 }4548 }
4507}4549}
src/codegen/wasm/Mir.zig+20
...@@ -846,33 +846,43 @@ pub const Intrinsic = enum(u32) {...@@ -846,33 +846,43 @@ pub const Intrinsic = enum(u32) {
846 __fabsh,846 __fabsh,
847 __fabsx,847 __fabsx,
848 __fixdfdi,848 __fixdfdi,
849 __fixdfei,
849 __fixdfsi,850 __fixdfsi,
850 __fixdfti,851 __fixdfti,
851 __fixhfdi,852 __fixhfdi,
853 __fixhfei,
852 __fixhfsi,854 __fixhfsi,
853 __fixhfti,855 __fixhfti,
854 __fixsfdi,856 __fixsfdi,
857 __fixsfei,
855 __fixsfsi,858 __fixsfsi,
856 __fixsfti,859 __fixsfti,
857 __fixtfdi,860 __fixtfdi,
861 __fixtfei,
858 __fixtfsi,862 __fixtfsi,
859 __fixtfti,863 __fixtfti,
860 __fixunsdfdi,864 __fixunsdfdi,
865 __fixunsdfei,
861 __fixunsdfsi,866 __fixunsdfsi,
862 __fixunsdfti,867 __fixunsdfti,
863 __fixunshfdi,868 __fixunshfdi,
869 __fixunshfei,
864 __fixunshfsi,870 __fixunshfsi,
865 __fixunshfti,871 __fixunshfti,
866 __fixunssfdi,872 __fixunssfdi,
873 __fixunssfei,
867 __fixunssfsi,874 __fixunssfsi,
868 __fixunssfti,875 __fixunssfti,
869 __fixunstfdi,876 __fixunstfdi,
877 __fixunstfei,
870 __fixunstfsi,878 __fixunstfsi,
871 __fixunstfti,879 __fixunstfti,
872 __fixunsxfdi,880 __fixunsxfdi,
881 __fixunsxfei,
873 __fixunsxfsi,882 __fixunsxfsi,
874 __fixunsxfti,883 __fixunsxfti,
875 __fixxfdi,884 __fixxfdi,
885 __fixxfei,
876 __fixxfsi,886 __fixxfsi,
877 __fixxfti,887 __fixxfti,
878 __floatdidf,888 __floatdidf,
...@@ -880,6 +890,11 @@ pub const Intrinsic = enum(u32) {...@@ -880,6 +890,11 @@ pub const Intrinsic = enum(u32) {
880 __floatdisf,890 __floatdisf,
881 __floatditf,891 __floatditf,
882 __floatdixf,892 __floatdixf,
893 __floateidf,
894 __floateihf,
895 __floateisf,
896 __floateitf,
897 __floateixf,
883 __floatsidf,898 __floatsidf,
884 __floatsihf,899 __floatsihf,
885 __floatsisf,900 __floatsisf,
...@@ -895,6 +910,11 @@ pub const Intrinsic = enum(u32) {...@@ -895,6 +910,11 @@ pub const Intrinsic = enum(u32) {
895 __floatundisf,910 __floatundisf,
896 __floatunditf,911 __floatunditf,
897 __floatundixf,912 __floatundixf,
913 __floatuneidf,
914 __floatuneihf,
915 __floatuneisf,
916 __floatuneitf,
917 __floatuneixf,
898 __floatunsidf,918 __floatunsidf,
899 __floatunsihf,919 __floatunsihf,
900 __floatunsisf,920 __floatunsisf,
test/behavior/cast.zig+48
...@@ -122,6 +122,54 @@ test "@floatFromInt" {...@@ -122,6 +122,54 @@ test "@floatFromInt" {
122 try comptime S.doTheTest();122 try comptime S.doTheTest();
123}123}
124124
125fn testIntFromFloat(comptime F: type, f: F, comptime I: type, i: I) !void {
126 try expect(@as(I, @intFromFloat(f)) == i);
127}
128
129test "@intFromFloat > 128 bits" {
130 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
131 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
132
133 try testIntFromFloat(f16, 1024, u140, 1024);
134 try testIntFromFloat(f16, -1024, i140, -1024);
135
136 try testIntFromFloat(f32, 1 << 24, u140, 1 << 24);
137 try testIntFromFloat(f32, -1 << 24, i140, -1 << 24);
138
139 try testIntFromFloat(f64, 1 << 53, u200, 1 << 53);
140 try testIntFromFloat(f64, -1 << 53, i200, -1 << 53);
141
142 try testIntFromFloat(f80, 1 << 63, u200, 1 << 63);
143 try testIntFromFloat(f80, -1 << 63, i200, -1 << 63);
144
145 try testIntFromFloat(f128, 1 << 100, u200, 1 << 100);
146 try testIntFromFloat(f128, -1 << 100, i200, -1 << 100);
147}
148
149fn testFloatFromInt(comptime I: type, i: I, comptime F: type, expected: F) !void {
150 try expect(@as(F, @floatFromInt(i)) == expected);
151}
152
153test "@floatFromInt > 128 bits" {
154 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
155 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
156
157 try testFloatFromInt(u140, 1024, f16, 1024);
158 try testFloatFromInt(i140, -1024, f16, -1024);
159
160 try testFloatFromInt(u140, 1 << 24, f32, 1 << 24);
161 try testFloatFromInt(i140, -1 << 24, f32, -1 << 24);
162
163 try testFloatFromInt(u200, 1 << 53, f64, 1 << 53);
164 try testFloatFromInt(i200, -1 << 53, f64, -1 << 53);
165
166 try testFloatFromInt(u200, 1 << 63, f80, 1 << 63);
167 try testFloatFromInt(i200, -1 << 63, f80, -1 << 63);
168
169 try testFloatFromInt(u200, 1 << 100, f128, 1 << 100);
170 try testFloatFromInt(i200, -1 << 100, f128, -1 << 100);
171}
172
125test "@floatFromInt(f80)" {173test "@floatFromInt(f80)" {
126 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO174 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
127 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO175 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO