Commit 609b84611dcde382af5d9fbc2345ede468d31a6f | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-08-03 17:29:59-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-08-03 17:29:59-07:00
log	609b84611dcde382af5d9fbc2345ede468d31a6f
tree	9dab23600c4fd136b10ccd65eb3d908dfe6bb206
parent	1472dc3ddb6fd7932ff530e7a2fd3f0185c7353f

stage2: rework runtime, comptime, inline function calls

 * ZIR function instructions encode the index of the block that
   contains the function instruction. This allows Zig to later scan the
   block and find the parameter instructions, which is needed for
   semantically analyzing function bodies.

 * Runtime function calls insert AIR arg instructions and then inserts
   Sema inst_map entries mapping the ZIR param instructions to them.

 * comptime/inline function call inserts Sema inst_map entries mapping
   the ZIR param instructions to the AIR callsite arguments.

With this commit we are back to the tests passing.

5 files changed, 117 insertions(+), 78 deletions(-)

BRANCH_TODO
src

BRANCH_TODO-2

...	...	@@ -1,6 +1,4 @@
1	1	* update arg instructions:
2		- runtime function call inserts AIR arg instructions and Sema map items for them
3		- comptime/inline function call inserts Sema map items for the args
4	2	- generic instantiation inserts Sema map items for the comptime args only, re-runs the
5	3	Decl ZIR to get the new Fn.
6	4	* generic function call where it makes a new function

src/AstGen.zig+7

