Commit d97928bf52a217f75c359ae9b1513bd9d42c82d3 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-10-22 17:50:36-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-10-22 17:50:36-07:00
log	d97928bf52a217f75c359ae9b1513bd9d42c82d3
tree	1f88eea918dfbb1615fa3716088ebf99cc586cb3
parent	01c1f415209f5085e09430cc6df182d7eb2245ee

stage2: implement aligned variables and `@alignCast`

 * Sema: implement zirAllocExtended
 * Sema: implement zirAlignCast

3 files changed, 172 insertions(+), 103 deletions(-)

src
- Sema.zig
test
- behavior
  - align.zig
  - align_stage1.zig

src/Sema.zig+93-21

 @@ -1940,7 +1940,7 @@ fn zirRetPtr(
     try sema.requireFunctionBlock(block, src);
     if (block.is_comptime) {
-        return sema.analyzeComptimeAlloc(block, sema.fn_ret_ty);
+        return sema.analyzeComptimeAlloc(block, sema.fn_ret_ty, 0);
     }
     const ptr_type = try Type.ptr(sema.arena, .{
 @@ -2067,9 +2067,7 @@ fn zirAllocExtended(
         const type_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
         extra_index += 1;
         break :blk try sema.resolveType(block, ty_src, type_ref);
-    } else {
+    } else undefined;
-        return sema.fail(block, src, "TODO implement Sema.zirAllocExtended inferred", .{});
-    };
     const alignment: u16 = if (small.has_align) blk: {
         const align_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
 @@ -2078,22 +2076,47 @@ fn zirAllocExtended(
         break :blk alignment;
     } else 0;
+    const inferred_alloc_ty = if (small.is_const)
+        Type.initTag(.inferred_alloc_const)
+    else
+        Type.initTag(.inferred_alloc_mut);
     if (small.is_comptime) {
-        return sema.fail(block, src, "TODO implement Sema.zirAllocExtended comptime", .{});
+        if (small.has_type) {
+            return sema.analyzeComptimeAlloc(block, var_ty, alignment);
+        } else {
+            return sema.addConstant(
+                inferred_alloc_ty,
+                try Value.Tag.inferred_alloc_comptime.create(sema.arena, undefined),
+            );
+        }
     }
-    if (!small.is_const) {
+    if (small.has_type) {
-        return sema.fail(block, src, "TODO implement Sema.zirAllocExtended var", .{});
+        if (!small.is_const) {
+            try sema.validateVarType(block, ty_src, var_ty, false);
+        }
+        const ptr_type = try Type.ptr(sema.arena, .{
+            .pointee_type = var_ty,
+            .@"align" = alignment,
+            .@"addrspace" = target_util.defaultAddressSpace(sema.mod.getTarget(), .local),
+        });
+        try sema.requireRuntimeBlock(block, src);
+        try sema.resolveTypeLayout(block, src, var_ty);
+        return block.addTy(.alloc, ptr_type);
     }
-    const ptr_type = try Type.ptr(sema.arena, .{
+    // `Sema.addConstant` does not add the instruction to the block because it is
-        .pointee_type = var_ty,
+    // not needed in the case of constant values. However here, we plan to "downgrade"
-        .@"align" = alignment,
+    // to a normal instruction when we hit `resolve_inferred_alloc`. So we append
-        .@"addrspace" = target_util.defaultAddressSpace(sema.mod.getTarget(), .local),
+    // to the block even though it is currently a `.constant`.
-    });
+    const result = try sema.addConstant(
-    try sema.requireRuntimeBlock(block, src);
+        inferred_alloc_ty,
-    try sema.resolveTypeLayout(block, src, var_ty);
+        try Value.Tag.inferred_alloc.create(sema.arena, .{}),
-    return block.addTy(.alloc, ptr_type);
+    );
+    try sema.requireFunctionBlock(block, src);
+    try block.instructions.append(sema.gpa, Air.refToIndex(result).?);
+    return result;
 }
 fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -2103,7 +2126,7 @@ fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node };
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    return sema.analyzeComptimeAlloc(block, var_ty);
+    return sema.analyzeComptimeAlloc(block, var_ty, 0);
 }
 fn zirAllocInferredComptime(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -2125,7 +2148,7 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     const var_decl_src = inst_data.src();
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
     if (block.is_comptime) {
-        return sema.analyzeComptimeAlloc(block, var_ty);
+        return sema.analyzeComptimeAlloc(block, var_ty, 0);
     }
     const ptr_type = try Type.ptr(sema.arena, .{
         .pointee_type = var_ty,
 @@ -2145,7 +2168,7 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node };
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
     if (block.is_comptime) {
-        return sema.analyzeComptimeAlloc(block, var_ty);
+        return sema.analyzeComptimeAlloc(block, var_ty, 0);
     }
     try sema.validateVarType(block, ty_src, var_ty, false);
     const ptr_type = try Type.ptr(sema.arena, .{
 @@ -9436,8 +9459,10 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
+    const resolved_ty = try sema.resolveTypeFields(block, operand_src, ty);
+    try sema.resolveTypeLayout(block, operand_src, resolved_ty);
     const target = sema.mod.getTarget();
-    const abi_align = ty.abiAlignment(target);
+    const abi_align = resolved_ty.abiAlignment(target);
     return sema.addIntUnsigned(Type.comptime_int, abi_align);
 }
 @@ -9735,8 +9760,33 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirAlignCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
-    const src = inst_data.src();
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    return sema.fail(block, src, "TODO: Sema.zirAlignCast", .{});
+    const align_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
+    const ptr_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
+    const dest_align = try sema.resolveAlign(block, align_src, extra.lhs);
+    const ptr = sema.resolveInst(extra.rhs);
+    const ptr_ty = sema.typeOf(ptr);
+    // TODO in addition to pointers, this instruction is supposed to work for
+    // pointer-like optionals and slices.
+    try sema.checkPtrType(block, ptr_src, ptr_ty);
+    // TODO compile error if the result pointer is comptime known and would have an
+    // alignment that disagrees with the Decl's alignment.
+    // TODO insert safety check that the alignment is correct
+    const ptr_info = ptr_ty.ptrInfo().data;
+    const dest_ty = try Type.ptr(sema.arena, .{
+        .pointee_type = ptr_info.pointee_type,
+        .@"align" = dest_align,
+        .@"addrspace" = ptr_info.@"addrspace",
+        .mutable = ptr_info.mutable,
+        .@"allowzero" = ptr_info.@"allowzero",
+        .@"volatile" = ptr_info.@"volatile",
+        .size = ptr_info.size,
+    });
+    return sema.coerceCompatiblePtrs(block, dest_ty, ptr, ptr_src);
 }
 fn zirClz(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -9838,6 +9888,18 @@ fn checkIntType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileEr
     }
 }
+fn checkPtrType(
+    sema: *Sema,
+    block: *Block,
+    ty_src: LazySrcLoc,
+    ty: Type,
+) CompileError!void {
+    switch (ty.zigTypeTag()) {
+        .Pointer => {},
+        else => return sema.fail(block, ty_src, "expected pointer type, found '{}'", .{ty}),
+    }
+}
 fn checkFloatType(
     sema: *Sema,
     block: *Block,
 @@ -14630,14 +14692,22 @@ fn analyzeComptimeAlloc(
     sema: *Sema,
     block: *Block,
     var_type: Type,
+    alignment: u32,
 ) CompileError!Air.Inst.Ref {
     const ptr_type = try Type.ptr(sema.arena, .{
         .pointee_type = var_type,
         .@"addrspace" = target_util.defaultAddressSpace(sema.mod.getTarget(), .global_constant),
+        .@"align" = alignment,
     });
     var anon_decl = try block.startAnonDecl();
     defer anon_decl.deinit();
+    const align_val = if (alignment == 0)
+        Value.@"null"
+    else
+        try Value.Tag.int_u64.create(anon_decl.arena(), alignment);
     const decl = try anon_decl.finish(
         try var_type.copy(anon_decl.arena()),
         // There will be stores before the first load, but they may be to sub-elements or
 @@ -14645,6 +14715,8 @@ fn analyzeComptimeAlloc(
         // into fields/elements and have those overridden with stored values.
         Value.undef,
     );
+    decl.align_val = align_val;
     try sema.mod.declareDeclDependency(sema.owner_decl, decl);
     return sema.addConstant(ptr_type, try Value.Tag.decl_ref_mut.create(sema.arena, .{
         .runtime_index = block.runtime_index,

test/behavior/align.zig+79

...	@@ -41,3 +41,82 @@ test "implicitly decreasing slice alignment" {	...	@@ -41,3 +41,82 @@ test "implicitly decreasing slice alignment" {
41	fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {	41	fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
42	return a[0] + b[0];	42	return a[0] + b[0];
43	}	43	}
		44
		45	test "@alignCast pointers" {
		46	var x: u32 align(4) = 1;
		47	expectsOnly1(&x);
		48	try expect(x == 2);
		49	}
		50	fn expectsOnly1(x: *align(1) u32) void {
		51	expects4(@alignCast(4, x));
		52	}
		53	fn expects4(x: *align(4) u32) void {
		54	x.* += 1;
		55	}
		56
		57	test "specifying alignment allows pointer cast" {
		58	try testBytesAlign(0x33);
		59	}
		60	fn testBytesAlign(b: u8) !void {
		61	var bytes align(4) = [_]u8{ b, b, b, b };
		62	const ptr = @ptrCast(*u32, &bytes[0]);
		63	try expect(ptr.* == 0x33333333);
		64	}
		65
		66	test "@alignCast slices" {
		67	var array align(4) = [_]u32{ 1, 1 };
		68	const slice = array[0..];
		69	sliceExpectsOnly1(slice);
		70	try expect(slice[0] == 2);
		71	}
		72	fn sliceExpectsOnly1(slice: []align(1) u32) void {
		73	sliceExpects4(@alignCast(4, slice));
		74	}
		75	fn sliceExpects4(slice: []align(4) u32) void {
		76	slice[0] += 1;
		77	}
		78
		79	test "alignment of structs" {
		80	try expect(@alignOf(struct {
		81	a: i32,
		82	b: *i32,
		83	}) == @alignOf(usize));
		84	}
		85
		86	test "return error union with 128-bit integer" {
		87	try expect(3 == try give());
		88	}
		89	fn give() anyerror!u128 {
		90	return 3;
		91	}
		92
		93	test "alignment of >= 128-bit integer type" {
		94	try expect(@alignOf(u128) == 16);
		95	try expect(@alignOf(u129) == 16);
		96	}
		97
		98	test "alignment of struct with 128-bit field" {
		99	try expect(@alignOf(struct {
		100	x: u128,
		101	}) == 16);
		102
		103	comptime {
		104	try expect(@alignOf(struct {
		105	x: u128,
		106	}) == 16);
		107	}
		108	}
		109
		110	test "size of extern struct with 128-bit field" {
		111	try expect(@sizeOf(extern struct {
		112	x: u128,
		113	y: u8,
		114	}) == 32);
		115
		116	comptime {
		117	try expect(@sizeOf(extern struct {
		118	x: u128,
		119	y: u8,
		120	}) == 32);
		121	}
		122	}

test/behavior/align_stage1.zig-82

...	@@ -39,43 +39,6 @@ test "bit field alignment" {	...	@@ -39,43 +39,6 @@ test "bit field alignment" {
39	try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3);	39	try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3);
40	}	40	}
41		41
42	test "specifying alignment allows pointer cast" {
43	try testBytesAlign(0x33);
44	}
45	fn testBytesAlign(b: u8) !void {
46	var bytes align(4) = [_]u8{ b, b, b, b };
47	const ptr = @ptrCast(*u32, &bytes[0]);
48	try expect(ptr.* == 0x33333333);
49	}
50
51	test "@alignCast pointers" {
52	var x: u32 align(4) = 1;
53	expectsOnly1(&x);
54	try expect(x == 2);
55	}
56	fn expectsOnly1(x: *align(1) u32) void {
57	expects4(@alignCast(4, x));
58	}
59	fn expects4(x: *align(4) u32) void {
60	x.* += 1;
61	}
62
63	test "@alignCast slices" {
64	var array align(4) = [_]u32{
65	1,
66	1,
67	};
68	const slice = array[0..];
69	sliceExpectsOnly1(slice);
70	try expect(slice[0] == 2);
71	}
72	fn sliceExpectsOnly1(slice: []align(1) u32) void {
73	sliceExpects4(@alignCast(4, slice));
74	}
75	fn sliceExpects4(slice: []align(4) u32) void {
76	slice[0] += 1;
77	}
78
79	test "implicitly decreasing fn alignment" {	42	test "implicitly decreasing fn alignment" {
80	// function alignment is a compile error on wasm32/wasm64	43	// function alignment is a compile error on wasm32/wasm64
81	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;	44	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	@@ -180,13 +143,6 @@ fn fnWithAlignedStack() i32 {	...	@@ -180,13 +143,6 @@ fn fnWithAlignedStack() i32 {
180	return 1234;	143	return 1234;
181	}	144	}
182		145
183	test "alignment of structs" {
184	try expect(@alignOf(struct {
185	a: i32,
186	b: *i32,
187	}) == @alignOf(usize));
188	}
189
190	test "alignment of function with c calling convention" {	146	test "alignment of function with c calling convention" {
191	var runtime_nothing = nothing;	147	var runtime_nothing = nothing;
192	const casted1 = @ptrCast(*const u8, runtime_nothing);	148	const casted1 = @ptrCast(*const u8, runtime_nothing);
...	@@ -196,44 +152,6 @@ test "alignment of function with c calling convention" {	...	@@ -196,44 +152,6 @@ test "alignment of function with c calling convention" {
196		152
197	fn nothing() callconv(.C) void {}	153	fn nothing() callconv(.C) void {}
198		154
199	test "return error union with 128-bit integer" {
200	try expect(3 == try give());
201	}
202	fn give() anyerror!u128 {
203	return 3;
204	}
205
206	test "alignment of >= 128-bit integer type" {
207	try expect(@alignOf(u128) == 16);
208	try expect(@alignOf(u129) == 16);
209	}
210
211	test "alignment of struct with 128-bit field" {
212	try expect(@alignOf(struct {
213	x: u128,
214	}) == 16);
215
216	comptime {
217	try expect(@alignOf(struct {
218	x: u128,
219	}) == 16);
220	}
221	}
222
223	test "size of extern struct with 128-bit field" {
224	try expect(@sizeOf(extern struct {
225	x: u128,
226	y: u8,
227	}) == 32);
228
229	comptime {
230	try expect(@sizeOf(extern struct {
231	x: u128,
232	y: u8,
233	}) == 32);
234	}
235	}
236
237	const DefaultAligned = struct {	155	const DefaultAligned = struct {
238	nevermind: u32,	156	nevermind: u32,
239	badguy: i128,	157	badguy: i128,