Commit f1b91bb41b2d810ecabf4c69cad91b24b3846b77 | zig

author	Jimmi Holst Christensen <jhc@dismail.de> 2022-01-20 22:46:15+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-01-23 17:23:55-05:00
log	f1b91bb41b2d810ecabf4c69cad91b24b3846b77
tree	59416bc00443451485832f6d1a1ce4b3d3357c58
parent	7287c7482a2c694c7c7f56b9f7c1744a7ae7905f

c backend: Implement aligning fields and local/global variables

There are some restrictions here.

- We either need C11 or a compiler that supports the aligned attribute
- We cannot provide align less than the type's natural C alignment.

6 files changed, 63 insertions(+), 25 deletions(-)

src
- codegen
  - c.zig
- link
  - C
    zig.h
test
- behavior.zig
- behavior

src/codegen/c.zig+34-5

 @@ -121,7 +121,13 @@ pub const Function = struct {
                 const decl_c_value = f.allocLocalValue();
                 gop.value_ptr.* = decl_c_value;
                 try writer.writeAll("static ");
-                try f.object.dg.renderTypeAndName(writer, ty, decl_c_value, .Const);
+                try f.object.dg.renderTypeAndName(
+                    writer,
+                    ty,
+                    decl_c_value,
+                    .Const,
+                    Value.initTag(.abi_align_default),
+                );
                 try writer.writeAll(" = ");
                 try f.object.dg.renderValue(writer, ty, val);
                 try writer.writeAll(";\n ");
 @@ -142,8 +148,18 @@ pub const Function = struct {
     }
     fn allocLocal(f: *Function, ty: Type, mutability: Mutability) !CValue {
+        return f.allocAlignedLocal(ty, mutability, Value.initTag(.abi_align_default));
+    }
+    fn allocAlignedLocal(f: *Function, ty: Type, mutability: Mutability, alignment: Value) !CValue {
         const local_value = f.allocLocalValue();
-        try f.object.dg.renderTypeAndName(f.object.writer(), ty, local_value, mutability);
+        try f.object.dg.renderTypeAndName(
+            f.object.writer(),
+            ty,
+            local_value,
+            mutability,
+            alignment,
+        );
         return local_value;
     }
 @@ -711,9 +727,11 @@ pub const DeclGen = struct {
             while (it.next()) |entry| {
                 const field_ty = entry.value_ptr.ty;
                 if (!field_ty.hasCodeGenBits()) continue;
+                const alignment = entry.value_ptr.abi_align;
                 const name: CValue = .{ .bytes = entry.key_ptr.* };
                 try buffer.append(' ');
-                try dg.renderTypeAndName(buffer.writer(), field_ty, name, .Mut);
+                try dg.renderTypeAndName(buffer.writer(), field_ty, name, .Mut, alignment);
                 try buffer.appendSlice(";\n");
             }
         }
 @@ -950,6 +968,7 @@ pub const DeclGen = struct {
         ty: Type,
         name: CValue,
         mutability: Mutability,
+        alignment: Value,
     ) error{ OutOfMemory, AnalysisFail }!void {
         var suffix = std.ArrayList(u8).init(dg.gpa);
         defer suffix.deinit();
 @@ -962,6 +981,8 @@ pub const DeclGen = struct {
             render_ty = render_ty.elemType();
         }
+        if (alignment.tag() != .abi_align_default and alignment.tag() != .null_value)
+            try w.print("ZIG_ALIGN({}) ", .{alignment.toUnsignedInt()});
         try dg.renderType(w, render_ty);
         const const_prefix = switch (mutability) {
 @@ -1118,7 +1139,7 @@ pub fn genDecl(o: *Object) !void {
         // https://github.com/ziglang/zig/issues/7582
         const decl_c_value: CValue = .{ .decl = o.dg.decl };
-        try o.dg.renderTypeAndName(writer, tv.ty, decl_c_value, .Mut);
+        try o.dg.renderTypeAndName(writer, tv.ty, decl_c_value, .Mut, o.dg.decl.align_val);
         try writer.writeAll(" = ");
         try o.dg.renderValue(writer, tv.ty, tv.val);
 @@ -1460,8 +1481,16 @@ fn airAlloc(f: *Function, inst: Air.Inst.Index) !CValue {
         return CValue{ .bytes = literal };
     }
+    const target = f.object.dg.module.getTarget();
+    const alignment = inst_ty.ptrAlignment(target);
+    var payload = Value.Payload.U64{
+        .base = .{ .tag = .int_u64 },
+        .data = alignment,
+    };
+    const alignment_value = Value.initPayload(&payload.base);
     // First line: the variable used as data storage.
-    const local = try f.allocLocal(elem_type, mutability);
+    const local = try f.allocAlignedLocal(elem_type, mutability, alignment_value);
     try writer.writeAll(";\n");
     // Arrays are already pointers so they don't need to be referenced.

src/link/C/zig.h+9

...	@@ -26,6 +26,15 @@	...	@@ -26,6 +26,15 @@
26	#define ZIG_RESTRICT	26	#define ZIG_RESTRICT
27	#endif	27	#endif
28		28
		29	#if __STDC_VERSION__ >= 201112L
		30	#include <stdalign.h>
		31	#define ZIG_ALIGN(alignment) alignas(alignment)
		32	#elif defined(__GNUC__)
		33	#define ZIG_ALIGN(alignment) __attribute__((aligned(alignment)))
		34	#else
		35	#define ZIG_ALIGN(alignment) zig_compile_error("the C compiler being used does not support aligning variables")
		36	#endif
		37
29	#if __STDC_VERSION__ >= 199901L	38	#if __STDC_VERSION__ >= 199901L
30	#include <stdbool.h>	39	#include <stdbool.h>
31	#else	40	#else

test/behavior.zig-1

...	@@ -71,7 +71,6 @@ test {	...	@@ -71,7 +71,6 @@ test {
71		71
72	if (builtin.zig_backend != .stage2_c) {	72	if (builtin.zig_backend != .stage2_c) {
73	// Tests that pass for stage1 and the llvm backend.	73	// Tests that pass for stage1 and the llvm backend.
74	_ = @import("behavior/align_llvm.zig");
75	_ = @import("behavior/alignof.zig");	74	_ = @import("behavior/alignof.zig");
76	_ = @import("behavior/array_llvm.zig");	75	_ = @import("behavior/array_llvm.zig");
77	_ = @import("behavior/atomics.zig");	76	_ = @import("behavior/atomics.zig");

test/behavior/align.zig+18

...	@@ -163,3 +163,21 @@ test "return error union with 128-bit integer" {	...	@@ -163,3 +163,21 @@ test "return error union with 128-bit integer" {
163	fn give() anyerror!u128 {	163	fn give() anyerror!u128 {
164	return 3;	164	return 3;
165	}	165	}
		166
		167	test "page aligned array on stack" {
		168	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm or
		169	builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		170
		171	// Large alignment value to make it hard to accidentally pass.
		172	var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
		173	var number1: u8 align(16) = 42;
		174	var number2: u8 align(16) = 43;
		175
		176	try expect(@ptrToInt(&array[0]) & 0xFFF == 0);
		177	try expect(array[3] == 4);
		178
		179	try expect(@truncate(u4, @ptrToInt(&number1)) == 0);
		180	try expect(@truncate(u4, @ptrToInt(&number2)) == 0);
		181	try expect(number1 == 42);
		182	try expect(number2 == 43);
		183	}

test/behavior/align_llvm.zig deleted-19

...	@@ -1,19 +0,0 @@
1	const std = @import("std");
2	const expect = std.testing.expect;
3	const builtin = @import("builtin");
4	const native_arch = builtin.target.cpu.arch;
5
6	test "page aligned array on stack" {
7	// Large alignment value to make it hard to accidentally pass.
8	var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
9	var number1: u8 align(16) = 42;
10	var number2: u8 align(16) = 43;
11
12	try expect(@ptrToInt(&array[0]) & 0xFFF == 0);
13	try expect(array[3] == 4);
14
15	try expect(@truncate(u4, @ptrToInt(&number1)) == 0);
16	try expect(@truncate(u4, @ptrToInt(&number2)) == 0);
17	try expect(number1 == 42);
18	try expect(number2 == 43);
19	}

test/behavior/struct.zig+2

...	@@ -201,6 +201,8 @@ test "struct field init with catch" {	...	@@ -201,6 +201,8 @@ test "struct field init with catch" {
201	}	201	}
202		202
203	test "packed struct field alignment" {	203	test "packed struct field alignment" {
		204	if (builtin.object_format == .c) return error.SkipZigTest;
		205
204	const Stage1 = struct {	206	const Stage1 = struct {
205	var baz: packed struct {	207	var baz: packed struct {
206	a: u32,	208	a: u32,