...	...	@@ -1125,6 +1125,7 @@ fn fnProtoExpr(
1125	1125
1126	1126	const result = try gz.addFunc(.{
1127	1127	.src_node = fn_proto.ast.proto_node,
	1128	.param_block = 0,
1128	1129	.ret_ty = return_type_inst,
1129	1130	.body = &[0]Zir.Inst.Index{},
1130	1131	.cc = cc,
...	...	@@ -3035,6 +3036,7 @@ fn fnDecl(
3035	3036	break :func try decl_gz.addFunc(.{
3036	3037	.src_node = decl_node,
3037	3038	.ret_ty = return_type_inst,
	3039	.param_block = block_inst,
3038	3040	.body = &[0]Zir.Inst.Index{},
3039	3041	.cc = cc,
3040	3042	.align_inst = .none, // passed in the per-decl data
...	...	@@ -3071,6 +3073,7 @@ fn fnDecl(
3071	3073
3072	3074	break :func try decl_gz.addFunc(.{
3073	3075	.src_node = decl_node,
	3076	.param_block = block_inst,
3074	3077	.ret_ty = return_type_inst,
3075	3078	.body = fn_gz.instructions.items,
3076	3079	.cc = cc,
...	...	@@ -3415,6 +3418,7 @@ fn testDecl(
3415	3418
3416	3419	const func_inst = try decl_block.addFunc(.{
3417	3420	.src_node = node,
	3421	.param_block = block_inst,
3418	3422	.ret_ty = .void_type,
3419	3423	.body = fn_block.instructions.items,
3420	3424	.cc = .none,
...	...	@@ -9111,6 +9115,7 @@ const GenZir = struct {
9111	9115	fn addFunc(gz: *GenZir, args: struct {
9112	9116	src_node: ast.Node.Index,
9113	9117	body: []const Zir.Inst.Index,
	9118	param_block: Zir.Inst.Index,
9114	9119	ret_ty: Zir.Inst.Ref,
9115	9120	cc: Zir.Inst.Ref,
9116	9121	align_inst: Zir.Inst.Ref,
...	...	@@ -9170,6 +9175,7 @@ const GenZir = struct {
9170	9175	);
9171	9176	const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.ExtendedFunc{
9172	9177	.src_node = gz.nodeIndexToRelative(args.src_node),
	9178	.param_block = args.param_block,
9173	9179	.return_type = args.ret_ty,
9174	9180	.body_len = @intCast(u32, args.body.len),
9175	9181	});
...	...	@@ -9212,6 +9218,7 @@ const GenZir = struct {
9212	9218	);
9213	9219
9214	9220	const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.Func{
	9221	.param_block = args.param_block,
9215	9222	.return_type = args.ret_ty,
9216	9223	.body_len = @intCast(u32, args.body.len),
9217	9224	});

src/Module.zig+38-19

...	...	@@ -2899,7 +2899,6 @@ pub fn semaFile(mod: Module, file: Scope.File) SemaError!void {
2899	2899	.namespace = &struct_obj.namespace,
2900	2900	.func = null,
2901	2901	.owner_func = null,
2902		.param_inst_list = &.{},
2903	2902	};
2904	2903	defer sema.deinit();
2905	2904	var block_scope: Scope.Block = .{
...	...	@@ -2954,7 +2953,6 @@ fn semaDecl(mod: Module, decl: Decl) !bool {
2954	2953	.namespace = decl.namespace,
2955	2954	.func = null,
2956	2955	.owner_func = null,
2957		.param_inst_list = &.{},
2958	2956	};
2959	2957	defer sema.deinit();
2960	2958
...	...	@@ -3625,8 +3623,6 @@ pub fn analyzeFnBody(mod: Module, decl: Decl, func: *Fn) SemaError!Air {
3625	3623	defer decl.value_arena.?.* = arena.state;
3626	3624
3627	3625	const fn_ty = decl.ty;
3628		const param_inst_list = try gpa.alloc(Air.Inst.Ref, fn_ty.fnParamLen());
3629		defer gpa.free(param_inst_list);
3630	3626
3631	3627	var sema: Sema = .{
3632	3628	.mod = mod,
...	...	@@ -3637,7 +3633,6 @@ pub fn analyzeFnBody(mod: Module, decl: Decl, func: *Fn) SemaError!Air {
3637	3633	.namespace = decl.namespace,
3638	3634	.func = func,
3639	3635	.owner_func = func,
3640		.param_inst_list = param_inst_list,
3641	3636	};
3642	3637	defer sema.deinit();
3643	3638
...	...	@@ -3656,29 +3651,55 @@ pub fn analyzeFnBody(mod: Module, decl: Decl, func: *Fn) SemaError!Air {
3656	3651	};
3657	3652	defer inner_block.instructions.deinit(gpa);
3658	3653
3659		// AIR requires the arg parameters to be the first N instructions.
3660		try inner_block.instructions.ensureTotalCapacity(gpa, param_inst_list.len);
3661		for (param_inst_list) \|*param_inst, param_index\| {
	3654	const fn_info = sema.code.getFnInfo(func.zir_body_inst);
	3655	const zir_tags = sema.code.instructions.items(.tag);
	3656
	3657	// Here we are performing "runtime semantic analysis" for a function body, which means
	3658	// we must map the parameter ZIR instructions to `arg` AIR instructions.
	3659	// AIR requires the `arg` parameters to be the first N instructions.
	3660	const params_len = @intCast(u32, fn_ty.fnParamLen());
	3661	try inner_block.instructions.ensureTotalCapacity(gpa, params_len);
	3662	try sema.air_instructions.ensureUnusedCapacity(gpa, params_len * 2); // * 2 for the `addType`
	3663	try sema.inst_map.ensureUnusedCapacity(gpa, params_len);
	3664
	3665	var param_index: usize = 0;
	3666	for (fn_info.param_body) \|inst\| {
	3667	const name = switch (zir_tags[inst]) {
	3668	.param, .param_comptime => blk: {
	3669	const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
	3670	const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
	3671	break :blk extra.name;
	3672	},
	3673
	3674	.param_anytype, .param_anytype_comptime => blk: {
	3675	const str_tok = sema.code.instructions.items(.data)[inst].str_tok;
	3676	break :blk str_tok.start;
	3677	},
	3678
	3679	else => continue,
	3680	};
3662	3681	const param_type = fn_ty.fnParamType(param_index);
	3682	param_index += 1;
3663	3683	const ty_ref = try sema.addType(param_type);
3664	3684	const arg_index = @intCast(u32, sema.air_instructions.len);
3665	3685	inner_block.instructions.appendAssumeCapacity(arg_index);
3666		param_inst.* = Air.indexToRef(arg_index);
3667		try sema.air_instructions.append(gpa, .{
	3686	sema.air_instructions.appendAssumeCapacity(.{
3668	3687	.tag = .arg,
3669		.data = .{
3670		.ty_str = .{
3671		.ty = ty_ref,
3672		.str = undefined, // Set in the semantic analysis of the arg instruction.
3673		},
3674		},
	3688	.data = .{ .ty_str = .{
	3689	.ty = ty_ref,
	3690	.str = name,
	3691	} },
3675	3692	});
	3693	sema.inst_map.putAssumeCapacityNoClobber(inst, Air.indexToRef(arg_index));
3676	3694	}
3677	3695
3678	3696	func.state = .in_progress;
3679	3697	log.debug("set {s} to in_progress", .{decl.name});
3680	3698
3681		try sema.analyzeFnBody(&inner_block, func.zir_body_inst);
	3699	_ = sema.analyzeBody(&inner_block, fn_info.body) catch \|err\| switch (err) {
	3700	error.NeededSourceLocation => unreachable,
	3701	else => \|e\| return e,
	3702	};
3682	3703
3683	3704	// Copy the block into place and mark that as the main block.
3684	3705	try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len +
...	...	@@ -4330,7 +4351,6 @@ pub fn analyzeStructFields(mod: Module, struct_obj: Struct) CompileError!void
4330	4351	.namespace = &struct_obj.namespace,
4331	4352	.owner_func = null,
4332	4353	.func = null,
4333		.param_inst_list = &.{},
4334	4354	};
4335	4355	defer sema.deinit();
4336	4356
...	...	@@ -4484,7 +4504,6 @@ pub fn analyzeUnionFields(mod: Module, union_obj: Union) CompileError!void {
4484	4504	.namespace = &union_obj.namespace,
4485	4505	.owner_func = null,
4486	4506	.func = null,
4487		.param_inst_list = &.{},
4488	4507	};
4489	4508	defer sema.deinit();
4490	4509

src/Sema.zig+21-54

...	...	@@ -29,13 +29,6 @@ owner_func: ?*Module.Fn,
29	29	/// This starts out the same as `owner_func` and then diverges in the case of
30	30	/// an inline or comptime function call.
31	31	func: ?*Module.Fn,
32		/// For now, AIR requires arg instructions to be the first N instructions in the
33		/// AIR code. We store references here for the purpose of `resolveInst`.
34		/// This can get reworked with AIR memory layout changes, into simply:
35		/// > Denormalized data to make `resolveInst` faster. This is 0 if not inside a function,
36		/// > otherwise it is the number of parameters of the function.
37		/// > param_count: u32
38		param_inst_list: []const Air.Inst.Ref,
39	32	branch_quota: u32 = 1000,
40	33	branch_count: u32 = 0,
41	34	/// This field is updated when a new source location becomes active, so that
...	...	@@ -85,43 +78,10 @@ pub fn deinit(sema: *Sema) void {
85	78	sema.air_values.deinit(gpa);
86	79	sema.inst_map.deinit(gpa);
87	80	sema.decl_val_table.deinit(gpa);
	81	sema.params.deinit(gpa);
88	82	sema.* = undefined;
89	83	}
90	84
91		pub fn analyzeFnBody(
92		sema: *Sema,
93		block: *Scope.Block,
94		fn_body_inst: Zir.Inst.Index,
95		) SemaError!void {
96		const tags = sema.code.instructions.items(.tag);
97		const datas = sema.code.instructions.items(.data);
98		const body: []const Zir.Inst.Index = switch (tags[fn_body_inst]) {
99		.func, .func_inferred => blk: {
100		const inst_data = datas[fn_body_inst].pl_node;
101		const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);
102		const body = sema.code.extra[extra.end..][0..extra.data.body_len];
103		break :blk body;
104		},
105		.extended => blk: {
106		const extended = datas[fn_body_inst].extended;
107		assert(extended.opcode == .func);
108		const extra = sema.code.extraData(Zir.Inst.ExtendedFunc, extended.operand);
109		const small = @bitCast(Zir.Inst.ExtendedFunc.Small, extended.small);
110		var extra_index: usize = extra.end;
111		extra_index += @boolToInt(small.has_lib_name);
112		extra_index += @boolToInt(small.has_cc);
113		extra_index += @boolToInt(small.has_align);
114		const body = sema.code.extra[extra_index..][0..extra.data.body_len];
115		break :blk body;
116		},
117		else => unreachable,
118		};
119		_ = sema.analyzeBody(block, body) catch \|err\| switch (err) {
120		error.NeededSourceLocation => unreachable,
121		else => \|e\| return e,
122		};
123		}
124
125	85	/// Returns only the result from the body that is specified.
126	86	/// Only appropriate to call when it is determined at comptime that this body
127	87	/// has no peers.
...	...	@@ -1066,7 +1026,6 @@ fn zirEnumDecl(
1066	1026	.namespace = &enum_obj.namespace,
1067	1027	.owner_func = null,
1068	1028	.func = null,
1069		.param_inst_list = &.{},
1070	1029	.branch_quota = sema.branch_quota,
1071	1030	.branch_count = sema.branch_count,
1072	1031	};
...	...	@@ -2538,10 +2497,6 @@ fn analyzeCall(
2538	2497	sema.func = module_fn;
2539	2498	defer sema.func = parent_func;
2540	2499
2541		const parent_param_inst_list = sema.param_inst_list;
2542		sema.param_inst_list = args;
2543		defer sema.param_inst_list = parent_param_inst_list;
2544
2545	2500	const parent_next_arg_index = sema.next_arg_index;
2546	2501	sema.next_arg_index = 0;
2547	2502	defer sema.next_arg_index = parent_next_arg_index;
...	...	@@ -2565,12 +2520,23 @@ fn analyzeCall(
2565	2520	try sema.emitBackwardBranch(&child_block, call_src);
2566	2521
2567	2522	// This will have return instructions analyzed as break instructions to
2568		// the block_inst above.
2569		try sema.analyzeFnBody(&child_block, module_fn.zir_body_inst);
2570
2571		const result = try sema.analyzeBlockBody(block, call_src, &child_block, merges);
2572
2573		break :res result;
	2523	// the block_inst above. Here we are performing "comptime/inline semantic analysis"
	2524	// for a function body, which means we must map the parameter ZIR instructions to
	2525	// the AIR instructions of the callsite.
	2526	const fn_info = sema.code.getFnInfo(module_fn.zir_body_inst);
	2527	const zir_tags = sema.code.instructions.items(.tag);
	2528	var arg_i: usize = 0;
	2529	try sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, args.len));
	2530	for (fn_info.param_body) \|inst\| {
	2531	switch (zir_tags[inst]) {
	2532	.param, .param_comptime, .param_anytype, .param_anytype_comptime => {},
	2533	else => continue,
	2534	}
	2535	sema.inst_map.putAssumeCapacityNoClobber(inst, args[arg_i]);
	2536	arg_i += 1;
	2537	}
	2538	_ = try sema.analyzeBody(&child_block, fn_info.body);
	2539	break :res try sema.analyzeBlockBody(block, call_src, &child_block, merges);
2574	2540	} else if (func_ty_info.is_generic) {
2575	2541	const func_val = try sema.resolveConstValue(block, func_src, func);
2576	2542	const module_fn = func_val.castTag(.function).?.data;
...	...	@@ -2601,7 +2567,7 @@ fn analyzeCall(
2601	2567	// TODO
2602	2568
2603	2569	// Queue up a `codegen_func` work item for the new Fn, making sure it will have
2604		// `analyzeFnBody` called with the Scope which contains the comptime parameters.
	2570	// `analyzeBody` called with the ZIR parameters mapped appropriately.
2605	2571	// TODO
2606	2572
2607	2573	// Save it into the Module's generic function map.
...	...	@@ -3344,11 +3310,12 @@ fn funcCommon(
3344	3310	// `resolveSwitchItemVal` to avoid resolving the source location unless
3345	3311	// we actually need to report an error.
3346	3312	const param_src = src;
3347		param_types[i] = try sema.resolveType(block, param_src, param.ty);
	3313	param_types[i] = try sema.analyzeAsType(block, param_src, param.ty);
3348	3314	}
3349	3315	comptime_params[i] = param.is_comptime;
3350	3316	any_are_comptime = any_are_comptime or param.is_comptime;
3351	3317	}
	3318	sema.params.clearRetainingCapacity();
3352	3319
3353	3320	if (align_val.tag() != .null_value) {
3354	3321	return mod.fail(&block.base, src, "TODO implement support for function prototypes to have alignment specified", .{});

src/Zir.zig+51-3

...	...	@@ -61,7 +61,7 @@ pub const ExtraIndex = enum(u32) {
61	61	_,
62	62	};
63	63
64		pub fn getMainStruct(zir: Zir) Zir.Inst.Index {
	64	pub fn getMainStruct(zir: Zir) Inst.Index {
65	65	return zir.extra[@enumToInt(ExtraIndex.main_struct)] -
66	66	@intCast(u32, Inst.Ref.typed_value_map.len);
67	67	}
...	...	@@ -2260,6 +2260,8 @@ pub const Inst = struct {
2260	2260	pub const ExtendedFunc = struct {
2261	2261	src_node: i32,
2262	2262	return_type: Ref,
	2263	/// Points to the block that contains the param instructions for this function.
	2264	param_block: Index,
2263	2265	body_len: u32,
2264	2266
2265	2267	pub const Small = packed struct {
...	...	@@ -2297,6 +2299,8 @@ pub const Inst = struct {
2297	2299	/// 1. src_locs: SrcLocs // if body_len != 0
2298	2300	pub const Func = struct {
2299	2301	return_type: Ref,
	2302	/// Points to the block that contains the param instructions for this function.
	2303	param_block: Index,
2300	2304	body_len: u32,
2301	2305
2302	2306	pub const SrcLocs = struct {
...	...	@@ -4894,10 +4898,54 @@ fn findDeclsSwitchMulti(
4894	4898
4895	4899	fn findDeclsBody(
4896	4900	zir: Zir,
4897		list: *std.ArrayList(Zir.Inst.Index),
4898		body: []const Zir.Inst.Index,
	4901	list: *std.ArrayList(Inst.Index),
	4902	body: []const Inst.Index,
4899	4903	) Allocator.Error!void {
4900	4904	for (body) \|member\| {
4901	4905	try zir.findDeclsInner(list, member);
4902	4906	}
4903	4907	}
	4908
	4909	pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) struct {
	4910	param_body: []const Inst.Index,
	4911	body: []const Inst.Index,
	4912	} {
	4913	const tags = zir.instructions.items(.tag);
	4914	const datas = zir.instructions.items(.data);
	4915	const info: struct {
	4916	param_block: Inst.Index,
	4917	body: []const Inst.Index,
	4918	} = switch (tags[fn_inst]) {
	4919	.func, .func_inferred => blk: {
	4920	const inst_data = datas[fn_inst].pl_node;
	4921	const extra = zir.extraData(Inst.Func, inst_data.payload_index);
	4922	const body = zir.extra[extra.end..][0..extra.data.body_len];
	4923	break :blk .{
	4924	.param_block = extra.data.param_block,
	4925	.body = body,
	4926	};
	4927	},
	4928	.extended => blk: {
	4929	const extended = datas[fn_inst].extended;
	4930	assert(extended.opcode == .func);
	4931	const extra = zir.extraData(Inst.ExtendedFunc, extended.operand);
	4932	const small = @bitCast(Inst.ExtendedFunc.Small, extended.small);
	4933	var extra_index: usize = extra.end;
	4934	extra_index += @boolToInt(small.has_lib_name);
	4935	extra_index += @boolToInt(small.has_cc);
	4936	extra_index += @boolToInt(small.has_align);
	4937	const body = zir.extra[extra_index..][0..extra.data.body_len];
	4938	break :blk .{
	4939	.param_block = extra.data.param_block,
	4940	.body = body,
	4941	};
	4942	},
	4943	else => unreachable,
	4944	};
	4945	assert(tags[info.param_block] == .block or tags[info.param_block] == .block_inline);
	4946	const param_block = zir.extraData(Inst.Block, datas[info.param_block].pl_node.payload_index);
	4947	return .{
	4948	.param_body = zir.extra[param_block.end..][0..param_block.data.body_len],
	4949	.body = info.body,
	4950	};
	4951	}