Commit 389020009a9afea3cc01e8e408aa33dbc63c156c | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-04-21 22:43:57-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-04-21 22:43:57-07:00
log	389020009a9afea3cc01e8e408aa33dbc63c156c
tree	688dc53c1a917b9bca1761dbea90886bbb0b0ea2
parent	ea00ddfe3710e386b62849fa4d275b5cbd82e28c

AstGen: implement alignment on locals

4 files changed, 139 insertions(+), 16 deletions(-)

src/AstGen.zig+61-15

 @@ -1902,9 +1902,6 @@ fn varDecl(
 ) InnerError!*Scope {
     try emitDbgNode(gz, node);
     const astgen = gz.astgen;
-    if (var_decl.ast.align_node != 0) {
-        return astgen.failNode(var_decl.ast.align_node, "TODO implement alignment on locals", .{});
-    }
     const gpa = astgen.gpa;
     const tree = &astgen.file.tree;
     const token_tags = tree.tokens.items(.tag);
 @@ -1919,12 +1916,12 @@ fn varDecl(
             .local_val => {
                 const local_val = s.cast(Scope.LocalVal).?;
                 if (mem.eql(u8, local_val.name, ident_name)) {
-                    return astgen.failTokNotes(name_token, "redefinition of '{s}'", .{
+                    return astgen.failTokNotes(name_token, "redeclaration of '{s}'", .{
                         ident_name,
                     }, &[_]u32{
                         try astgen.errNoteTok(
                             local_val.token_src,
-                            "previous definition is here",
+                            "previous declaration is here",
                             .{},
                         ),
                     });
 @@ -1934,12 +1931,12 @@ fn varDecl(
             .local_ptr => {
                 const local_ptr = s.cast(Scope.LocalPtr).?;
                 if (mem.eql(u8, local_ptr.name, ident_name)) {
-                    return astgen.failTokNotes(name_token, "redefinition of '{s}'", .{
+                    return astgen.failTokNotes(name_token, "redeclaration of '{s}'", .{
                         ident_name,
                     }, &[_]u32{
                         try astgen.errNoteTok(
                             local_ptr.token_src,
-                            "previous definition is here",
+                            "previous declaration is here",
                             .{},
                         ),
                     });
 @@ -1957,15 +1954,21 @@ fn varDecl(
         return astgen.failNode(node, "variables must be initialized", .{});
     }
+    const align_inst: Zir.Inst.Ref = if (var_decl.ast.align_node != 0)
+        try expr(gz, scope, align_rl, var_decl.ast.align_node)
+    else
+        .none;
     switch (token_tags[var_decl.ast.mut_token]) {
         .keyword_const => {
             if (var_decl.comptime_token) |comptime_token| {
                 return astgen.failTok(comptime_token, "'comptime const' is redundant; instead wrap the initialization expression with 'comptime'", .{});
             }
             // Depending on the type of AST the initialization expression is, we may need an lvalue
             // or an rvalue as a result location. If it is an rvalue, we can use the instruction as
             // the variable, no memory location needed.
-            if (!nodeMayNeedMemoryLocation(tree, var_decl.ast.init_node)) {
+            if (align_inst == .none and !nodeMayNeedMemoryLocation(tree, var_decl.ast.init_node)) {
                 const result_loc: ResultLoc = if (var_decl.ast.type_node != 0) .{
                     .ty = try typeExpr(gz, scope, var_decl.ast.type_node),
                 } else .none;
 @@ -1997,10 +2000,29 @@ fn varDecl(
             if (var_decl.ast.type_node != 0) {
                 const type_inst = try typeExpr(gz, &init_scope.base, var_decl.ast.type_node);
                 opt_type_inst = type_inst;
-                init_scope.rl_ptr = try init_scope.addUnNode(.alloc, type_inst, node);
+                if (align_inst == .none) {
+                    init_scope.rl_ptr = try init_scope.addUnNode(.alloc, type_inst, node);
+                } else {
+                    init_scope.rl_ptr = try gz.addAllocExtended(.{
+                        .node = node,
+                        .type_inst = type_inst,
+                        .align_inst = align_inst,
+                        .is_const = true,
+                        .is_comptime = false,
+                    });
+                }
                 init_scope.rl_ty_inst = type_inst;
             } else {
-                const alloc = try init_scope.addNode(.alloc_inferred, node);
+                const alloc = if (align_inst == .none)
+                    try init_scope.addNode(.alloc_inferred, node)
+                else
+                    try gz.addAllocExtended(.{
+                        .node = node,
+                        .type_inst = .none,
+                        .align_inst = align_inst,
+                        .is_const = true,
+                        .is_comptime = false,
+                    });
                 resolve_inferred_alloc = alloc;
                 init_scope.rl_ptr = alloc;
             }
 @@ -2010,7 +2032,7 @@ fn varDecl(
             const zir_datas = astgen.instructions.items(.data);
             const parent_zir = &gz.instructions;
-            if (init_scope.rvalue_rl_count == 1) {
+            if (align_inst == .none and init_scope.rvalue_rl_count == 1) {
                 // Result location pointer not used. We don't need an alloc for this
                 // const local, and type inference becomes trivial.
                 // Move the init_scope instructions into the parent scope, eliding
 @@ -2070,12 +2092,36 @@ fn varDecl(
                 alloc: Zir.Inst.Ref,
             } = if (var_decl.ast.type_node != 0) a: {
                 const type_inst = try typeExpr(gz, scope, var_decl.ast.type_node);
-                const tag: Zir.Inst.Tag = if (is_comptime) .alloc_comptime else .alloc_mut;
+                const alloc = alloc: {
-                const alloc = try gz.addUnNode(tag, type_inst, node);
+                    if (align_inst == .none) {
+                        const tag: Zir.Inst.Tag = if (is_comptime) .alloc_comptime else .alloc_mut;
+                        break :alloc try gz.addUnNode(tag, type_inst, node);
+                    } else {
+                        break :alloc try gz.addAllocExtended(.{
+                            .node = node,
+                            .type_inst = type_inst,
+                            .align_inst = align_inst,
+                            .is_const = false,
+                            .is_comptime = is_comptime,
+                        });
+                    }
+                };
                 break :a .{ .alloc = alloc, .result_loc = .{ .ptr = alloc } };
             } else a: {
-                const tag: Zir.Inst.Tag = if (is_comptime) .alloc_inferred_comptime else .alloc_inferred_mut;
+                const alloc = alloc: {
-                const alloc = try gz.addNode(tag, node);
+                    if (align_inst == .none) {
+                        const tag: Zir.Inst.Tag = if (is_comptime) .alloc_inferred_comptime else .alloc_inferred_mut;
+                        break :alloc try gz.addNode(tag, node);
+                    } else {
+                        break :alloc try gz.addAllocExtended(.{
+                            .node = node,
+                            .type_inst = .none,
+                            .align_inst = align_inst,
+                            .is_const = false,
+                            .is_comptime = is_comptime,
+                        });
+                    }
+                };
                 resolve_inferred_alloc = alloc;
                 break :a .{ .alloc = alloc, .result_loc = .{ .inferred_ptr = alloc } };
             };

src/Module.zig+51

...	@@ -1630,6 +1630,57 @@ pub const Scope = struct {	...	@@ -1630,6 +1630,57 @@ pub const Scope = struct {
1630	});	1630	});
1631	}	1631	}
1632		1632
		1633	pub fn addAllocExtended(
		1634	gz: *GenZir,
		1635	args: struct {
		1636	/// Absolute node index. This function does the conversion to offset from Decl.
		1637	node: ast.Node.Index,
		1638	type_inst: Zir.Inst.Ref,
		1639	align_inst: Zir.Inst.Ref,
		1640	is_const: bool,
		1641	is_comptime: bool,
		1642	},
		1643	) !Zir.Inst.Ref {
		1644	const astgen = gz.astgen;
		1645	const gpa = astgen.gpa;
		1646
		1647	try gz.instructions.ensureUnusedCapacity(gpa, 1);
		1648	try astgen.instructions.ensureUnusedCapacity(gpa, 1);
		1649	try astgen.extra.ensureUnusedCapacity(
		1650	gpa,
		1651	@typeInfo(Zir.Inst.AllocExtended).Struct.fields.len +
		1652	@as(usize, @boolToInt(args.type_inst != .none)) +
		1653	@as(usize, @boolToInt(args.align_inst != .none)),
		1654	);
		1655	const payload_index = gz.astgen.addExtra(Zir.Inst.AllocExtended{
		1656	.src_node = gz.nodeIndexToRelative(args.node),
		1657	}) catch unreachable; // ensureUnusedCapacity above
		1658	if (args.type_inst != .none) {
		1659	astgen.extra.appendAssumeCapacity(@enumToInt(args.type_inst));
		1660	}
		1661	if (args.align_inst != .none) {
		1662	astgen.extra.appendAssumeCapacity(@enumToInt(args.align_inst));
		1663	}
		1664
		1665	const has_type: u4 = @boolToInt(args.type_inst != .none);
		1666	const has_align: u4 = @boolToInt(args.align_inst != .none);
		1667	const is_const: u4 = @boolToInt(args.is_const);
		1668	const is_comptime: u4 = @boolToInt(args.is_comptime);
		1669	const small: u16 = has_type \| (has_align << 1) \| (is_const << 2) \| (is_comptime << 3);
		1670
		1671	const new_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
		1672	astgen.instructions.appendAssumeCapacity(.{
		1673	.tag = .extended,
		1674	.data = .{ .extended = .{
		1675	.opcode = .alloc,
		1676	.small = small,
		1677	.operand = payload_index,
		1678	} },
		1679	});
		1680	gz.instructions.appendAssumeCapacity(new_index);
		1681	return gz.indexToRef(new_index);
		1682	}
		1683
1633	/// Asserts that `str` is 8 or fewer bytes.	1684	/// Asserts that `str` is 8 or fewer bytes.
1634	pub fn addSmallStr(	1685	pub fn addSmallStr(
1635	gz: *GenZir,	1686	gz: *GenZir,

src/Sema.zig+11

...	@@ -516,6 +516,7 @@ fn zirExtended(sema: Sema, block: Scope.Block, inst: Zir.Inst.Index) InnerErro	...	@@ -516,6 +516,7 @@ fn zirExtended(sema: Sema, block: Scope.Block, inst: Zir.Inst.Index) InnerErro
516	.error_return_trace => return sema.zirErrorReturnTrace(block, extended),	516	.error_return_trace => return sema.zirErrorReturnTrace(block, extended),
517	.frame => return sema.zirFrame( block, extended),	517	.frame => return sema.zirFrame( block, extended),
518	.frame_address => return sema.zirFrameAddress( block, extended),	518	.frame_address => return sema.zirFrameAddress( block, extended),
		519	.alloc => return sema.zirAllocExtended( block, extended),
519	.c_undef => return sema.zirCUndef( block, extended),	520	.c_undef => return sema.zirCUndef( block, extended),
520	.c_include => return sema.zirCInclude( block, extended),	521	.c_include => return sema.zirCInclude( block, extended),
521	.c_define => return sema.zirCDefine( block, extended),	522	.c_define => return sema.zirCDefine( block, extended),
...	@@ -1131,6 +1132,16 @@ fn zirIndexablePtrLen(sema: Sema, block: Scope.Block, inst: Zir.Inst.Index) In	...	@@ -1131,6 +1132,16 @@ fn zirIndexablePtrLen(sema: Sema, block: Scope.Block, inst: Zir.Inst.Index) In
1131	return sema.analyzeLoad(block, src, result_ptr, result_ptr.src);	1132	return sema.analyzeLoad(block, src, result_ptr, result_ptr.src);
1132	}	1133	}
1133		1134
		1135	fn zirAllocExtended(
		1136	sema: *Sema,
		1137	block: *Scope.Block,
		1138	extended: Zir.Inst.Extended.InstData,
		1139	) InnerError!*Inst {
		1140	const extra = sema.code.extraData(Zir.Inst.AllocExtended, extended.operand);
		1141	const src: LazySrcLoc = .{ .node_offset = extra.data.src_node };
		1142	return sema.mod.fail(&block.base, src, "TODO implement Sema.zirAllocExtended", .{});
		1143	}
		1144
1134	fn zirAllocComptime(sema: Sema, block: Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {	1145	fn zirAllocComptime(sema: Sema, block: Scope.Block, inst: Zir.Inst.Index) InnerError!*Inst {
1135	const inst_data = sema.code.instructions.items(.data)[inst].un_node;	1146	const inst_data = sema.code.instructions.items(.data)[inst].un_node;
1136	const src = inst_data.src();	1147	const src = inst_data.src();

src/Zir.zig+16-1

 @@ -926,7 +926,6 @@ pub const Inst = struct {
         /// Allocates stack local memory.
         /// Uses the `un_node` union field. The operand is the type of the allocated object.
         /// The node source location points to a var decl node.
-        /// Indicates the beginning of a new statement in debug info.
         alloc,
         /// Same as `alloc` except mutable.
         alloc_mut,
 @@ -1251,6 +1250,14 @@ pub const Inst = struct {
         /// Implements the `@frameAddress` builtin.
         /// `operand` is `src_node: i32`.
         frame_address,
+        /// Same as `alloc` from `Tag` but may contain an alignment instruction.
+        /// `operand` is payload index to `AllocExtended`.
+        /// `small`:
+        ///  * 0b000X - has type
+        ///  * 0b00X0 - has alignment
+        ///  * 0b0X00 - 1=const, 0=var
+        ///  * 0bX000 - is comptime
+        alloc,
         /// `operand` is payload index to `UnNode`.
         c_undef,
         /// `operand` is payload index to `UnNode`.
 @@ -2200,6 +2207,13 @@ pub const Inst = struct {
         args: Ref,
     };
+    /// Trailing:
+    /// 0. type_inst: Ref,  // if small 0b000X is set
+    /// 1. align_inst: Ref, // if small 0b00X0 is set
+    pub const AllocExtended = struct {
+        src_node: i32,
+    };
     /// Trailing: `CompileErrors.Item` for each `items_len`.
     pub const CompileErrors = struct {
         items_len: u32,
 @@ -2571,6 +2585,7 @@ const Writer = struct {
             => try self.writeExtNode(stream, extended),
             .func,
+            .alloc,
             .c_undef,
             .c_include,
             .c_define,