Commit 73f4c680054a1a4e067f0719676f61f175d81a13 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-10-17 09:06:56+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2024-10-19 19:46:07+01:00
log	73f4c680054a1a4e067f0719676f61f175d81a13
tree	cc67d4aac2546d4459cad172e0b6eff15d394e14
parent	387965a696e567357ca4729b41951e51592ef821
signature	Commit is signed but in an unrecognized format.

x86_64: handle incoming stack alignment

3 files changed, 17 insertions(+), 27 deletions(-)

src
- Zcu.zig
- arch
  - x86_64
    CodeGen.zig
- target.zig

src/Zcu.zig+1-2

...	@@ -3607,8 +3607,7 @@ pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enu	...	@@ -3607,8 +3607,7 @@ pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enu
3607	else => false,	3607	else => false,
3608	},	3608	},
3609	.stage2_x86_64 => switch (cc) {	3609	.stage2_x86_64 => switch (cc) {
3610	.x86_64_sysv, .x86_64_win => \|opts\| opts.incoming_stack_alignment == null,	3610	.x86_64_sysv, .x86_64_win, .naked => true, // incoming stack alignment supported
3611	.naked => true,
3612	else => false,	3611	else => false,
3613	},	3612	},
3614	.stage2_aarch64 => switch (cc) {	3613	.stage2_aarch64 => switch (cc) {

src/arch/x86_64/CodeGen.zig+16-9

 @@ -19326,12 +19326,12 @@ fn resolveCallingConventionValues(
             result.return_value = InstTracking.init(.unreach);
             result.stack_align = .@"8";
         },
-        .x86_64_sysv, .x86_64_win => {
+        .x86_64_sysv, .x86_64_win => |cc_opts| {
             var ret_int_reg_i: u32 = 0;
             var ret_sse_reg_i: u32 = 0;
             var param_int_reg_i: u32 = 0;
             var param_sse_reg_i: u32 = 0;
-            result.stack_align = .@"16";
+            result.stack_align = .fromByteUnits(cc_opts.incoming_stack_alignment orelse 16);
             switch (resolved_cc) {
                 .x86_64_sysv => {},
 @@ -19512,10 +19512,13 @@ fn resolveCallingConventionValues(
                 }
                 const param_size: u31 = @intCast(ty.abiSize(zcu));
-                const param_align: u31 =
+                const param_align = ty.abiAlignment(zcu).max(.@"8");
-                    @intCast(@max(ty.abiAlignment(zcu).toByteUnits().?, 8));
+                result.stack_byte_count = mem.alignForward(
-                result.stack_byte_count =
+                    u31,
-                    mem.alignForward(u31, result.stack_byte_count, param_align);
+                    result.stack_byte_count,
+                    @intCast(param_align.toByteUnits().?),
+                );
+                result.stack_align = result.stack_align.max(param_align);
                 arg.* = .{ .load_frame = .{
                     .index = stack_frame_base,
                     .off = result.stack_byte_count,
 @@ -19557,9 +19560,13 @@ fn resolveCallingConventionValues(
                     continue;
                 }
                 const param_size: u31 = @intCast(ty.abiSize(zcu));
-                const param_align: u31 = @intCast(ty.abiAlignment(zcu).toByteUnits().?);
+                const param_align = ty.abiAlignment(zcu);
-                result.stack_byte_count =
+                result.stack_byte_count = mem.alignForward(
-                    mem.alignForward(u31, result.stack_byte_count, param_align);
+                    u31,
+                    result.stack_byte_count,
+                    @intCast(param_align.toByteUnits().?),
+                );
+                result.stack_align = result.stack_align.max(param_align);
                 arg.* = .{ .load_frame = .{
                     .index = stack_frame_base,
                     .off = result.stack_byte_count,

src/target.zig-16

...	@@ -607,19 +607,3 @@ pub inline fn backendSupportsFeature(backend: std.builtin.CompilerBackend, compt	...	@@ -607,19 +607,3 @@ pub inline fn backendSupportsFeature(backend: std.builtin.CompilerBackend, compt
607	},	607	},
608	};	608	};
609	}	609	}
610
611	pub fn stackAlignment(target: std.Target, cc: std.builtin.CallingConvention) u64 {
612	switch (cc) {
613	inline else => \|payload\| switch (@TypeOf(payload)) {
614	std.builtin.CallingConvention.CommonOptions,
615	std.builtin.CallingConvention.X86RegparmOptions,
616	std.builtin.CallingConvention.ArmInterruptOptions,
617	std.builtin.CallingConvention.MipsInterruptOptions,
618	std.builtin.CallingConvention.RiscvInterruptOptions,
619	=> if (payload.incoming_stack_alignment) \|a\| return a,
620	void => {},
621	else => comptime unreachable,
622	},
623	}
624	return target.stackAlignment();
625	}