Commit 9da3a058d82573efeaf12fe61ab6a312649175ec | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-05-29 17:54:16-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-05-30 12:03:53-07:00
log	9da3a058d82573efeaf12fe61ab6a312649175ec
tree	b86f6f08761289b95c46e10879e476da455de218
parent	f846dc420fff629572caa1175bfa64e5fcffaeb5

stage2: add missing data to ZIR encoding of functions

The main purpose of this commit is to prepare to implement support for
callconv(), align(), linksection(), and addrspace() annotations on
generic functions where the provided expression depends on comptime
parameters (making the function generic).

It's a rather involved change, so this commit only makes the necessary
changes to AstGen without regressing any behavior, and a follow-up
commit can finish the task by making the enhancements to Sema.

By my quick estimation, the new encoding for functions is a negligible
improvement - along the lines of 0.005% fewer total ZIR bytes on
average. Still, it's nice that this commit, while adding more
data into ZIR, actually ends up reducing the storage size thanks to a
slightly more sophisticated encoding.

Zir.Inst.ExtendedFunc is renamed to Zir.Inst.FuncFancy to eliminate
confusion about it being an extended instruction (it used to be but is
no longer). The encoding for this instruction is completely reworked.

The encoding for Zir.Inst.Func is also changed slightly - when the
return type body length is 1, then only a Zir.Inst.Ref is provided; not
a full body.

linksection() and addrspace() are now communicated via func_fancy ZIR
instruction rather than as part of the corresponding decl. This allows
their expressions to observe comptime parameters.

5 files changed, 803 insertions(+), 241 deletions(-)

src/AstGen.zig+271-81

...	...	@@ -73,7 +73,7 @@ fn setExtra(astgen: *AstGen, index: usize, extra: anytype) void {
73	73	Zir.Inst.Call.Flags => @bitCast(u32, @field(extra, field.name)),
74	74	Zir.Inst.BuiltinCall.Flags => @bitCast(u32, @field(extra, field.name)),
75	75	Zir.Inst.SwitchBlock.Bits => @bitCast(u32, @field(extra, field.name)),
76		Zir.Inst.ExtendedFunc.Bits => @bitCast(u32, @field(extra, field.name)),
	76	Zir.Inst.FuncFancy.Bits => @bitCast(u32, @field(extra, field.name)),
77	77	else => @compileError("bad field type"),
78	78	};
79	79	i += 1;
...	...	@@ -1205,7 +1205,7 @@ fn fnProtoExpr(
1205	1205	break :is_var_args false;
1206	1206	};
1207	1207
1208		const align_inst: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
	1208	const align_ref: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
