Commit 069a009fbc6e34cc5a14cea037a2129cf4642434 | zig

src/Air.zig+2-2

...	@@ -780,8 +780,8 @@ pub const Inst = struct {	...	@@ -780,8 +780,8 @@ pub const Inst = struct {
780	reduce,	780	reduce,
781	/// Same as `reduce` with optimized float mode.	781	/// Same as `reduce` with optimized float mode.
782	reduce_optimized,	782	reduce_optimized,
783	/// Given an integer, bool, float, or pointer operand, return a vector with all elements	783	/// Given an operand, return a vector or array with all elements equal to the operand.
784	/// equal to the scalar value.	784	/// For a sentinel-terminated array, the sentinel is derived from the result type.
785	/// Uses the `ty_op` field.	785	/// Uses the `ty_op` field.
786	splat,	786	splat,
787	/// Constructs a vector by selecting elements from a single vector based on a mask. Each	787	/// Constructs a vector by selecting elements from a single vector based on a mask. Each

src/Air/Legalize.zig+22-8

 @@ -200,6 +200,8 @@ pub const Feature = enum {
     expand_packed_agg_field_val,
     /// Replace `aggregate_init` of a packed struct with a sequence of `shl_exact`, `bit_cast`, `int_cast`, and `bit_or`.
     expand_packed_aggregate_init,
+    /// Replace `splat` of an array with an `aggregate_init`.
+    expand_array_splat,
     /// Replace `array_to_vector` with an `array_elem_val` per element followed by an `aggregate_init`.
     expand_array_to_vector,
 @@ -891,15 +893,27 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void {
                     .soft_float => unreachable, // the operand is not a scalar
                 }
             },
-            .splat => if (l.features.has(.splat_one_elem_to_bit_cast)) {
+            .splat => {
                 const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op;
-                switch (ty_op.ty.vectorLen(zcu)) {
+                switch (ty_op.ty.zigTypeTag(zcu)) {
-                    0 => unreachable,
+                    .vector => switch (ty_op.ty.vectorLen(zcu)) {
-                    1 => continue :inst l.replaceInst(inst, .bit_cast, .{ .ty_op = .{
+                        0 => unreachable,
-                        .ty = ty_op.ty,
+                        1 => continue :inst l.replaceInst(inst, .bit_cast, .{ .ty_op = .{
-                        .operand = ty_op.operand,
+                            .ty = ty_op.ty,
-                    } }),
+                            .operand = ty_op.operand,
-                    else => {},
+                        } }),
+                        else => {},
+                    },
+                    .array => if (l.features.has(.expand_array_splat)) {
+                        const len: usize = @intCast(ty_op.ty.arrayLen(zcu));
+                        const elems_start: u32 = @intCast(l.air_extra.items.len);
+                        try l.air_extra.appendNTimes(l.pt.zcu.gpa, @backingInt(ty_op.operand), len);
+                        continue :inst l.replaceInst(inst, .aggregate_init, .{ .ty_pl = .{
+                            .ty = ty_op.ty,
+                            .payload = elems_start,
+                        } });
+                    },
+                    else => unreachable,
                 }
             },
             .shuffle_one => {

src/Sema.zig+1-7

 @@ -23271,13 +23271,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     try sema.requireRuntimeBlock(block, src, scalar_src);
     switch (dest_ty.zigTypeTag(zcu)) {
-        .array => {
+        .vector, .array => return block.addTyOp(.splat, dest_ty, scalar),
-            const elems = try sema.arena.alloc(Air.Inst.Ref, len + @intFromBool(maybe_sentinel != null));
-            @memset(elems[0..len], scalar);
-            if (maybe_sentinel) |s| elems[len] = Air.internedToRef(s.toIntern());
-            return block.addAggregateInit(dest_ty, elems);
-        },
-        .vector => return block.addTyOp(.splat, dest_ty, scalar),
         else => unreachable,
     }
 }

src/codegen/aarch64.zig+1

...	@@ -8,6 +8,7 @@ pub const Select = @import("aarch64/Select.zig");	...	@@ -8,6 +8,7 @@ pub const Select = @import("aarch64/Select.zig");
8	pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {	8	pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {
9	return comptime &.initMany(&.{	9	return comptime &.initMany(&.{
10	.expand_bit_cast_safe,	10	.expand_bit_cast_safe,
		11	.expand_array_splat,
11	.expand_array_to_vector,	12	.expand_array_to_vector,
12	});	13	});
13	}	14	}

src/codegen/c.zig+1

...	@@ -39,6 +39,7 @@ pub fn legalizeFeatures(_: const std.Target) ?const Air.Legalize.Features {	...	@@ -39,6 +39,7 @@ pub fn legalizeFeatures(_: const std.Target) ?const Air.Legalize.Features {
39	.expand_packed_store = true,	39	.expand_packed_store = true,
40	.expand_packed_agg_field_val = true,	40	.expand_packed_agg_field_val = true,
41	.expand_packed_aggregate_init = true,	41	.expand_packed_aggregate_init = true,
		42	.expand_array_splat = true,
42	.expand_array_to_vector = true,	43	.expand_array_to_vector = true,
43		44
44	.scalarize_bit_cast_array = true,	45	.scalarize_bit_cast_array = true,

src/codegen/llvm/FuncGen.zig+77-25

 @@ -5590,8 +5590,36 @@ fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error
         .slice => null,
         .many, .c => unreachable,
     });
+    const len_bytes = try self.sliceOrArrayLenInBytes(dest_slice, ptr_ty);
-    if (allow_byte_memset) if (bin_op.rhs.toInterned()) |elem_ip_index| {
+    try self.lowerMemset(
+        dest_ptr,
+        dest_ptr_align,
+        bin_op.rhs,
+        elem_ty,
+        len_bytes,
+        access_kind,
+        safety,
+        allow_byte_memset,
+    );
+    return .none;
+}
+fn lowerMemset(
+    self: *FuncGen,
+    dest_ptr: Builder.Value,
+    dest_ptr_align: InternPool.Alignment,
+    elem_ref: Air.Inst.Ref,
+    elem_ty: Type,
+    len_bytes: Builder.Value,
+    access_kind: Builder.MemoryAccessKind,
+    safety: bool,
+    allow_byte_memset: bool,
+) Allocator.Error!void {
+    const o = self.object;
+    const zcu = o.zcu;
+    if (allow_byte_memset) if (elem_ref.toInterned()) |elem_ip_index| {
         const elem_val: Value = .fromInterned(elem_ip_index);
         if (elem_val.isUndef(zcu)) {
             // Even if safety is disabled, we still emit a memset to undefined since it conveys
 @@ -5601,20 +5629,19 @@ fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error
                 try o.builder.intValue(.i8, 0xaa)
             else
                 try o.builder.undefValue(.i8);
-            const len = try self.sliceOrArrayLenInBytes(dest_slice, ptr_ty);
             _ = try self.wip.callMemSet(
                 dest_ptr,
                 dest_ptr_align.toLlvm(),
                 fill_byte,
-                len,
+                len_bytes,
                 access_kind,
                 self.disable_intrinsics,
             );
             const owner_mod = self.ownerModule();
             if (safety and owner_mod.valgrind) {
-                try self.valgrindMarkUndef(dest_ptr, len);
+                try self.valgrindMarkUndef(dest_ptr, len_bytes);
             }
-            return .none;
+            return;
         }
         // Test if the element value is compile-time known to be a
 @@ -5623,20 +5650,19 @@ fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error
         // intrinsic can be used.
         if (try elem_val.hasRepeatedByteRepr(zcu)) |byte_val| {
             const fill_byte = try o.builder.intValue(.i8, byte_val);
-            const len = try self.sliceOrArrayLenInBytes(dest_slice, ptr_ty);
             _ = try self.wip.callMemSet(
                 dest_ptr,
                 dest_ptr_align.toLlvm(),
                 fill_byte,
-                len,
+                len_bytes,
                 access_kind,
                 self.disable_intrinsics,
             );
-            return .none;
+            return;
         }
     };
-    const value = try self.resolveInst(bin_op.rhs);
+    const value = try self.resolveInst(elem_ref);
     const elem_abi_size = elem_ty.abiSize(zcu);
     intrinsic: {
 @@ -5660,16 +5686,15 @@ fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error
             break :intrinsic;
         };
         // Great, we can use the intrinsic!
-        const len = try self.sliceOrArrayLenInBytes(dest_slice, ptr_ty);
         _ = try self.wip.callMemSet(
             dest_ptr,
             dest_ptr_align.toLlvm(),
             fill_byte,
-            len,
+            len_bytes,
             access_kind,
             self.disable_intrinsics,
         );
-        return .none;
+        return;
     }
     // non-byte-sized element. lower with a loop. something like this:
 @@ -5693,15 +5718,7 @@ fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error
     const body_block = try self.wip.block(1, "InlineMemsetBody");
     const end_block = try self.wip.block(1, "InlineMemsetEnd");
-    const end_ptr = switch (ptr_ty.ptrSize(zcu)) {
+    const end_ptr = try self.ptraddScaled(dest_ptr, len_bytes, 1);
-        .slice => try self.ptraddScaled(
-            dest_ptr,
-            try self.wip.extractValue(dest_slice, &.{1}, ""),
-            elem_abi_size,
-        ),
-        .one => try self.ptraddConst(dest_ptr, ptr_ty.childType(zcu).abiSize(zcu)),
-        .many, .c => unreachable,
-    };
     _ = try self.wip.br(loop_block);
     self.wip.cursor = .{ .block = loop_block };
 @@ -5718,7 +5735,7 @@ fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error
     self.wip.cursor = .{ .block = end_block };
     it_ptr.finish(&.{ next_ptr, dest_ptr }, &.{ body_block, entry_block }, &self.wip);
-    return .none;
+    return;
 }
 fn airMemcpy(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value {
 @@ -5980,10 +5997,45 @@ fn airErrorName(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Va
 }
 fn airSplat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value {
+    const o = self.object;
+    const zcu = o.zcu;
     const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op;
-    const scalar = try self.resolveInst(ty_op.operand);
+    const result_ty = self.typeOfIndex(inst);
-    const vector_ty = self.typeOfIndex(inst);
+    switch (result_ty.zigTypeTag(zcu)) {
-    return self.wip.splatVector(try self.object.lowerType(vector_ty, .as_value), scalar, "");
+        .vector => {
+            const scalar = try self.resolveInst(ty_op.operand);
+            return self.wip.splatVector(try o.lowerType(result_ty, .as_value), scalar, "");
+        },
+        .array => {
+            assert(isByRef(result_ty, zcu));
+            const result_ptr = try self.buildZigAlloca(result_ty, .none);
+            const array_info = result_ty.arrayInfo(zcu);
+            const elem_size = array_info.elem_type.abiSize(zcu);
+            const len_bytes = array_info.len * elem_size;
+            const len_bytes_llvm = try o.builder.intValue(try o.lowerType(.usize, .as_value), len_bytes);
+            try self.lowerMemset(
+                result_ptr,
+                result_ty.abiAlignment(zcu),
+                ty_op.operand,
+                array_info.elem_type,
+                len_bytes_llvm,
+                .normal,
+                false,
+                !self.needMemsetWorkaround(len_bytes),
+            );
+            if (array_info.sentinel) |sent_val| {
+                const sent_ptr = try self.ptraddConst(result_ptr, len_bytes);
+                const sent_elem = try self.resolveValue(sent_val);
+                try self.store(sent_ptr, .none, sent_elem.toValue(), array_info.elem_type, .normal);
+            }
+            return result_ptr;
+        },
+        else => unreachable,
+    }
 }
 fn airSelect(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value {

src/codegen/riscv64/CodeGen.zig+1

...	@@ -59,6 +59,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {	...	@@ -59,6 +59,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {
59	.expand_sub_safe,	59	.expand_sub_safe,
60	.expand_mul_safe,	60	.expand_mul_safe,
61		61
		62	.expand_array_splat,
62	.expand_array_to_vector,	63	.expand_array_to_vector,
63	});	64	});
64	}	65	}

src/codegen/sparc64/CodeGen.zig+1

...	@@ -42,6 +42,7 @@ const InnerError = codegen.Error \|\| error{OutOfRegisters};	...	@@ -42,6 +42,7 @@ const InnerError = codegen.Error \|\| error{OutOfRegisters};
42		42
43	pub fn legalizeFeatures(_: const std.Target) ?const Air.Legalize.Features {	43	pub fn legalizeFeatures(_: const std.Target) ?const Air.Legalize.Features {
44	return comptime &.initMany(&.{	44	return comptime &.initMany(&.{
		45	.expand_array_splat,
45	.expand_array_to_vector,	46	.expand_array_to_vector,
46	});	47	});
47	}	48	}

src/codegen/spirv/CodeGen.zig+1

...	@@ -129,6 +129,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {	...	@@ -129,6 +129,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {
129	.expand_sub_safe,	129	.expand_sub_safe,
130	.expand_mul_safe,	130	.expand_mul_safe,
131		131
		132	.expand_array_splat,
132	.expand_array_to_vector,	133	.expand_array_to_vector,
133	});	134	});
134	}	135	}

