Commit cff70a4050a4ca0ef5ef6be5ee72b425e56ad2d4 | zig

author	Jacob Young <jacobly@ziglang.org> 2026-10-20 19:38:22-04:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-10-21 20:10:42+02:00
log	cff70a4050a4ca0ef5ef6be5ee72b425e56ad2d4
tree	2be048fa682c91062bae18663453c91313081ca0
parent	ff08725400468a106c29a6281f718a94fc57fac5
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

llvm: implement bitcast without the help of a legalize feature

Closes #37188

2 files changed, 57 insertions(+), 22 deletions(-)

src
- codegen
  - llvm
    FuncGen.zig
test
- behavior
  - bitcast.zig

src/codegen/llvm/FuncGen.zig+24-22

 @@ -4670,38 +4670,38 @@ fn airBitCast(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error!
     // We have the following `Air.Legalize` features enabled:
     //
     // * `.scalarize_bit_cast_array`
-    // * `.scalarize_bit_cast_vector_non_elementwise`
+    // * `.scalarize_bit_cast_vector_non_elementwise` (big-endian only)
     //
-    // That means the `bit_cast` instructions we might see are limited to the following:
+    // That means that on big-endian, the `bit_cast` instructions we might see are limited to the following:
     //
     // * bool/int/float <-> bool/int/float
     // * `@Vector(n, A)` <-> `@Vector(n, B)`
     //
-    // Most of these cases can be handled by LLVM's `bitcast` instruction, except when
+    // While on little-endian, the `bit_cast` instructions we might see can be any of the following:
-    // a non-native type like `f80` is used.
+    //
+    // * bool/int/float/`@Vector(n, A)` <-> bool/int/float/`@Vector(m, B)`
     if (isByRef(operand_ty, zcu)) {
         const operand_scalar_ty = operand_ty.scalarType(zcu);
         const target = zcu.getTarget();
-        const bits = operand_scalar_ty.floatBits(target);
+        const scalar_bits = operand_scalar_ty.floatBits(target);
-        const dest_scalar_ty = dest_ty.scalarType(zcu);
         if (isByRef(dest_ty, zcu)) {
-            assert(dest_scalar_ty.floatBits(target) == bits);
+            const dest_scalar_ty = dest_ty.scalarType(zcu);
-            return operand;
+            // Converting between equivalent floats with the same repr.
+            if (dest_scalar_ty.floatBits(target) == scalar_bits) return operand;
         }
-        assert(dest_scalar_ty.intInfo(zcu).bits == bits);
         const len = if (operand_ty.toIntern() != operand_scalar_ty.toIntern())
             operand_ty.vectorLen(zcu)
         else
             null;
         const operand_scalar_size = operand_scalar_ty.abiSize(zcu);
-        var result = if (len) |_|
+        var result = if (len) |l|
-            try o.builder.poisonValue(try o.lowerType(dest_ty, .as_value))
+            try o.builder.poisonValue(try o.builder.vectorType(.normal, l, try o.intType(scalar_bits, .as_value)))
         else
             undefined;
         for (0..len orelse 1) |index| {
-            const result_elem = result_elem: switch (bits) {
+            const result_elem = result_elem: switch (scalar_bits) {
                 else => unreachable,
                 80 => {
                     const f80_layout = o.softF80Layout(.{}) catch unreachable;
 @@ -4747,28 +4747,30 @@ fn airBitCast(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error!
             else
                 result_elem;
         }
-        return result;
+        return fg.wip.cast(.bitcast, result, try o.lowerType(dest_ty, .as_value), "");
     }
     if (isByRef(dest_ty, zcu)) {
         const dest_scalar_ty = dest_ty.scalarType(zcu);
-        const bits = dest_scalar_ty.floatBits(zcu.getTarget());
+        const scalar_bits = dest_scalar_ty.floatBits(zcu.getTarget());
-        assert(dest_scalar_ty.isRuntimeFloat());
-        const operand_scalar_ty = operand_ty.scalarType(zcu);
-        assert(operand_scalar_ty.intInfo(zcu).bits == bits);
-        const len = if (operand_ty.toIntern() != operand_scalar_ty.toIntern())
+        const len = if (dest_ty.toIntern() != dest_scalar_ty.toIntern())
             operand_ty.vectorLen(zcu)
         else
             null;
-        const operand_scalar_size = operand_scalar_ty.abiSize(zcu);
+        const operand_scalar_int_ty = try o.intType(scalar_bits, .as_value);
+        const bitcasted_operand = try fg.wip.cast(.bitcast, operand, if (len) |l|
+            try o.builder.vectorType(.normal, l, operand_scalar_int_ty)
+        else
+            operand_scalar_int_ty, "");
+        const operand_scalar_size = operand_ty.scalarType(zcu).abiSize(zcu);
         const result_ptr = try fg.buildZigAlloca(dest_ty, .none);
         for (0..len orelse 1) |index| {
             const operand_elem = if (len) |_|
-                try fg.wip.extractElement(operand, try o.builder.intValue(.i32, index), "elementwise.operand_elem")
+                try fg.wip.extractElement(bitcasted_operand, try o.builder.intValue(.i32, index), "elementwise.operand_elem")
             else
-                operand;
+                bitcasted_operand;
-            switch (bits) {
+            switch (scalar_bits) {
                 else => unreachable,
                 80 => {
                     const f80_layout = o.softF80Layout(.{}) catch unreachable;

test/behavior/bitcast.zig+33

...	@@ -631,3 +631,36 @@ test "@bitCast deeply nested arrays to scalar" {	...	@@ -631,3 +631,36 @@ test "@bitCast deeply nested arrays to scalar" {
631	try static.doTheTest(src);	631	try static.doTheTest(src);
632	try comptime static.doTheTest(src);	632	try comptime static.doTheTest(src);
633	}	633	}
		634
		635	test "@bitCast between float and vector" {
		636	const static = struct {
		637	fn doTheTest() !void {
		638	{
		639	var v: @Vector(5, u16) = undefined;
		640	v = .{ 0xf5c3, 0x5c28, 0xc28f, 0xc8f5, 0x4000 };
		641	const f: f80 = @bitCast(v);
		642	try expect(f == 3.14);
		643	}
		644	{
		645	var f: f80 = undefined;
		646	f = 3.14;
		647	const v: @Vector(5, u16) = @bitCast(f);
		648	try expect(std.mem.eql(u16, &@as([5]u16, v), &.{ 0xf5c3, 0x5c28, 0xc28f, 0xc8f5, 0x4000 }));
		649	}
		650	{
		651	var v: @Vector(4, u32) = undefined;
		652	v = .{ 0x51eb851f, 0xeb851eb8, 0x851eb851, 0x400191eb };
		653	const f: f128 = @bitCast(v);
		654	try expect(f == 6.28);
		655	}
		656	{
		657	var f: f128 = undefined;
		658	f = 6.28;
		659	const v: @Vector(4, u32) = @bitCast(f);
		660	try expect(std.mem.eql(u32, &@as([4]u32, v), &.{ 0x51eb851f, 0xeb851eb8, 0x851eb851, 0x400191eb }));
		661	}
		662	}
		663	};
		664	try static.doTheTest();
		665	try comptime static.doTheTest();
		666	}