1209	1209	break :inst try expr(&block_scope, scope, align_rl, fn_proto.ast.align_expr);
1210	1210	};
1211	1211
...	...	@@ -1232,19 +1232,24 @@ fn fnProtoExpr(
1232	1232	if (is_inferred_error) {
1233	1233	return astgen.failTok(maybe_bang, "function prototype may not have inferred error set", .{});
1234	1234	}
1235		var ret_gz = block_scope.makeSubBlock(scope);
1236		defer ret_gz.unstack();
1237		const ret_ty = try expr(&ret_gz, scope, coerced_type_rl, fn_proto.ast.return_type);
1238		const ret_br = try ret_gz.addBreak(.break_inline, 0, ret_ty);
	1235	const ret_ty = try expr(&block_scope, scope, coerced_type_rl, fn_proto.ast.return_type);
1239	1236
1240	1237	const result = try block_scope.addFunc(.{
1241	1238	.src_node = fn_proto.ast.proto_node,
	1239
	1240	.cc_ref = cc,
	1241	.cc_gz = null,
	1242	.align_ref = align_ref,
	1243	.align_gz = null,
	1244	.ret_ref = ret_ty,
	1245	.ret_gz = null,
	1246	.section_ref = .none,
	1247	.section_gz = null,
	1248	.addrspace_ref = .none,
	1249	.addrspace_gz = null,
	1250
1242	1251	.param_block = block_inst,
1243		.ret_gz = &ret_gz,
1244		.ret_br = ret_br,
1245	1252	.body_gz = null,
1246		.cc = cc,
1247		.align_inst = align_inst,
1248	1253	.lib_name = 0,
1249	1254	.is_var_args = is_var_args,
1250	1255	.is_inferred_error = false,
...	...	@@ -2282,7 +2287,7 @@ fn unusedResultExpr(gz: GenZir, scope: Scope, statement: Ast.Node.Index) Inner
2282	2287	.field_val_named,
2283	2288	.func,
2284	2289	.func_inferred,
2285		.func_extended,
	2290	.func_fancy,
2286	2291	.int,
2287	2292	.int_big,
2288	2293	.float,
...	...	@@ -3395,9 +3400,8 @@ fn fnDecl(
3395	3400
3396	3401	const doc_comment_index = try astgen.docCommentAsString(fn_proto.firstToken());
3397	3402
3398		const has_section_or_addrspace = fn_proto.ast.section_expr != 0 or fn_proto.ast.addrspace_expr != 0;
3399		// Alignment is passed in the func instruction in this case.
3400		wip_members.nextDecl(is_pub, is_export, false, has_section_or_addrspace);
	3403	// align, linksection, and addrspace is passed in the func instruction in this case.
	3404	wip_members.nextDecl(is_pub, is_export, false, false);
3401	3405
3402	3406	var params_scope = &fn_gz.base;
3403	3407	const is_var_args = is_var_args: {
...	...	@@ -3483,17 +3487,49 @@ fn fnDecl(
3483	3487	const maybe_bang = tree.firstToken(fn_proto.ast.return_type) - 1;
3484	3488	const is_inferred_error = token_tags[maybe_bang] == .bang;
3485	3489
3486		const align_inst: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
3487		break :inst try expr(&decl_gz, params_scope, align_rl, fn_proto.ast.align_expr);
	3490	// After creating the function ZIR instruction, it will need to update the break
	3491	// instructions inside the expression blocks for align, addrspace, cc, and ret_ty
	3492	// to use the function instruction as the "block" to break from.
	3493
	3494	var align_gz = decl_gz.makeSubBlock(params_scope);
	3495	defer align_gz.unstack();
	3496	const align_ref: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
	3497	const inst = try expr(&decl_gz, params_scope, coerced_align_rl, fn_proto.ast.align_expr);
	3498	if (align_gz.instructionsSlice().len == 0) {
	3499	// In this case we will send a len=0 body which can be encoded more efficiently.
	3500	break :inst inst;
	3501	}
	3502	_ = try align_gz.addBreak(.break_inline, 0, inst);
	3503	break :inst inst;
3488	3504	};
3489		const addrspace_inst: Zir.Inst.Ref = if (fn_proto.ast.addrspace_expr == 0) .none else inst: {
3490		break :inst try expr(&decl_gz, params_scope, .{ .ty = .address_space_type }, fn_proto.ast.addrspace_expr);
	3505
	3506	var addrspace_gz = decl_gz.makeSubBlock(params_scope);
	3507	defer addrspace_gz.unstack();
	3508	const addrspace_ref: Zir.Inst.Ref = if (fn_proto.ast.addrspace_expr == 0) .none else inst: {
	3509	const inst = try expr(&decl_gz, params_scope, .{ .coerced_ty = .address_space_type }, fn_proto.ast.addrspace_expr);
	3510	if (addrspace_gz.instructionsSlice().len == 0) {
	3511	// In this case we will send a len=0 body which can be encoded more efficiently.
	3512	break :inst inst;
	3513	}
	3514	_ = try addrspace_gz.addBreak(.break_inline, 0, inst);
	3515	break :inst inst;
3491	3516	};
3492		const section_inst: Zir.Inst.Ref = if (fn_proto.ast.section_expr == 0) .none else inst: {
3493		break :inst try comptimeExpr(&decl_gz, params_scope, .{ .ty = .const_slice_u8_type }, fn_proto.ast.section_expr);
	3517
	3518	var section_gz = decl_gz.makeSubBlock(params_scope);
	3519	defer section_gz.unstack();
	3520	const section_ref: Zir.Inst.Ref = if (fn_proto.ast.section_expr == 0) .none else inst: {
	3521	const inst = try expr(&decl_gz, params_scope, .{ .coerced_ty = .const_slice_u8_type }, fn_proto.ast.section_expr);
	3522	if (section_gz.instructionsSlice().len == 0) {
	3523	// In this case we will send a len=0 body which can be encoded more efficiently.
	3524	break :inst inst;
	3525	}
	3526	_ = try section_gz.addBreak(.break_inline, 0, inst);
	3527	break :inst inst;
3494	3528	};
3495	3529
3496		const cc: Zir.Inst.Ref = blk: {
	3530	var cc_gz = decl_gz.makeSubBlock(params_scope);
	3531	defer cc_gz.unstack();
	3532	const cc_ref: Zir.Inst.Ref = blk: {
3497	3533	if (fn_proto.ast.callconv_expr != 0) {
3498	3534	if (has_inline_keyword) {
3499	3535	return astgen.failNode(
...	...	@@ -3502,12 +3538,18 @@ fn fnDecl(
3502	3538	.{},
3503	3539	);
3504	3540	}
3505		break :blk try expr(
	3541	const inst = try expr(
3506	3542	&decl_gz,
3507	3543	params_scope,
3508		.{ .ty = .calling_convention_type },
	3544	.{ .coerced_ty = .calling_convention_type },
3509	3545	fn_proto.ast.callconv_expr,
3510	3546	);
	3547	if (cc_gz.instructionsSlice().len == 0) {
	3548	// In this case we will send a len=0 body which can be encoded more efficiently.
	3549	break :blk inst;
	3550	}
	3551	_ = try cc_gz.addBreak(.break_inline, 0, inst);
	3552	break :blk inst;
3511	3553	} else if (is_extern) {
3512	3554	// note: https://github.com/ziglang/zig/issues/5269
3513	3555	break :blk .calling_convention_c;
...	...	@@ -3520,8 +3562,18 @@ fn fnDecl(
3520	3562
3521	3563	var ret_gz = decl_gz.makeSubBlock(params_scope);
3522	3564	defer ret_gz.unstack();
3523		const ret_ty = try expr(&ret_gz, params_scope, coerced_type_rl, fn_proto.ast.return_type);
3524		const ret_br = try ret_gz.addBreak(.break_inline, 0, ret_ty);
	3565	const ret_ref: Zir.Inst.Ref = switch (nodePrimitive(tree, fn_proto.ast.return_type)) {
	3566	.none => inst: {
	3567	const inst = try expr(&ret_gz, params_scope, coerced_type_rl, fn_proto.ast.return_type);
	3568	if (ret_gz.instructionsSlice().len == 0) {
	3569	// In this case we will send a len=0 body which can be encoded more efficiently.
	3570	break :inst inst;
	3571	}
	3572	_ = try ret_gz.addBreak(.break_inline, 0, inst);
	3573	break :inst inst;
	3574	},
	3575	else => \|p\| p,
	3576	};
3525	3577
3526	3578	const func_inst: Zir.Inst.Ref = if (body_node == 0) func: {
3527	3579	if (!is_extern) {
...	...	@@ -3532,12 +3584,18 @@ fn fnDecl(
3532	3584	}
3533	3585	break :func try decl_gz.addFunc(.{
3534	3586	.src_node = decl_node,
	3587	.cc_ref = cc_ref,
	3588	.cc_gz = &cc_gz,
	3589	.align_ref = align_ref,
	3590	.align_gz = &align_gz,
	3591	.ret_ref = ret_ref,
3535	3592	.ret_gz = &ret_gz,
3536		.ret_br = ret_br,
	3593	.section_ref = section_ref,
	3594	.section_gz = &section_gz,
	3595	.addrspace_ref = addrspace_ref,
	3596	.addrspace_gz = &addrspace_gz,
3537	3597	.param_block = block_inst,
3538	3598	.body_gz = null,
3539		.cc = cc,
3540		.align_inst = align_inst,
3541	3599	.lib_name = lib_name,
3542	3600	.is_var_args = is_var_args,
3543	3601	.is_inferred_error = false,
...	...	@@ -3571,14 +3629,20 @@ fn fnDecl(
3571	3629
3572	3630	break :func try decl_gz.addFunc(.{
3573	3631	.src_node = decl_node,
	3632	.cc_ref = cc_ref,
	3633	.cc_gz = &cc_gz,
	3634	.align_ref = align_ref,
	3635	.align_gz = &align_gz,
	3636	.ret_ref = ret_ref,
	3637	.ret_gz = &ret_gz,
	3638	.section_ref = section_ref,
	3639	.section_gz = &section_gz,
	3640	.addrspace_ref = addrspace_ref,
	3641	.addrspace_gz = &addrspace_gz,
3574	3642	.lbrace_line = lbrace_line,
3575	3643	.lbrace_column = lbrace_column,
3576	3644	.param_block = block_inst,
3577		.ret_gz = &ret_gz,
3578		.ret_br = ret_br,
3579	3645	.body_gz = &fn_gz,
3580		.cc = cc,
3581		.align_inst = align_inst,
3582	3646	.lib_name = lib_name,
3583	3647	.is_var_args = is_var_args,
3584	3648	.is_inferred_error = is_inferred_error,
...	...	@@ -3604,10 +3668,6 @@ fn fnDecl(
3604	3668	wip_members.appendToDecl(fn_name_str_index);
3605	3669	wip_members.appendToDecl(block_inst);
3606	3670	wip_members.appendToDecl(doc_comment_index);
3607		if (has_section_or_addrspace) {
3608		wip_members.appendToDecl(@enumToInt(section_inst));
3609		wip_members.appendToDecl(@enumToInt(addrspace_inst));
3610		}
3611	3671	}
3612	3672
3613	3673	fn globalVarDecl(
...	...	@@ -4001,14 +4061,22 @@ fn testDecl(
4001	4061
4002	4062	const func_inst = try decl_block.addFunc(.{
4003	4063	.src_node = node,
	4064
	4065	.cc_ref = .none,
	4066	.cc_gz = null,
	4067	.align_ref = .none,
	4068	.align_gz = null,
	4069	.ret_ref = .void_type,
	4070	.ret_gz = null,
	4071	.section_ref = .none,
	4072	.section_gz = null,
	4073	.addrspace_ref = .none,
	4074	.addrspace_gz = null,
	4075
4004	4076	.lbrace_line = lbrace_line,
4005	4077	.lbrace_column = lbrace_column,
4006	4078	.param_block = block_inst,
4007		.ret_gz = null,
4008		.ret_br = 0,
4009	4079	.body_gz = &fn_block,
4010		.cc = .none,
4011		.align_inst = .none,
4012	4080	.lib_name = 0,
4013	4081	.is_var_args = false,
4014	4082	.is_inferred_error = true,
...	...	@@ -8957,6 +9025,31 @@ fn nodeImpliesComptimeOnly(tree: *const Ast, start_node: Ast.Node.Index) bool {
8957	9025	}
8958	9026	}
8959	9027
	9028	fn nodePrimitive(tree: *const Ast, start_node: Ast.Node.Index) Zir.Inst.Ref {
	9029	const node_tags = tree.nodes.items(.tag);
	9030	const node_datas = tree.nodes.items(.data);
	9031
	9032	var node = start_node;
	9033	while (true) {
	9034	switch (node_tags[node]) {
	9035	// Forward the question to the LHS sub-expression.
	9036	.grouped_expression => node = node_datas[node].lhs,
	9037
	9038	.identifier => {
	9039	const main_tokens = tree.nodes.items(.main_token);
	9040	const ident_bytes = tree.tokenSlice(main_tokens[node]);
	9041	if (primitives.get(ident_bytes)) \|primitive\| {
	9042	return primitive;
	9043	} else {
	9044	return .none;
	9045	}
	9046	},
	9047
	9048	else => return .none,
	9049	}
	9050	}
	9051	}
	9052
8960	9053	/// Applies `rl` semantics to `result`. Expressions which do not do their own handling of
8961	9054	/// result locations must call this function on their result.
8962	9055	/// As an example, if the `ResultLoc` is `ptr`, it will write the result to the pointer.
...	...	@@ -9952,17 +10045,34 @@ const GenZir = struct {
9952	10045	gz.unstack();
9953	10046	}
9954	10047
9955		/// Supports `body_gz` stacked on `ret_gz` stacked on `gz`. Unstacks `body_gz` and `ret_gz`.
	10048	/// Must be called with the following stack set up:
	10049	/// * gz (bottom)
	10050	/// * align_gz
	10051	/// * addrspace_gz
	10052	/// * section_gz
	10053	/// * cc_gz
	10054	/// * ret_gz
	10055	/// * body_gz (top)
	10056	/// Unstacks all of those except for `gz`.
9956	10057	fn addFunc(gz: *GenZir, args: struct {
9957	10058	src_node: Ast.Node.Index,
9958	10059	lbrace_line: u32 = 0,
9959	10060	lbrace_column: u32 = 0,
9960		body_gz: ?*GenZir,
9961	10061	param_block: Zir.Inst.Index,
	10062
	10063	align_gz: ?*GenZir,
	10064	addrspace_gz: ?*GenZir,
	10065	section_gz: ?*GenZir,
	10066	cc_gz: ?*GenZir,
9962	10067	ret_gz: ?*GenZir,
9963		ret_br: Zir.Inst.Index,
9964		cc: Zir.Inst.Ref,
9965		align_inst: Zir.Inst.Ref,
	10068	body_gz: ?*GenZir,
	10069
	10070	align_ref: Zir.Inst.Ref,
	10071	addrspace_ref: Zir.Inst.Ref,
	10072	section_ref: Zir.Inst.Ref,
	10073	cc_ref: Zir.Inst.Ref,
	10074	ret_ref: Zir.Inst.Ref,
	10075
9966	10076	lib_name: u32,
9967	10077	is_var_args: bool,
9968	10078	is_inferred_error: bool,
...	...	@@ -9972,11 +10082,13 @@ const GenZir = struct {
9972	10082	assert(args.src_node != 0);
9973	10083	const astgen = gz.astgen;
9974	10084	const gpa = astgen.gpa;
	10085	const ret_ref = if (args.ret_ref == .void_type) .none else args.ret_ref;
	10086	const new_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
9975	10087
9976	10088	try astgen.instructions.ensureUnusedCapacity(gpa, 1);
9977	10089
9978	10090	var body: []Zir.Inst.Index = &[0]Zir.Inst.Index{};
9979		var ret_ty: []Zir.Inst.Index = &[0]Zir.Inst.Index{};
	10091	var ret_body: []Zir.Inst.Index = &[0]Zir.Inst.Index{};
9980	10092	var src_locs_buffer: [3]u32 = undefined;
9981	10093	var src_locs: []u32 = src_locs_buffer[0..0];
9982	10094	if (args.body_gz) \|body_gz\| {
...	...	@@ -10000,61 +10112,120 @@ const GenZir = struct {
10000	10112
10001	10113	body = body_gz.instructionsSlice();
10002	10114	if (args.ret_gz) \|ret_gz\|
10003		ret_ty = ret_gz.instructionsSliceUpto(body_gz);
	10115	ret_body = ret_gz.instructionsSliceUpto(body_gz);
10004	10116	} else {
10005	10117	if (args.ret_gz) \|ret_gz\|
10006		ret_ty = ret_gz.instructionsSlice();
	10118	ret_body = ret_gz.instructionsSlice();
10007	10119	}
10008	10120
10009		if (args.cc != .none or args.lib_name != 0 or
10010		args.is_var_args or args.is_test or args.align_inst != .none or
10011		args.is_extern)
	10121	if (args.cc_ref != .none or args.lib_name != 0 or
	10122	args.is_var_args or args.is_test or args.is_extern or
	10123	args.align_ref != .none or args.section_ref != .none or
	10124	args.addrspace_ref != .none)
10012	10125	{
	10126	var align_body: []Zir.Inst.Index = &.{};
	10127	var addrspace_body: []Zir.Inst.Index = &.{};
	10128	var section_body: []Zir.Inst.Index = &.{};
	10129	var cc_body: []Zir.Inst.Index = &.{};
	10130	if (args.ret_gz != null) {
	10131	align_body = args.align_gz.?.instructionsSliceUpto(args.addrspace_gz.?);
	10132	addrspace_body = args.addrspace_gz.?.instructionsSliceUpto(args.section_gz.?);
	10133	section_body = args.section_gz.?.instructionsSliceUpto(args.cc_gz.?);
	10134	cc_body = args.cc_gz.?.instructionsSliceUpto(args.ret_gz.?);
	10135	}
	10136
10013	10137	try astgen.extra.ensureUnusedCapacity(
10014	10138	gpa,
10015		@typeInfo(Zir.Inst.ExtendedFunc).Struct.fields.len +
10016		ret_ty.len + body.len + src_locs.len +
10017		@boolToInt(args.lib_name != 0) +
10018		@boolToInt(args.align_inst != .none) +
10019		@boolToInt(args.cc != .none),
	10139	@typeInfo(Zir.Inst.FuncFancy).Struct.fields.len +
	10140	fancyFnExprExtraLen(align_body, args.align_ref) +
	10141	fancyFnExprExtraLen(addrspace_body, args.addrspace_ref) +
	10142	fancyFnExprExtraLen(section_body, args.section_ref) +
	10143	fancyFnExprExtraLen(cc_body, args.cc_ref) +
	10144	fancyFnExprExtraLen(ret_body, ret_ref) +
	10145	body.len + src_locs.len +
	10146	@boolToInt(args.lib_name != 0),
10020	10147	);
10021		const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.ExtendedFunc{
	10148	const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.FuncFancy{
10022	10149	.param_block = args.param_block,
10023		.ret_body_len = @intCast(u32, ret_ty.len),
10024	10150	.body_len = @intCast(u32, body.len),
10025	10151	.bits = .{
10026	10152	.is_var_args = args.is_var_args,
10027	10153	.is_inferred_error = args.is_inferred_error,
10028		.has_lib_name = args.lib_name != 0,
10029		.has_cc = args.cc != .none,
10030		.has_align = args.align_inst != .none,
10031	10154	.is_test = args.is_test,
10032	10155	.is_extern = args.is_extern,
	10156	.has_lib_name = args.lib_name != 0,
	10157
	10158	.has_align_ref = args.align_ref != .none,
	10159	.has_addrspace_ref = args.addrspace_ref != .none,
	10160	.has_section_ref = args.section_ref != .none,
	10161	.has_cc_ref = args.cc_ref != .none,
	10162	.has_ret_ty_ref = ret_ref != .none,
	10163
	10164	.has_align_body = align_body.len != 0,
	10165	.has_addrspace_body = addrspace_body.len != 0,
	10166	.has_section_body = section_body.len != 0,
	10167	.has_cc_body = cc_body.len != 0,
	10168	.has_ret_ty_body = ret_body.len != 0,
10033	10169	},
10034	10170	});
10035	10171	if (args.lib_name != 0) {
10036	10172	astgen.extra.appendAssumeCapacity(args.lib_name);
10037	10173	}
10038		if (args.cc != .none) {
10039		astgen.extra.appendAssumeCapacity(@enumToInt(args.cc));
	10174
	10175	const zir_datas = astgen.instructions.items(.data);
	10176	if (align_body.len != 0) {
	10177	astgen.extra.appendAssumeCapacity(@intCast(u32, align_body.len));
	10178	astgen.extra.appendSliceAssumeCapacity(align_body);
	10179	zir_datas[align_body[align_body.len - 1]].@"break".block_inst = new_index;
	10180	} else if (args.align_ref != .none) {
	10181	astgen.extra.appendAssumeCapacity(@enumToInt(args.align_ref));
	10182	}
	10183	if (addrspace_body.len != 0) {
	10184	astgen.extra.appendAssumeCapacity(@intCast(u32, addrspace_body.len));
	10185	astgen.extra.appendSliceAssumeCapacity(addrspace_body);
	10186	zir_datas[addrspace_body[addrspace_body.len - 1]].@"break".block_inst = new_index;
	10187	} else if (args.addrspace_ref != .none) {
	10188	astgen.extra.appendAssumeCapacity(@enumToInt(args.addrspace_ref));
	10189	}
	10190	if (section_body.len != 0) {
	10191	astgen.extra.appendAssumeCapacity(@intCast(u32, section_body.len));
	10192	astgen.extra.appendSliceAssumeCapacity(section_body);
	10193	zir_datas[section_body[section_body.len - 1]].@"break".block_inst = new_index;
	10194	} else if (args.section_ref != .none) {
	10195	astgen.extra.appendAssumeCapacity(@enumToInt(args.section_ref));
10040	10196	}
10041		if (args.align_inst != .none) {
10042		astgen.extra.appendAssumeCapacity(@enumToInt(args.align_inst));
	10197	if (cc_body.len != 0) {
	10198	astgen.extra.appendAssumeCapacity(@intCast(u32, cc_body.len));
	10199	astgen.extra.appendSliceAssumeCapacity(cc_body);
	10200	zir_datas[cc_body[cc_body.len - 1]].@"break".block_inst = new_index;
	10201	} else if (args.cc_ref != .none) {
	10202	astgen.extra.appendAssumeCapacity(@enumToInt(args.cc_ref));
10043	10203	}
10044		astgen.extra.appendSliceAssumeCapacity(ret_ty);
	10204	if (ret_body.len != 0) {
	10205	astgen.extra.appendAssumeCapacity(@intCast(u32, ret_body.len));
	10206	astgen.extra.appendSliceAssumeCapacity(ret_body);
	10207	zir_datas[ret_body[ret_body.len - 1]].@"break".block_inst = new_index;
	10208	} else if (ret_ref != .none) {
	10209	astgen.extra.appendAssumeCapacity(@enumToInt(ret_ref));
	10210	}
	10211
10045	10212	astgen.extra.appendSliceAssumeCapacity(body);
10046	10213	astgen.extra.appendSliceAssumeCapacity(src_locs);
10047		// order is important when unstacking
	10214
	10215	// Order is important when unstacking.
10048	10216	if (args.body_gz) \|body_gz\| body_gz.unstack();
10049		if (args.ret_gz) \|ret_gz\| ret_gz.unstack();
	10217	if (args.ret_gz != null) {
	10218	args.ret_gz.?.unstack();
	10219	args.cc_gz.?.unstack();
	10220	args.section_gz.?.unstack();
	10221	args.addrspace_gz.?.unstack();
	10222	args.align_gz.?.unstack();
	10223	}
	10224
10050	10225	try gz.instructions.ensureUnusedCapacity(gpa, 1);
10051	10226
10052		const new_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
10053		if (args.ret_br != 0) {
10054		astgen.instructions.items(.data)[args.ret_br].@"break".block_inst = new_index;
10055		}
10056	10227	astgen.instructions.appendAssumeCapacity(.{
10057		.tag = .func_extended,
	10228	.tag = .func_fancy,
10058	10229	.data = .{ .pl_node = .{
10059	10230	.src_node = gz.nodeIndexToRelative(args.src_node),
10060	10231	.payload_index = payload_index,
...	...	@@ -10066,27 +10237,40 @@ const GenZir = struct {
10066	10237	try astgen.extra.ensureUnusedCapacity(
10067	10238	gpa,
10068	10239	@typeInfo(Zir.Inst.Func).Struct.fields.len +
10069		ret_ty.len + body.len + src_locs.len,
	10240	@maximum(ret_body.len, @boolToInt(ret_ref != .none)) +
	10241	body.len + src_locs.len,
10070	10242	);
	10243	const ret_body_len = if (ret_body.len != 0)
	10244	@intCast(u32, ret_body.len)
	10245	else
	10246	@boolToInt(ret_ref != .none);
10071	10247
10072	10248	const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.Func{
10073	10249	.param_block = args.param_block,
10074		.ret_body_len = @intCast(u32, ret_ty.len),
	10250	.ret_body_len = ret_body_len,
10075	10251	.body_len = @intCast(u32, body.len),
10076	10252	});
10077		astgen.extra.appendSliceAssumeCapacity(ret_ty);
	10253	const zir_datas = astgen.instructions.items(.data);
	10254	if (ret_body.len != 0) {
	10255	astgen.extra.appendSliceAssumeCapacity(ret_body);
	10256	zir_datas[ret_body[ret_body.len - 1]].@"break".block_inst = new_index;
	10257	} else if (ret_ref != .none) {
	10258	astgen.extra.appendAssumeCapacity(@enumToInt(ret_ref));
	10259	}
10078	10260	astgen.extra.appendSliceAssumeCapacity(body);
10079	10261	astgen.extra.appendSliceAssumeCapacity(src_locs);
10080		// order is important when unstacking
	10262
	10263	// Order is important when unstacking.
10081	10264	if (args.body_gz) \|body_gz\| body_gz.unstack();
10082	10265	if (args.ret_gz) \|ret_gz\| ret_gz.unstack();
	10266	if (args.cc_gz) \|cc_gz\| cc_gz.unstack();
	10267	if (args.section_gz) \|section_gz\| section_gz.unstack();
	10268	if (args.addrspace_gz) \|addrspace_gz\| addrspace_gz.unstack();
	10269	if (args.align_gz) \|align_gz\| align_gz.unstack();
	10270
10083	10271	try gz.instructions.ensureUnusedCapacity(gpa, 1);
10084	10272
10085	10273	const tag: Zir.Inst.Tag = if (args.is_inferred_error) .func_inferred else .func;
10086		const new_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
10087		if (args.ret_br != 0) {
10088		astgen.instructions.items(.data)[args.ret_br].@"break".block_inst = new_index;
10089		}
10090	10274	astgen.instructions.appendAssumeCapacity(.{
10091	10275	.tag = tag,
10092	10276	.data = .{ .pl_node = .{
...	...	@@ -10099,6 +10283,12 @@ const GenZir = struct {
10099	10283	}
10100	10284	}
10101	10285
	10286	fn fancyFnExprExtraLen(body: []Zir.Inst.Index, ref: Zir.Inst.Ref) usize {
	10287	// In the case of non-empty body, there is one for the body length,
	10288	// and then one for each instruction.
	10289	return body.len + @boolToInt(ref != .none);
	10290	}
	10291
10102	10292	fn addVar(gz: *GenZir, args: struct {
10103	10293	align_inst: Zir.Inst.Ref,
10104	10294	lib_name: u32,

src/Module.zig+2-2

...	...	@@ -1595,9 +1595,9 @@ pub const Fn = struct {
1595	1595	switch (zir_tags[func.zir_body_inst]) {
1596	1596	.func => return false,
1597	1597	.func_inferred => return true,
1598		.func_extended => {
	1598	.func_fancy => {
1599	1599	const inst_data = zir.instructions.items(.data)[func.zir_body_inst].pl_node;
1600		const extra = zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
	1600	const extra = zir.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);
1601	1601	return extra.data.bits.is_inferred_error;
1602	1602	},
1603	1603	else => unreachable,

src/Sema.zig+189-68

...	...	@@ -747,7 +747,7 @@ fn analyzeBodyInner(
747	747	.field_call_bind => try sema.zirFieldCallBind(block, inst),
748	748	.func => try sema.zirFunc(block, inst, false),
749	749	.func_inferred => try sema.zirFunc(block, inst, true),
750		.func_extended => try sema.zirFuncExtended(block, inst),
	750	.func_fancy => try sema.zirFuncFancy(block, inst),
751	751	.import => try sema.zirImport(block, inst),
752	752	.indexable_ptr_len => try sema.zirIndexablePtrLen(block, inst),
753	753	.int => try sema.zirInt(block, inst),
...	...	@@ -5186,7 +5186,10 @@ fn analyzeCall(
5186	5186	// on parameters, we must now do the same for the return type as we just did with
5187	5187	// each of the parameters, resolving the return type and providing it to the child
5188	5188	// `Sema` so that it can be used for the `ret_ptr` instruction.
5189		const ret_ty_inst = try sema.resolveBody(&child_block, fn_info.ret_ty_body, module_fn.zir_body_inst);
	5189	const ret_ty_inst = if (fn_info.ret_ty_body.len != 0)
	5190	try sema.resolveBody(&child_block, fn_info.ret_ty_body, module_fn.zir_body_inst)
	5191	else
	5192	try sema.resolveInst(fn_info.ret_ty_ref);
5190	5193	const ret_ty_src = func_src; // TODO better source location
5191	5194	const bare_return_type = try sema.analyzeAsType(&child_block, ret_ty_src, ret_ty_inst);
5192	5195	// Create a fresh inferred error set type for inline/comptime calls.
...	...	@@ -6497,9 +6500,34 @@ fn zirFunc(
6497	6500
6498	6501	const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
6499	6502	const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);
	6503	const target = sema.mod.getTarget();
	6504	const ret_ty_src = inst_data.src(); // TODO better source location
	6505
6500	6506	var extra_index = extra.end;
6501		const ret_ty_body = sema.code.extra[extra_index..][0..extra.data.ret_body_len];
6502		extra_index += ret_ty_body.len;
	6507
	6508	const ret_ty: Type = switch (extra.data.ret_body_len) {
	6509	0 => Type.void,
	6510	1 => blk: {
	6511	const ret_ty_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
	6512	extra_index += 1;
	6513	if (sema.resolveType(block, ret_ty_src, ret_ty_ref)) \|ret_ty\| {
	6514	break :blk ret_ty;
	6515	} else \|err\| switch (err) {
	6516	error.GenericPoison => {
	6517	break :blk Type.initTag(.generic_poison);
	6518	},
	6519	else => \|e\| return e,
	6520	}
	6521	},
	6522	else => blk: {
	6523	const ret_ty_body = sema.code.extra[extra_index..][0..extra.data.ret_body_len];
	6524	extra_index += ret_ty_body.len;
	6525
	6526	const ret_ty_val = try sema.resolveGenericBody(block, ret_ty_src, ret_ty_body, inst, Type.type);
	6527	var buffer: Value.ToTypeBuffer = undefined;
	6528	break :blk try ret_ty_val.toType(&buffer).copy(sema.arena);
	6529	},
	6530	};
6503	6531
6504	6532	var src_locs: Zir.Inst.Func.SrcLocs = undefined;
6505	6533	const has_body = extra.data.body_len != 0;
...	...	@@ -6517,9 +6545,11 @@ fn zirFunc(
6517	6545	block,
6518	6546	inst_data.src_node,
6519	6547	inst,
6520		ret_ty_body,
	6548	0,
	6549	target_util.defaultAddressSpace(target, .function),
	6550	null,
6521	6551	cc,
6522		Value.@"null",
	6552	ret_ty,
6523	6553	false,
6524	6554	inferred_error_set,
6525	6555	false,
...	...	@@ -6529,6 +6559,44 @@ fn zirFunc(
6529	6559	);
6530	6560	}
6531	6561
	6562	// TODO this function and its callsites along with funcCommon need to be reworked
	6563	// to handle when callconv, align, linksection, addrspace depend on comptime values
	6564	// (thus triggering error.GenericPoison)
	6565	fn resolveGenericBody(
	6566	sema: *Sema,
	6567	block: *Block,
	6568	src: LazySrcLoc,
	6569	body: []const Zir.Inst.Index,
	6570	func_inst: Zir.Inst.Index,
	6571	dest_ty: Type,
	6572	) !Value {
	6573	assert(body.len != 0);
	6574
	6575	const err = err: {
	6576	// Make sure any nested param instructions don't clobber our work.
	6577	const prev_params = block.params;
	6578	block.params = .{};
	6579	defer {
	6580	block.params.deinit(sema.gpa);
	6581	block.params = prev_params;
	6582	}
	6583	const uncasted = sema.resolveBody(block, body, func_inst) catch \|err\| break :err err;
	6584	const result = sema.coerce(block, dest_ty, uncasted, src) catch \|err\| break :err err;
	6585	const val = sema.resolveConstValue(block, src, result) catch \|err\| break :err err;
	6586	return val;
	6587	};
	6588	switch (err) {
	6589	error.GenericPoison => {
	6590	if (dest_ty.tag() == .type) {
	6591	return Value.initTag(.generic_poison_type);
	6592	} else {
	6593	return Value.initTag(.generic_poison);
	6594	}
	6595	},
	6596	else => \|e\| return e,
	6597	}
	6598	}
	6599
6532	6600	/// Given a library name, examines if the library name should end up in
6533	6601	/// `link.File.Options.system_libs` table (for example, libc is always
6534	6602	/// specified via dedicated flag `link.File.Options.link_libc` instead),
...	...	@@ -6597,9 +6665,11 @@ fn funcCommon(
6597	6665	block: *Block,
6598	6666	src_node_offset: i32,
6599	6667	func_inst: Zir.Inst.Index,
6600		ret_ty_body: []const Zir.Inst.Index,
	6668	alignment: u32,
	6669	address_space: std.builtin.AddressSpace,
	6670	section: ?[*:0]const u8,
6601	6671	cc: std.builtin.CallingConvention,
6602		align_val: Value,
	6672	bare_return_type: Type,
6603	6673	var_args: bool,
6604	6674	inferred_error_set: bool,
6605	6675	is_extern: bool,
...	...	@@ -6609,42 +6679,11 @@ fn funcCommon(
6609	6679	) CompileError!Air.Inst.Ref {
6610	6680	const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
6611	6681
6612		// The return type body might be a type expression that depends on generic parameters.
6613		// In such case we need to use a generic_poison value for the return type and mark
6614		// the function as generic.
6615		var is_generic = false;
6616		const bare_return_type: Type = ret_ty: {
6617		if (ret_ty_body.len == 0) break :ret_ty Type.void;
6618
6619		const err = err: {
6620		// Make sure any nested param instructions don't clobber our work.
6621		const prev_params = block.params;
6622		block.params = .{};
6623		defer {
6624		block.params.deinit(sema.gpa);
6625		block.params = prev_params;
6626		}
6627		if (sema.resolveBody(block, ret_ty_body, func_inst)) \|ret_ty_inst\| {
6628		if (sema.analyzeAsType(block, ret_ty_src, ret_ty_inst)) \|ret_ty\| {
6629		break :ret_ty ret_ty;
6630		} else \|err\| break :err err;
6631		} else \|err\| break :err err;
6632		// Check for generic params.
6633		for (block.params.items) \|param\| {
6634		if (param.ty.tag() == .generic_poison) is_generic = true;
6635		}
6636		};
6637		switch (err) {
6638		error.GenericPoison => {
6639		// The type is not available until the generic instantiation.
6640		is_generic = true;
6641		break :ret_ty Type.initTag(.generic_poison);
6642		},
6643		else => \|e\| return e,
6644		}
6645		};
6646
6647		const mod = sema.mod;
	6682	var is_generic = bare_return_type.tag() == .generic_poison;
	6683	// Check for generic params.
	6684	for (block.params.items) \|param\| {
	6685	if (param.ty.tag() == .generic_poison) is_generic = true;
	6686	}
6648	6687
6649	6688	const new_func: *Module.Fn = new_func: {
6650	6689	if (!has_body) break :new_func undefined;
...	...	@@ -6661,18 +6700,7 @@ fn funcCommon(
6661	6700	errdefer if (maybe_inferred_error_set_node) \|node\| sema.gpa.destroy(node);
6662	6701	// Note: no need to errdefer since this will still be in its default state at the end of the function.
6663	6702
6664		const target = mod.getTarget();
6665
6666	6703	const fn_ty: Type = fn_ty: {
6667		const alignment: u32 = if (align_val.tag() == .null_value) 0 else a: {
6668		const alignment = @intCast(u32, align_val.toUnsignedInt(target));
6669		if (alignment == target_util.defaultFunctionAlignment(target)) {
6670		break :a 0;
6671		} else {
6672		break :a alignment;
6673		}
6674		};
6675
6676	6704	// Hot path for some common function types.
6677	6705	// TODO can we eliminate some of these Type tag values? seems unnecessarily complicated.
6678	6706	if (!is_generic and block.params.items.len == 0 and !var_args and
...	...	@@ -6747,6 +6775,12 @@ fn funcCommon(
6747	6775	});
6748	6776	};
6749	6777
	6778	if (sema.owner_decl.owns_tv) {
	6779	sema.owner_decl.@"linksection" = section;
	6780	sema.owner_decl.@"align" = alignment;
	6781	sema.owner_decl.@"addrspace" = address_space;
	6782	}
	6783
6750	6784	if (is_extern) {
6751	6785	const new_extern_fn = try sema.gpa.create(Module.ExternFn);
6752	6786	errdefer sema.gpa.destroy(new_extern_fn);
...	...	@@ -16723,16 +16757,20 @@ fn zirVarExtended(
16723	16757	return result;
16724	16758	}
16725	16759
16726		fn zirFuncExtended(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
	16760	fn zirFuncFancy(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
16727	16761	const tracy = trace(@src());
16728	16762	defer tracy.end();
16729	16763
16730	16764	const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
16731	16765	const src = inst_data.src();
16732		const extra = sema.code.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
	16766	const extra = sema.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);
	16767	const target = sema.mod.getTarget();
16733	16768
16734		const cc_src: LazySrcLoc = .{ .node_offset_fn_type_cc = inst_data.src_node };
16735	16769	const align_src: LazySrcLoc = src; // TODO add a LazySrcLoc that points at align
	16770	const addrspace_src: LazySrcLoc = src; // TODO add a LazySrcLoc that points at addrspace
	16771	const section_src: LazySrcLoc = src; // TODO add a LazySrcLoc that points at section
	16772	const cc_src: LazySrcLoc = .{ .node_offset_fn_type_cc = inst_data.src_node };
	16773	const ret_src: LazySrcLoc = src; // TODO add a LazySrcLoc that points at the return type
16736	16774
16737	16775	var extra_index: usize = extra.end;
16738	16776
...	...	@@ -16742,22 +16780,103 @@ fn zirFuncExtended(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileErro
16742	16780	break :blk lib_name;
16743	16781	} else null;
16744	16782
16745		const cc: std.builtin.CallingConvention = if (extra.data.bits.has_cc) blk: {
	16783	const @"align": u32 = if (extra.data.bits.has_align_body) blk: {
	16784	const body_len = sema.code.extra[extra_index];
	16785	extra_index += 1;
	16786	const body = sema.code.extra[extra_index..][0..body_len];
	16787	extra_index += body.len;
	16788
	16789	const val = try sema.resolveGenericBody(block, align_src, body, inst, Type.u16);
	16790	const alignment = @intCast(u32, val.toUnsignedInt(target));
	16791	if (alignment == target_util.defaultFunctionAlignment(target)) {
	16792	break :blk 0;
	16793	} else {
	16794	break :blk alignment;
	16795	}
	16796	} else if (extra.data.bits.has_align_ref) blk: {
	16797	const align_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
	16798	extra_index += 1;
	16799	const align_tv = try sema.resolveInstConst(block, align_src, align_ref);
	16800	const alignment = @intCast(u32, align_tv.val.toUnsignedInt(target));
	16801	if (alignment == target_util.defaultFunctionAlignment(target)) {
	16802	break :blk 0;
	16803	} else {
	16804	break :blk alignment;
	16805	}
	16806	} else 0;
	16807
	16808	const @"addrspace": std.builtin.AddressSpace = if (extra.data.bits.has_addrspace_body) blk: {
	16809	const body_len = sema.code.extra[extra_index];
	16810	extra_index += 1;
	16811	const body = sema.code.extra[extra_index..][0..body_len];
	16812	extra_index += body.len;
	16813
	16814	const addrspace_ty = try sema.getBuiltinType(block, addrspace_src, "AddressSpace");
	16815	const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty);
	16816	break :blk val.toEnum(std.builtin.AddressSpace);
	16817	} else if (extra.data.bits.has_addrspace_ref) blk: {
	16818	const addrspace_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
	16819	extra_index += 1;
	16820	const addrspace_tv = try sema.resolveInstConst(block, addrspace_src, addrspace_ref);
	16821	break :blk addrspace_tv.val.toEnum(std.builtin.AddressSpace);
	16822	} else target_util.defaultAddressSpace(target, .function);
	16823
	16824	const @"linksection": ?[*:0]const u8 = if (extra.data.bits.has_section_body) {
	16825	const body_len = sema.code.extra[extra_index];
	16826	extra_index += 1;
	16827	const body = sema.code.extra[extra_index..][0..body_len];
	16828	extra_index += body.len;
	16829
	16830	const val = try sema.resolveGenericBody(block, section_src, body, inst, Type.initTag(.const_slice_u8));
	16831	_ = val;
	16832	return sema.fail(block, section_src, "TODO implement linksection on functions", .{});
	16833	} else if (extra.data.bits.has_section_ref) {
	16834	const section_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
	16835	extra_index += 1;
	16836	const section_tv = try sema.resolveInstConst(block, section_src, section_ref);
	16837	_ = section_tv;
	16838	return sema.fail(block, section_src, "TODO implement linksection on functions", .{});
	16839	} else null;
	16840
	16841	const cc: std.builtin.CallingConvention = if (extra.data.bits.has_cc_body) blk: {
	16842	const body_len = sema.code.extra[extra_index];
	16843	extra_index += 1;
	16844	const body = sema.code.extra[extra_index..][0..body_len];
	16845	extra_index += body.len;
	16846
	16847	const cc_ty = try sema.getBuiltinType(block, addrspace_src, "CallingConvention");
	16848	const val = try sema.resolveGenericBody(block, cc_src, body, inst, cc_ty);
	16849	break :blk val.toEnum(std.builtin.CallingConvention);
	16850	} else if (extra.data.bits.has_cc_ref) blk: {
16746	16851	const cc_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
16747	16852	extra_index += 1;
16748	16853	const cc_tv = try sema.resolveInstConst(block, cc_src, cc_ref);
16749	16854	break :blk cc_tv.val.toEnum(std.builtin.CallingConvention);
16750	16855	} else .Unspecified;
16751	16856
16752		const align_val: Value = if (extra.data.bits.has_align) blk: {
16753		const align_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
	16857	const ret_ty: Type = if (extra.data.bits.has_ret_ty_body) blk: {
	16858	const body_len = sema.code.extra[extra_index];
16754	16859	extra_index += 1;
16755		const align_tv = try sema.resolveInstConst(block, align_src, align_ref);
16756		break :blk align_tv.val;
16757		} else Value.@"null";
	16860	const body = sema.code.extra[extra_index..][0..body_len];
	16861	extra_index += body.len;
16758	16862
16759		const ret_ty_body = sema.code.extra[extra_index..][0..extra.data.ret_body_len];
16760		extra_index += ret_ty_body.len;
	16863	const val = try sema.resolveGenericBody(block, ret_src, body, inst, Type.type);
	16864	var buffer: Value.ToTypeBuffer = undefined;
	16865	const ty = try val.toType(&buffer).copy(sema.arena);
	16866	break :blk ty;
	16867	} else if (extra.data.bits.has_ret_ty_ref) blk: {
	16868	const ret_ty_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
	16869	extra_index += 1;
	16870	const ret_ty_tv = sema.resolveInstConst(block, ret_src, ret_ty_ref) catch \|err\| switch (err) {
	16871	error.GenericPoison => {
	16872	break :blk Type.initTag(.generic_poison);
	16873	},
	16874	else => \|e\| return e,
	16875	};
	16876	var buffer: Value.ToTypeBuffer = undefined;
	16877	const ty = try ret_ty_tv.val.toType(&buffer).copy(sema.arena);
	16878	break :blk ty;
	16879	} else Type.void;
16761	16880
16762	16881	var src_locs: Zir.Inst.Func.SrcLocs = undefined;
16763	16882	const has_body = extra.data.body_len != 0;
...	...	@@ -16774,9 +16893,11 @@ fn zirFuncExtended(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileErro
16774	16893	block,
16775	16894	inst_data.src_node,
16776	16895	inst,
16777		ret_ty_body,
	16896	@"align",
	16897	@"addrspace",
	16898	@"linksection",
16778	16899	cc,
16779		align_val,
	16900	ret_ty,
16780	16901	is_var_args,
16781	16902	is_inferred_error,
16782	16903	is_extern,

src/Zir.zig+209-53

...	...	@@ -74,7 +74,7 @@ pub fn extraData(code: Zir, comptime T: type, index: usize) struct { data: T, en
74	74	Inst.Call.Flags => @bitCast(Inst.Call.Flags, code.extra[i]),
75	75	Inst.BuiltinCall.Flags => @bitCast(Inst.BuiltinCall.Flags, code.extra[i]),
76	76	Inst.SwitchBlock.Bits => @bitCast(Inst.SwitchBlock.Bits, code.extra[i]),
77		Inst.ExtendedFunc.Bits => @bitCast(Inst.ExtendedFunc.Bits, code.extra[i]),
	77	Inst.FuncFancy.Bits => @bitCast(Inst.FuncFancy.Bits, code.extra[i]),
78	78	else => @compileError("bad field type"),
79	79	};
80	80	i += 1;
...	...	@@ -424,8 +424,8 @@ pub const Inst = struct {
424	424	func_inferred,
425	425	/// Represents a function declaration or function prototype, depending on
426	426	/// whether body_len is 0.
427		/// Uses the `pl_node` union field. `payload_index` points to a `ExtendedFunc`.
428		func_extended,
	427	/// Uses the `pl_node` union field. `payload_index` points to a `FuncFancy`.
	428	func_fancy,
429	429	/// Implements the `@import` builtin.
430	430	/// Uses the `str_tok` field.
431	431	import,
...	...	@@ -1070,7 +1070,7 @@ pub const Inst = struct {
1070	1070	.field_val_named,
1071	1071	.func,
1072	1072	.func_inferred,
1073		.func_extended,
	1073	.func_fancy,
1074	1074	.has_decl,
1075	1075	.int,
1076	1076	.int_big,
...	...	@@ -1356,7 +1356,7 @@ pub const Inst = struct {
1356	1356	.field_val_named,
1357	1357	.func,
1358	1358	.func_inferred,
1359		.func_extended,
	1359	.func_fancy,
1360	1360	.has_decl,
1361	1361	.int,
1362	1362	.int_big,
...	...	@@ -1611,7 +1611,7 @@ pub const Inst = struct {
1611	1611	.field_call_bind = .pl_node,
1612	1612	.func = .pl_node,
1613	1613	.func_inferred = .pl_node,
1614		.func_extended = .pl_node,
	1614	.func_fancy = .pl_node,
1615	1615	.import = .str_tok,
1616	1616	.int = .int,
1617	1617	.int_big = .str,
...	...	@@ -2620,29 +2620,100 @@ pub const Inst = struct {
2620	2620	};
2621	2621
2622	2622	/// Trailing:
2623		/// 0. lib_name: u32, // null terminated string index, if has_lib_name is set
2624		/// 1. cc: Ref, // if has_cc is set
2625		/// 2. align: Ref, // if has_align is set
2626		/// 3. return_type: Index // for each ret_body_len
2627		/// 4. body: Index // for each body_len
2628		/// 5. src_locs: Func.SrcLocs // if body_len != 0
2629		pub const ExtendedFunc = struct {
	2623	/// if (ret_body_len == 1) {
	2624	/// 0. return_type: Ref
	2625	/// }
	2626	/// if (ret_body_len > 1) {
	2627	/// 1. return_type: Index // for each ret_body_len
	2628	/// }
	2629	/// 2. body: Index // for each body_len
	2630	/// 3. src_locs: SrcLocs // if body_len != 0
	2631	pub const Func = struct {
2630	2632	/// If this is 0 it means a void return type.
	2633	/// If this is 1 it means return_type is a simple Ref
2631	2634	ret_body_len: u32,
2632	2635	/// Points to the block that contains the param instructions for this function.
2633	2636	param_block: Index,
2634	2637	body_len: u32,
	2638
	2639	pub const SrcLocs = struct {
	2640	/// Line index in the source file relative to the parent decl.
	2641	lbrace_line: u32,
	2642	/// Line index in the source file relative to the parent decl.
	2643	rbrace_line: u32,
	2644	/// lbrace_column is least significant bits u16
	2645	/// rbrace_column is most significant bits u16
	2646	columns: u32,
	2647	};
	2648	};
	2649
	2650	/// Trailing:
	2651	/// 0. lib_name: u32, // null terminated string index, if has_lib_name is set
	2652	/// if (has_align_ref and !has_align_body) {
	2653	/// 1. align: Ref,
	2654	/// }
	2655	/// if (has_align_body) {
	2656	/// 2. align_body_len: u32
	2657	/// 3. align_body: u32 // for each align_body_len
	2658	/// }
	2659	/// if (has_addrspace_ref and !has_addrspace_body) {
	2660	/// 4. addrspace: Ref,
	2661	/// }
	2662	/// if (has_addrspace_body) {
	2663	/// 5. addrspace_body_len: u32
	2664	/// 6. addrspace_body: u32 // for each addrspace_body_len
	2665	/// }
	2666	/// if (has_section_ref and !has_section_body) {
	2667	/// 7. section: Ref,
	2668	/// }
	2669	/// if (has_section_body) {
	2670	/// 8. section_body_len: u32
	2671	/// 9. section_body: u32 // for each section_body_len
	2672	/// }
	2673	/// if (has_cc_ref and !has_cc_body) {
	2674	/// 10. cc: Ref,
	2675	/// }
	2676	/// if (has_cc_body) {
	2677	/// 11. cc_body_len: u32
	2678	/// 12. cc_body: u32 // for each cc_body_len
	2679	/// }
	2680	/// if (has_ret_ty_ref and !has_ret_ty_body) {
	2681	/// 13. ret_ty: Ref,
	2682	/// }
	2683	/// if (has_ret_ty_body) {
	2684	/// 14. ret_ty_body_len: u32
	2685	/// 15. ret_ty_body: u32 // for each ret_ty_body_len
	2686	/// }
	2687	/// 16. body: Index // for each body_len
	2688	/// 17. src_locs: Func.SrcLocs // if body_len != 0
	2689	pub const FuncFancy = struct {
	2690	/// Points to the block that contains the param instructions for this function.
	2691	param_block: Index,
	2692	body_len: u32,
2635	2693	bits: Bits,
2636	2694
	2695	/// If both has_cc_ref and has_cc_body are false, it means auto calling convention.
	2696	/// If both has_align_ref and has_align_body are false, it means default alignment.
	2697	/// If both has_ret_ty_ref and has_ret_ty_body are false, it means void return type.
	2698	/// If both has_section_ref and has_section_body are false, it means default section.
	2699	/// If both has_addrspace_ref and has_addrspace_body are false, it means default addrspace.
2637	2700	pub const Bits = packed struct {
2638	2701	is_var_args: bool,
2639	2702	is_inferred_error: bool,
2640		has_lib_name: bool,
2641		has_cc: bool,
2642		has_align: bool,
2643	2703	is_test: bool,
2644	2704	is_extern: bool,
2645		_: u25 = undefined,
	2705	has_align_ref: bool,
	2706	has_align_body: bool,
	2707	has_addrspace_ref: bool,
	2708	has_addrspace_body: bool,
	2709	has_section_ref: bool,
	2710	has_section_body: bool,
	2711	has_cc_ref: bool,
	2712	has_cc_body: bool,
	2713	has_ret_ty_ref: bool,
	2714	has_ret_ty_body: bool,
	2715	has_lib_name: bool,
	2716	_: u17 = undefined,
2646	2717	};
2647	2718	};
2648	2719
...	...	@@ -2664,28 +2735,6 @@ pub const Inst = struct {
2664	2735	};
2665	2736	};
2666	2737
2667		/// Trailing:
2668		/// 0. return_type: Index // for each ret_body_len
2669		/// 1. body: Index // for each body_len
2670		/// 2. src_locs: SrcLocs // if body_len != 0
2671		pub const Func = struct {
2672		/// If this is 0 it means a void return type.
2673		ret_body_len: u32,
2674		/// Points to the block that contains the param instructions for this function.
2675		param_block: Index,
2676		body_len: u32,
2677
2678		pub const SrcLocs = struct {
2679		/// Line index in the source file relative to the parent decl.
2680		lbrace_line: u32,
2681		/// Line index in the source file relative to the parent decl.
2682		rbrace_line: u32,
2683		/// lbrace_column is least significant bits u16
2684		/// rbrace_column is most significant bits u16
2685		columns: u32,
2686		};
2687		};
2688
2689	2738	/// This data is stored inside extra, with trailing operands according to `operands_len`.
2690	2739	/// Each operand is a `Ref`.
2691	2740	pub const MultiOp = struct {
...	...	@@ -3487,7 +3536,7 @@ pub fn declIterator(zir: Zir, decl_inst: u32) DeclIterator {
3487	3536	switch (tags[decl_inst]) {
3488	3537	// Functions are allowed and yield no iterations.
3489	3538	// There is one case matching this in the extended instruction set below.
3490		.func, .func_inferred, .func_extended => return declIteratorInner(zir, 0, 0),
	3539	.func, .func_inferred, .func_fancy => return declIteratorInner(zir, 0, 0),
3491	3540
3492	3541	.extended => {
3493	3542	const extended = datas[decl_inst].extended;
...	...	@@ -3593,18 +3642,77 @@ fn findDeclsInner(
3593	3642
3594	3643	const inst_data = datas[inst].pl_node;
3595	3644	const extra = zir.extraData(Inst.Func, inst_data.payload_index);
3596		const body = zir.extra[extra.end..][0..extra.data.body_len];
	3645	var extra_index: usize = extra.end;
	3646	switch (extra.data.ret_body_len) {
	3647	0 => {},
	3648	1 => extra_index += 1,
	3649	else => {
	3650	const body = zir.extra[extra_index..][0..extra.data.ret_body_len];
	3651	extra_index += body.len;
	3652	try zir.findDeclsBody(list, body);
	3653	},
	3654	}
	3655	const body = zir.extra[extra_index..][0..extra.data.body_len];
3597	3656	return zir.findDeclsBody(list, body);
3598	3657	},
3599		.func_extended => {
	3658	.func_fancy => {
3600	3659	try list.append(inst);
3601	3660
3602	3661	const inst_data = datas[inst].pl_node;
3603		const extra = zir.extraData(Inst.ExtendedFunc, inst_data.payload_index);
	3662	const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index);
3604	3663	var extra_index: usize = extra.end;
3605	3664	extra_index += @boolToInt(extra.data.bits.has_lib_name);
3606		extra_index += @boolToInt(extra.data.bits.has_cc);
3607		extra_index += @boolToInt(extra.data.bits.has_align);
	3665
	3666	if (extra.data.bits.has_align_body) {
	3667	const body_len = zir.extra[extra_index];
	3668	extra_index += 1;
	3669	const body = zir.extra[extra_index..][0..body_len];
	3670	try zir.findDeclsBody(list, body);
	3671	extra_index += body.len;
	3672	} else if (extra.data.bits.has_align_ref) {
	3673	extra_index += 1;
	3674	}
	3675
	3676	if (extra.data.bits.has_addrspace_body) {
	3677	const body_len = zir.extra[extra_index];
	3678	extra_index += 1;
	3679	const body = zir.extra[extra_index..][0..body_len];
	3680	try zir.findDeclsBody(list, body);
	3681	extra_index += body.len;
	3682	} else if (extra.data.bits.has_addrspace_ref) {
	3683	extra_index += 1;
	3684	}
	3685
	3686	if (extra.data.bits.has_section_body) {
	3687	const body_len = zir.extra[extra_index];
	3688	extra_index += 1;
	3689	const body = zir.extra[extra_index..][0..body_len];
	3690	try zir.findDeclsBody(list, body);
	3691	extra_index += body.len;
	3692	} else if (extra.data.bits.has_section_ref) {
	3693	extra_index += 1;
	3694	}
	3695
	3696	if (extra.data.bits.has_cc_body) {
	3697	const body_len = zir.extra[extra_index];
	3698	extra_index += 1;
	3699	const body = zir.extra[extra_index..][0..body_len];
	3700	try zir.findDeclsBody(list, body);
	3701	extra_index += body.len;
	3702	} else if (extra.data.bits.has_cc_ref) {
	3703	extra_index += 1;
	3704	}
	3705
	3706	if (extra.data.bits.has_ret_ty_body) {
	3707	const body_len = zir.extra[extra_index];
	3708	extra_index += 1;
	3709	const body = zir.extra[extra_index..][0..body_len];
	3710	try zir.findDeclsBody(list, body);
	3711	extra_index += body.len;
	3712	} else if (extra.data.bits.has_ret_ty_ref) {
	3713	extra_index += 1;
	3714	}
	3715
3608	3716	const body = zir.extra[extra_index..][0..extra.data.body_len];
3609	3717	return zir.findDeclsBody(list, body);
3610	3718	},
...	...	@@ -3729,6 +3837,7 @@ pub const FnInfo = struct {
3729	3837	param_body_inst: Inst.Index,
3730	3838	ret_ty_body: []const Inst.Index,
3731	3839	body: []const Inst.Index,
	3840	ret_ty_ref: Zir.Inst.Ref,
3732	3841	total_params_len: u32,
3733	3842	};
3734	3843
...	...	@@ -3738,38 +3847,84 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
3738	3847	const info: struct {
3739	3848	param_block: Inst.Index,
3740	3849	body: []const Inst.Index,
	3850	ret_ty_ref: Inst.Ref,
3741	3851	ret_ty_body: []const Inst.Index,
3742	3852	} = switch (tags[fn_inst]) {
3743	3853	.func, .func_inferred => blk: {
3744	3854	const inst_data = datas[fn_inst].pl_node;
3745	3855	const extra = zir.extraData(Inst.Func, inst_data.payload_index);
	3856
3746	3857	var extra_index: usize = extra.end;
	3858	var ret_ty_ref: Inst.Ref = .none;
	3859	var ret_ty_body: []const Inst.Index = &.{};
3747	3860
3748		const ret_ty_body = zir.extra[extra_index..][0..extra.data.ret_body_len];
3749		extra_index += ret_ty_body.len;
	3861	switch (extra.data.ret_body_len) {
	3862	0 => {
	3863	ret_ty_ref = .void_type;
	3864	},
	3865	1 => {
	3866	ret_ty_ref = @intToEnum(Inst.Ref, zir.extra[extra_index]);
	3867	extra_index += 1;
	3868	},
	3869	else => {
	3870	ret_ty_body = zir.extra[extra_index..][0..extra.data.ret_body_len];
	3871	extra_index += ret_ty_body.len;
	3872	},
	3873	}
3750	3874
3751	3875	const body = zir.extra[extra_index..][0..extra.data.body_len];
3752	3876	extra_index += body.len;
3753	3877
3754	3878	break :blk .{
3755	3879	.param_block = extra.data.param_block,
	3880	.ret_ty_ref = ret_ty_ref,
3756	3881	.ret_ty_body = ret_ty_body,
3757	3882	.body = body,
3758	3883	};
3759	3884	},
3760		.func_extended => blk: {
	3885	.func_fancy => blk: {
3761	3886	const inst_data = datas[fn_inst].pl_node;
3762		const extra = zir.extraData(Inst.ExtendedFunc, inst_data.payload_index);
	3887	const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index);
	3888
3763	3889	var extra_index: usize = extra.end;
	3890	var ret_ty_ref: Inst.Ref = .void_type;
	3891	var ret_ty_body: []const Inst.Index = &.{};
	3892
3764	3893	extra_index += @boolToInt(extra.data.bits.has_lib_name);
3765		extra_index += @boolToInt(extra.data.bits.has_cc);
3766		extra_index += @boolToInt(extra.data.bits.has_align);
3767		const ret_ty_body = zir.extra[extra_index..][0..extra.data.ret_body_len];
3768		extra_index += ret_ty_body.len;
	3894	if (extra.data.bits.has_align_body) {
	3895	extra_index += zir.extra[extra_index] + 1;
	3896	} else if (extra.data.bits.has_align_ref) {
	3897	extra_index += 1;
	3898	}
	3899	if (extra.data.bits.has_addrspace_body) {
	3900	extra_index += zir.extra[extra_index] + 1;
	3901	} else if (extra.data.bits.has_addrspace_ref) {
	3902	extra_index += 1;
	3903	}
	3904	if (extra.data.bits.has_section_body) {
	3905	extra_index += zir.extra[extra_index] + 1;
	3906	} else if (extra.data.bits.has_section_ref) {
	3907	extra_index += 1;
	3908	}
	3909	if (extra.data.bits.has_cc_body) {
	3910	extra_index += zir.extra[extra_index] + 1;
	3911	} else if (extra.data.bits.has_cc_ref) {
	3912	extra_index += 1;
	3913	}
	3914	if (extra.data.bits.has_ret_ty_body) {
	3915	const body_len = zir.extra[extra_index];
	3916	extra_index += 1;
	3917	ret_ty_body = zir.extra[extra_index..][0..body_len];
	3918	extra_index += ret_ty_body.len;
	3919	} else if (extra.data.bits.has_ret_ty_ref) {
	3920	ret_ty_ref = @intToEnum(Inst.Ref, zir.extra[extra_index]);
	3921	extra_index += 1;
	3922	}
3769	3923	const body = zir.extra[extra_index..][0..extra.data.body_len];
3770	3924	extra_index += body.len;
3771	3925	break :blk .{
3772	3926	.param_block = extra.data.param_block,
	3927	.ret_ty_ref = ret_ty_ref,
3773	3928	.ret_ty_body = ret_ty_body,
3774	3929	.body = body,
3775	3930	};
...	...	@@ -3792,6 +3947,7 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
3792	3947	.param_body = param_body,
3793	3948	.param_body_inst = info.param_block,
3794	3949	.ret_ty_body = info.ret_ty_body,
	3950	.ret_ty_ref = info.ret_ty_ref,
3795	3951	.body = info.body,
3796	3952	.total_params_len = total_params_len,
3797	3953	};

src/print_zir.zig+132-37

...	...	@@ -429,7 +429,7 @@ const Writer = struct {
429	429
430	430	.func => try self.writeFunc(stream, inst, false),
431	431	.func_inferred => try self.writeFunc(stream, inst, true),
432		.func_extended => try self.writeFuncExtended(stream, inst),
	432	.func_fancy => try self.writeFuncFancy(stream, inst),
433	433
434	434	.@"unreachable" => try self.writeUnreachable(stream, inst),
435	435
...	...	@@ -1912,10 +1912,24 @@ const Writer = struct {
1912	1912	const inst_data = self.code.instructions.items(.data)[inst].pl_node;
1913	1913	const src = inst_data.src();
1914	1914	const extra = self.code.extraData(Zir.Inst.Func, inst_data.payload_index);
	1915
1915	1916	var extra_index = extra.end;
	1917	var ret_ty_ref: Zir.Inst.Ref = .none;
	1918	var ret_ty_body: []const Zir.Inst.Index = &.{};
1916	1919
1917		const ret_ty_body = self.code.extra[extra_index..][0..extra.data.ret_body_len];
1918		extra_index += ret_ty_body.len;
	1920	switch (extra.data.ret_body_len) {
	1921	0 => {
	1922	ret_ty_ref = .void_type;
	1923	},
	1924	1 => {
	1925	ret_ty_ref = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
	1926	extra_index += 1;
	1927	},
	1928	else => {
	1929	ret_ty_body = self.code.extra[extra_index..][0..extra.data.ret_body_len];
	1930	extra_index += ret_ty_body.len;
	1931	},
	1932	}
1919	1933
1920	1934	const body = self.code.extra[extra_index..][0..extra.data.body_len];
1921	1935	extra_index += body.len;
...	...	@@ -1926,43 +1940,96 @@ const Writer = struct {
1926	1940	}
1927	1941	return self.writeFuncCommon(
1928	1942	stream,
1929		ret_ty_body,
1930	1943	inferred_error_set,
1931	1944	false,
1932	1945	false,
	1946
1933	1947	.none,
	1948	&.{},
1934	1949	.none,
	1950	&.{},
	1951	.none,
	1952	&.{},
	1953	.none,
	1954	&.{},
	1955	ret_ty_ref,
	1956	ret_ty_body,
	1957
1935	1958	body,
1936	1959	src,
1937	1960	src_locs,
1938	1961	);
1939	1962	}
1940	1963
1941		fn writeFuncExtended(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
	1964	fn writeFuncFancy(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
1942	1965	const inst_data = self.code.instructions.items(.data)[inst].pl_node;
1943		const extra = self.code.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
	1966	const extra = self.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);
1944	1967	const src = inst_data.src();
1945	1968
1946	1969	var extra_index: usize = extra.end;
	1970	var align_ref: Zir.Inst.Ref = .none;
	1971	var align_body: []const Zir.Inst.Index = &.{};
	1972	var addrspace_ref: Zir.Inst.Ref = .none;
	1973	var addrspace_body: []const Zir.Inst.Index = &.{};
	1974	var section_ref: Zir.Inst.Ref = .none;
	1975	var section_body: []const Zir.Inst.Index = &.{};
	1976	var cc_ref: Zir.Inst.Ref = .none;
	1977	var cc_body: []const Zir.Inst.Index = &.{};
	1978	var ret_ty_ref: Zir.Inst.Ref = .none;
	1979	var ret_ty_body: []const Zir.Inst.Index = &.{};
	1980
1947	1981	if (extra.data.bits.has_lib_name) {
1948	1982	const lib_name = self.code.nullTerminatedString(self.code.extra[extra_index]);
1949	1983	extra_index += 1;
1950	1984	try stream.print("lib_name=\"{}\", ", .{std.zig.fmtEscapes(lib_name)});
1951	1985	}
1952	1986	try self.writeFlag(stream, "test, ", extra.data.bits.is_test);
1953		const cc: Zir.Inst.Ref = if (!extra.data.bits.has_cc) .none else blk: {
1954		const cc = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
	1987
	1988	if (extra.data.bits.has_align_body) {
	1989	const body_len = self.code.extra[extra_index];
1955	1990	extra_index += 1;
1956		break :blk cc;
1957		};
1958		const align_inst: Zir.Inst.Ref = if (!extra.data.bits.has_align) .none else blk: {
1959		const align_inst = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
	1991	align_body = self.code.extra[extra_index..][0..body_len];
	1992	extra_index += align_body.len;
	1993	} else if (extra.data.bits.has_align_ref) {
	1994	align_ref = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
1960	1995	extra_index += 1;
1961		break :blk align_inst;
1962		};
1963
1964		const ret_ty_body = self.code.extra[extra_index..][0..extra.data.ret_body_len];
1965		extra_index += ret_ty_body.len;
	1996	}
	1997	if (extra.data.bits.has_addrspace_body) {
	1998	const body_len = self.code.extra[extra_index];
	1999	extra_index += 1;
	2000	addrspace_body = self.code.extra[extra_index..][0..body_len];
	2001	extra_index += addrspace_body.len;
	2002	} else if (extra.data.bits.has_addrspace_ref) {
	2003	addrspace_ref = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
	2004	extra_index += 1;
	2005	}
	2006	if (extra.data.bits.has_section_body) {
	2007	const body_len = self.code.extra[extra_index];
	2008	extra_index += 1;
	2009	section_body = self.code.extra[extra_index..][0..body_len];
	2010	extra_index += section_body.len;
	2011	} else if (extra.data.bits.has_section_ref) {
	2012	section_ref = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
	2013	extra_index += 1;
	2014	}
	2015	if (extra.data.bits.has_cc_body) {
	2016	const body_len = self.code.extra[extra_index];
	2017	extra_index += 1;
	2018	cc_body = self.code.extra[extra_index..][0..body_len];
	2019	extra_index += cc_body.len;
	2020	} else if (extra.data.bits.has_cc_ref) {
	2021	cc_ref = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
	2022	extra_index += 1;
	2023	}
	2024	if (extra.data.bits.has_ret_ty_body) {
	2025	const body_len = self.code.extra[extra_index];
	2026	extra_index += 1;
	2027	ret_ty_body = self.code.extra[extra_index..][0..body_len];
	2028	extra_index += ret_ty_body.len;
	2029	} else if (extra.data.bits.has_ret_ty_ref) {
	2030	ret_ty_ref = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
	2031	extra_index += 1;
	2032	}
1966	2033
1967	2034	const body = self.code.extra[extra_index..][0..extra.data.body_len];
1968	2035	extra_index += body.len;
...	...	@@ -1973,12 +2040,19 @@ const Writer = struct {
1973	2040	}
1974	2041	return self.writeFuncCommon(
1975	2042	stream,
1976		ret_ty_body,
1977	2043	extra.data.bits.is_inferred_error,
1978	2044	extra.data.bits.is_var_args,
1979	2045	extra.data.bits.is_extern,
1980		cc,
1981		align_inst,
	2046	align_ref,
	2047	align_body,
	2048	addrspace_ref,
	2049	addrspace_body,
	2050	section_ref,
	2051	section_body,
	2052	cc_ref,
	2053	cc_body,
	2054	ret_ty_ref,
	2055	ret_ty_body,
1982	2056	body,
1983	2057	src,
1984	2058	src_locs,
...	...	@@ -2122,30 +2196,33 @@ const Writer = struct {
2122	2196	fn writeFuncCommon(
2123	2197	self: *Writer,
2124	2198	stream: anytype,
2125		ret_ty_body: []const Zir.Inst.Index,
2126	2199	inferred_error_set: bool,
2127	2200	var_args: bool,
2128	2201	is_extern: bool,
2129		cc: Zir.Inst.Ref,
2130		align_inst: Zir.Inst.Ref,
	2202	align_ref: Zir.Inst.Ref,
	2203	align_body: []const Zir.Inst.Index,
	2204	addrspace_ref: Zir.Inst.Ref,
	2205	addrspace_body: []const Zir.Inst.Index,
	2206	section_ref: Zir.Inst.Ref,
	2207	section_body: []const Zir.Inst.Index,
	2208	cc_ref: Zir.Inst.Ref,
	2209	cc_body: []const Zir.Inst.Index,
	2210	ret_ty_ref: Zir.Inst.Ref,
	2211	ret_ty_body: []const Zir.Inst.Index,
2131	2212	body: []const Zir.Inst.Index,
2132	2213	src: LazySrcLoc,
2133	2214	src_locs: Zir.Inst.Func.SrcLocs,
2134	2215	) !void {
2135		if (ret_ty_body.len == 0) {
2136		try stream.writeAll("ret_ty=void");
2137		} else {
2138		try stream.writeAll("ret_ty=");
2139		try self.writeBracedBody(stream, ret_ty_body);
2140		}
2141
2142		try self.writeOptionalInstRef(stream, ", cc=", cc);
2143		try self.writeOptionalInstRef(stream, ", align=", align_inst);
2144		try self.writeFlag(stream, ", vargs", var_args);
2145		try self.writeFlag(stream, ", extern", is_extern);
2146		try self.writeFlag(stream, ", inferror", inferred_error_set);
2147
2148		try stream.writeAll(", body=");
	2216	try self.writeOptionalInstRefOrBody(stream, "align=", align_ref, align_body);
	2217	try self.writeOptionalInstRefOrBody(stream, "addrspace=", addrspace_ref, addrspace_body);
	2218	try self.writeOptionalInstRefOrBody(stream, "section=", section_ref, section_body);
	2219	try self.writeOptionalInstRefOrBody(stream, "cc=", cc_ref, cc_body);
	2220	try self.writeOptionalInstRefOrBody(stream, "ret_ty=", ret_ty_ref, ret_ty_body);
	2221	try self.writeFlag(stream, "vargs, ", var_args);
	2222	try self.writeFlag(stream, "extern, ", is_extern);
	2223	try self.writeFlag(stream, "inferror, ", inferred_error_set);
	2224
	2225	try stream.writeAll("body=");
2149	2226	try self.writeBracedBody(stream, body);
2150	2227	try stream.writeAll(") ");
2151	2228	if (body.len != 0) {
...	...	@@ -2195,6 +2272,24 @@ const Writer = struct {
2195	2272	try self.writeInstRef(stream, inst);
2196	2273	}
2197	2274
	2275	fn writeOptionalInstRefOrBody(
	2276	self: *Writer,
	2277	stream: anytype,
	2278	prefix: []const u8,
	2279	ref: Zir.Inst.Ref,
	2280	body: []const Zir.Inst.Index,
	2281	) !void {
	2282	if (body.len != 0) {
	2283	try stream.writeAll(prefix);
	2284	try self.writeBracedBody(stream, body);
	2285	try stream.writeAll(", ");
	2286	} else if (ref != .none) {
	2287	try stream.writeAll(prefix);
	2288	try self.writeInstRef(stream, ref);
	2289	try stream.writeAll(", ");
	2290	}
	2291	}
	2292
2198	2293	fn writeFlag(
2199	2294	self: *Writer,
2200	2295	stream: anytype,