src/codegen/wasm/CodeGen.zig+1

...	@@ -38,6 +38,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {	...	@@ -38,6 +38,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {
38	.expand_packed_store,	38	.expand_packed_store,
39	.expand_packed_agg_field_val,	39	.expand_packed_agg_field_val,
40	.expand_packed_aggregate_init,	40	.expand_packed_aggregate_init,
		41	.expand_array_splat,
41	.expand_array_to_vector,	42	.expand_array_to_vector,
42		43
43	.scalarize_add,	44	.scalarize_add,

src/codegen/x86_64/CodeGen.zig+1

...	@@ -78,6 +78,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {	...	@@ -78,6 +78,7 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {
78	.expand_packed_store,	78	.expand_packed_store,
79	.expand_packed_agg_field_val,	79	.expand_packed_agg_field_val,
80	.expand_packed_aggregate_init,	80	.expand_packed_aggregate_init,
		81	.expand_array_splat,
81	.expand_array_to_vector,	82	.expand_array_to_vector,
82	});	83	});
83	}	84	}

test/behavior/memset.zig+22

...	@@ -30,6 +30,28 @@ fn testMemsetArray() !void {	...	@@ -30,6 +30,28 @@ fn testMemsetArray() !void {
30	}	30	}
31	}	31	}
32		32
		33	test "@memset preserves array sentinel" {
		34	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		36	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
		37
		38	try testMemsetArraySentinel();
		39	try comptime testMemsetArraySentinel();
		40	}
		41
		42	fn testMemsetArraySentinel() !void {
		43	var value: u32 = 42;
		44	_ = &value;
		45	var array: [3:0]u32 = .{ 1, 2, 3 };
		46
		47	@memset(&array, value);
		48
		49	try expect(array[0] == value);
		50	try expect(array[1] == value);
		51	try expect(array[2] == value);
		52	try expect(array[3] == 0);
		53	}
		54
33	test "@memset on slices" {	55	test "@memset on slices" {
34	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	56	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;

author	Pavel Verigo <paul.verigo@gmail.com> 2026-08-16 04:25:58+02:00
committer	Pavel Verigo <paul.verigo@gmail.com> 2026-08-23 03:57:02+02:00
log	069a009fbc6e34cc5a14cea037a2129cf4642434
tree	581889431796bef24de22e1c12ce8c6a6fa472b1
parent	3c46da14db296beec186c3df4fe3669f6c99b715

sema: dont use aggregate_init for runtime splat on arrays, reuse AIR .splat