Commit f1b7c76ae9c015eeadeeff6ffcdf1523afce43f5 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-09-21 17:03:38-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-06-26 15:57:07-07:00
log	f1b7c76ae9c015eeadeeff6ffcdf1523afce43f5
tree	9f18b9d6edfaf3f550236f3503b6720736888fbd
parent	a6eb83bd1b7739156ab01e3fc55588f67d924daa

LLVM: implement call_async_alloc

It's based on a runtime alloca based on the frame size. This allows us
to lower async function calls before lowering the callee, and allows
updating callees without updating the callers.

Sema: add `std.debug.Trace` integration for `unneeded`. This helps us
debug when `LazySrcLoc.unneeded` was incorrectly used.

8 files changed, 367 insertions(+), 209 deletions(-)

src
- Module.zig
- Sema.zig
- codegen
  - llvm.zig
  - llvm
    bindings.zig
- link

src/Module.zig+17-3

 @@ -2178,7 +2178,10 @@ pub const SrcLoc = struct {
     pub fn span(src_loc: SrcLoc, gpa: Allocator) !Span {
         switch (src_loc.lazy) {
-            .unneeded => unreachable,
+            .unneeded => |t| {
+                t.dump();
+                unreachable;
+            },
             .entire_file => return Span{ .start = 0, .end = 1, .main = 0 },
             .byte_abs => |byte_index| return Span{ .start = byte_index, .end = byte_index + 1, .main = byte_index },
 @@ -2905,7 +2908,7 @@ pub const LazySrcLoc = union(enum) {
     /// unreachable. If you are debugging this tag incorrectly being this value,
     /// look into using reverse-continue with a memory watchpoint to see where the
     /// value is being set to this tag.
-    unneeded,
+    unneeded: std.debug.Trace,
     /// Means the source location points to an entire file; not any particular
     /// location within the file. `file_scope` union field will be active.
     entire_file,
 @@ -3197,6 +3200,7 @@ pub const LazySrcLoc = union(enum) {
     for_capture_from_input: i32,
     pub const nodeOffset = if (TracedOffset.want_tracing) nodeOffsetDebug else nodeOffsetRelease;
+    pub const un = if (TracedOffset.want_tracing) unneededDebug else unneededRelease;
     noinline fn nodeOffsetDebug(node_offset: i32) LazySrcLoc {
         var result: LazySrcLoc = .{ .node_offset = .{ .x = node_offset } };
 @@ -3204,10 +3208,20 @@ pub const LazySrcLoc = union(enum) {
         return result;
     }
-    fn nodeOffsetRelease(node_offset: i32) LazySrcLoc {
+    noinline fn unneededDebug() LazySrcLoc {
+        var result: LazySrcLoc = .{ .unneeded = .{} };
+        result.unneeded.addAddr(@returnAddress(), "init");
+        return result;
+    }
+    inline fn nodeOffsetRelease(node_offset: i32) LazySrcLoc {
         return .{ .node_offset = .{ .x = node_offset } };
     }
+    inline fn unneededRelease() LazySrcLoc {
+        return .{ .unneeded = .{} };
+    }
     /// Upgrade to a `SrcLoc` based on the `Decl` provided.
     pub fn toSrcLoc(lazy: LazySrcLoc, decl: *Decl, mod: *Module) SrcLoc {
         return switch (lazy) {

src/Sema.zig+73-73

src/codegen/llvm.zig+270-129

...	@@ -2348,7 +2348,24 @@ pub const Object = struct {	...	@@ -2348,7 +2348,24 @@ pub const Object = struct {
2348	.Null => unreachable,	2348	.Null => unreachable,
2349	.EnumLiteral => unreachable,	2349	.EnumLiteral => unreachable,
2350		2350
2351	.Frame => @panic("TODO implement lowerDebugType for Frame types"),	2351	.Frame => {
		2352	// TODO make this more useful than just a pointer to u8
		2353	// TODO this also does not account for async functions with
		2354	// any spilled locals that are aligned to more than 16 bytes
		2355	const elem_di_ty = try o.lowerDebugType(Type.u8, .full);
		2356	const name = try o.allocTypeName(ty);
		2357	defer gpa.free(name);
		2358	const ptr_di_ty = dib.createPointerType(
		2359	elem_di_ty,
		2360	target.ptrBitWidth(),
		2361	target.ptrBitWidth() * 2, // alignment
		2362	name,
		2363	);
		2364	// The recursive call to `lowerDebugType` means we can't use `gop` anymore.
		2365	try o.di_type_map.put(gpa, ty.toIntern(), AnnotatedDITypePtr.initFull(ptr_di_ty));
		2366	return ptr_di_ty;
		2367	},
		2368
2352	.AnyFrame => @panic("TODO implement lowerDebugType for AnyFrame types"),	2369	.AnyFrame => @panic("TODO implement lowerDebugType for AnyFrame types"),
2353	}	2370	}
2354	}	2371	}
...	@@ -3045,6 +3062,17 @@ pub const Object = struct {	...	@@ -3045,6 +3062,17 @@ pub const Object = struct {
3045	}	3062	}
3046	}	3063	}
3047		3064
		3065	fn lowerAsyncFrameHeader(o: Object, ret_ty: Type) !llvm.Type {
		3066	const opaque_ptr_ty = o.context.pointerType(0);
		3067	const l = asyncFrameLayout();
		3068	var fields: [4]*llvm.Type = undefined;
		3069	fields[l.fn_ptr] = opaque_ptr_ty;
		3070	fields[l.resume_index] = try o.lowerType(Type.usize);
		3071	fields[l.awaiter] = opaque_ptr_ty;
		3072	fields[l.ret_val] = try o.lowerType(ret_ty);
		3073	return o.context.structType(&fields, fields.len, .False);
		3074	}
		3075
3048	fn lowerAsyncFrameType(	3076	fn lowerAsyncFrameType(
3049	o: *Object,	3077	o: *Object,
3050	func: *Module.Fn,	3078	func: *Module.Fn,
...	@@ -4668,6 +4696,200 @@ pub const FuncGen = struct {	...	@@ -4668,6 +4696,200 @@ pub const FuncGen = struct {
4668	try llvm_args.append(self.err_ret_trace.?);	4696	try llvm_args.append(self.err_ret_trace.?);
4669	}	4697	}
4670		4698
		4699	try addCallArgs(self, args, &llvm_args, fn_info);
		4700
		4701	const call = self.builder.buildCall(
		4702	try o.lowerType(zig_fn_ty),
		4703	llvm_fn,
		4704	llvm_args.items.ptr,
		4705	@intCast(llvm_args.items.len),
		4706	toLlvmCallConv(fn_info.cc, target),
		4707	attr,
		4708	"",
		4709	);
		4710
		4711	if (callee_ty.zigTypeTag(mod) == .Pointer) {
		4712	// Add argument attributes for function pointer calls.
		4713	var it = iterateParamTypes(o, fn_info);
		4714	it.llvm_index += @intFromBool(sret);
		4715	it.llvm_index += @intFromBool(err_return_tracing);
		4716	while (it.next()) \|lowering\| switch (lowering) {
		4717	.byval => {
		4718	const param_index = it.zig_index - 1;
		4719	const param_ty = fn_info.param_types[param_index].toType();
		4720	if (!isByRef(param_ty, mod)) {
		4721	o.addByValParamAttrs(call, param_ty, param_index, fn_info, it.llvm_index - 1);
		4722	}
		4723	},
		4724	.byref => {
		4725	const param_index = it.zig_index - 1;
		4726	const param_ty = fn_info.param_types[param_index].toType();
		4727	const param_llvm_ty = try o.lowerType(param_ty);
		4728	const alignment = param_ty.abiAlignment(mod);
		4729	o.addByRefParamAttrs(call, it.llvm_index - 1, alignment, it.byval_attr, param_llvm_ty);
		4730	},
		4731	.byref_mut => {
		4732	o.addArgAttr(call, it.llvm_index - 1, "noundef");
		4733	},
		4734	// No attributes needed for these.
		4735	.no_bits,
		4736	.abi_sized_int,
		4737	.multiple_llvm_types,
		4738	.as_u16,
		4739	.float_array,
		4740	.i32_array,
		4741	.i64_array,
		4742	=> continue,
		4743
		4744	.slice => {
		4745	assert(!it.byval_attr);
		4746	const param_ty = fn_info.param_types[it.zig_index - 1].toType();
		4747	const ptr_info = param_ty.ptrInfo(mod);
		4748	const llvm_arg_i = it.llvm_index - 2;
		4749
		4750	if (math.cast(u5, it.zig_index - 1)) \|i\| {
		4751	if (@as(u1, @truncate(fn_info.noalias_bits >> i)) != 0) {
		4752	o.addArgAttr(call, llvm_arg_i, "noalias");
		4753	}
		4754	}
		4755	if (param_ty.zigTypeTag(mod) != .Optional) {
		4756	o.addArgAttr(call, llvm_arg_i, "nonnull");
		4757	}
		4758	if (ptr_info.flags.is_const) {
		4759	o.addArgAttr(call, llvm_arg_i, "readonly");
		4760	}
		4761	const elem_align = ptr_info.flags.alignment.toByteUnitsOptional() orelse
		4762	@max(ptr_info.child.toType().abiAlignment(mod), 1);
		4763	o.addArgAttrInt(call, llvm_arg_i, "align", elem_align);
		4764	},
		4765	};
		4766	}
		4767
		4768	if (fn_info.return_type == .noreturn_type and attr != .AlwaysTail) {
		4769	return null;
		4770	}
		4771
		4772	if (self.liveness.isUnused(inst) or !return_type.hasRuntimeBitsIgnoreComptime(mod)) {
		4773	return null;
		4774	}
		4775
		4776	const llvm_ret_ty = try o.lowerType(return_type);
		4777
		4778	if (ret_ptr) \|rp\| {
		4779	call.setCallSret(llvm_ret_ty);
		4780	if (isByRef(return_type, mod)) {
		4781	return rp;
		4782	} else {
		4783	// our by-ref status disagrees with sret so we must load.
		4784	const loaded = self.builder.buildLoad(llvm_ret_ty, rp, "");
		4785	loaded.setAlignment(return_type.abiAlignment(mod));
		4786	return loaded;
		4787	}
		4788	}
		4789
		4790	const abi_ret_ty = try lowerFnRetTy(o, fn_info);
		4791
		4792	if (abi_ret_ty != llvm_ret_ty) {
		4793	// In this case the function return type is honoring the calling convention by having
		4794	// a different LLVM type than the usual one. We solve this here at the callsite
		4795	// by using our canonical type, then loading it if necessary.
		4796	const alignment = o.target_data.abiAlignmentOfType(abi_ret_ty);
		4797	const rp = self.buildAlloca(llvm_ret_ty, alignment);
		4798	const store_inst = self.builder.buildStore(call, rp);
		4799	store_inst.setAlignment(alignment);
		4800	if (isByRef(return_type, mod)) {
		4801	return rp;
		4802	} else {
		4803	const load_inst = self.builder.buildLoad(llvm_ret_ty, rp, "");
		4804	load_inst.setAlignment(alignment);
		4805	return load_inst;
		4806	}
		4807	}
		4808
		4809	if (isByRef(return_type, mod)) {
		4810	// our by-ref status disagrees with sret so we must allocate, store,
		4811	// and return the allocation pointer.
		4812	const alignment = return_type.abiAlignment(mod);
		4813	const rp = self.buildAlloca(llvm_ret_ty, alignment);
		4814	const store_inst = self.builder.buildStore(call, rp);
		4815	store_inst.setAlignment(alignment);
		4816	return rp;
		4817	} else {
		4818	return call;
		4819	}
		4820	}
		4821
		4822	fn airCallAsync(self: FuncGen, inst: Air.Inst.Index) !?llvm.Value {
		4823	_ = inst;
		4824	return self.todo("lower call_async", .{});
		4825	}
		4826
		4827	fn airCallAsyncAlloc(fg: FuncGen, inst: Air.Inst.Index) !?llvm.Value {
		4828	const o = fg.dg.object;
		4829	const mod = o.module;
		4830	const ty_pl = fg.air.instructions.items(.data)[inst].ty_pl;
		4831	const extra = fg.air.extraData(Air.AsyncCallAlloc, ty_pl.payload);
		4832	const args: []const Air.Inst.Ref = @ptrCast(fg.air.extra[extra.end..][0..extra.data.args_len]);
		4833	const callee = try fg.resolveInst(extra.data.callee);
		4834	const callee_ty = fg.typeOf(extra.data.callee);
		4835	const zig_fn_ty = switch (callee_ty.zigTypeTag(mod)) {
		4836	.Fn => callee_ty,
		4837	.Pointer => callee_ty.childType(mod),
		4838	else => unreachable,
		4839	};
		4840	const fn_info = mod.typeToFunc(zig_fn_ty).?;
		4841	// Remember that we want to lower calls to functions which have not yet
		4842	// been semantically analyzed. So we must not call lowerType on the
		4843	// frame type. Instead we runtime-call a function to learn the frame
		4844	// size of the callee, allocate that many bytes, and then pointer-cast
		4845	// it to the anytype->T header that we know based on the type alone.
		4846	const target = mod.getTarget();
		4847	const llvm_i8 = o.context.intType(8);
		4848	const frame_size = fg.genFrameSize(callee);
		4849	const frame_alloca = fg.builder.buildArrayAlloca(llvm_i8, frame_size, "");
		4850	frame_alloca.setAlignment(target.ptrBitWidth() / 4);
		4851	const frame_llvm_ty = try o.lowerAsyncFrameHeader(fn_info.return_type.toType());
		4852	const llvm_ptr_ty = fg.context.pointerType(0);
		4853	const frame_ptr = fg.builder.buildBitCast(frame_alloca, llvm_ptr_ty, "");
		4854	const l = asyncFrameLayout();
		4855	const fn_ptr_ptr = fg.builder.buildStructGEP(frame_llvm_ty, frame_ptr, l.fn_ptr, "");
		4856	_ = fg.builder.buildStore(callee, fn_ptr_ptr);
		4857
		4858	const resume_index_ptr = fg.builder.buildStructGEP(frame_llvm_ty, frame_ptr, l.resume_index, "");
		4859	const llvm_usize = o.context.intType(target.ptrBitWidth());
		4860	const zero = llvm_usize.constNull();
		4861	_ = fg.builder.buildStore(zero, resume_index_ptr);
		4862
		4863	const awaiter_ptr = fg.builder.buildStructGEP(frame_llvm_ty, frame_ptr, l.awaiter, "");
		4864	_ = fg.builder.buildStore(zero, awaiter_ptr);
		4865
		4866	var llvm_args = std.ArrayList(*llvm.Value).init(fg.gpa);
		4867	defer llvm_args.deinit();
		4868
		4869	try addCallArgs(fg, args, &llvm_args, fn_info);
		4870
		4871	_ = fg.builder.buildCall(
		4872	try o.lowerType(zig_fn_ty),
		4873	callee,
		4874	llvm_args.items.ptr,
		4875	@intCast(llvm_args.items.len),
		4876	.Fast,
		4877	.Auto,
		4878	"",
		4879	);
		4880
		4881	return frame_ptr;
		4882	}
		4883
		4884	fn addCallArgs(
		4885	self: *FuncGen,
		4886	args: []const Air.Inst.Ref,
		4887	llvm_args: std.ArrayList(llvm.Value),
		4888	fn_info: InternPool.Key.FuncType,
		4889	) !void {
		4890	const o = self.dg.object;
		4891	const mod = o.module;
		4892	const target = mod.getTarget();
4671	var it = iterateParamTypes(o, fn_info);	4893	var it = iterateParamTypes(o, fn_info);
4672	while (it.nextCall(self, args)) \|lowering\| switch (lowering) {	4894	while (it.nextCall(self, args)) \|lowering\| switch (lowering) {
4673	.no_bits => continue,	4895	.no_bits => continue,
...	@@ -4824,126 +5046,6 @@ pub const FuncGen = struct {	...	@@ -4824,126 +5046,6 @@ pub const FuncGen = struct {
4824	try llvm_args.append(load_inst);	5046	try llvm_args.append(load_inst);
4825	},	5047	},
4826	};	5048	};
4827
4828	const call = self.builder.buildCall(
4829	try o.lowerType(zig_fn_ty),
4830	llvm_fn,
4831	llvm_args.items.ptr,
4832	@as(c_uint, @intCast(llvm_args.items.len)),
4833	toLlvmCallConv(fn_info.cc, target),
4834	attr,
4835	"",
4836	);
4837
4838	if (callee_ty.zigTypeTag(mod) == .Pointer) {
4839	// Add argument attributes for function pointer calls.
4840	it = iterateParamTypes(o, fn_info);
4841	it.llvm_index += @intFromBool(sret);
4842	it.llvm_index += @intFromBool(err_return_tracing);
4843	while (it.next()) \|lowering\| switch (lowering) {
4844	.byval => {
4845	const param_index = it.zig_index - 1;
4846	const param_ty = fn_info.param_types[param_index].toType();
4847	if (!isByRef(param_ty, mod)) {
4848	o.addByValParamAttrs(call, param_ty, param_index, fn_info, it.llvm_index - 1);
4849	}
4850	},
4851	.byref => {
4852	const param_index = it.zig_index - 1;
4853	const param_ty = fn_info.param_types[param_index].toType();
4854	const param_llvm_ty = try o.lowerType(param_ty);
4855	const alignment = param_ty.abiAlignment(mod);
4856	o.addByRefParamAttrs(call, it.llvm_index - 1, alignment, it.byval_attr, param_llvm_ty);
4857	},
4858	.byref_mut => {
4859	o.addArgAttr(call, it.llvm_index - 1, "noundef");
4860	},
4861	// No attributes needed for these.
4862	.no_bits,
4863	.abi_sized_int,
4864	.multiple_llvm_types,
4865	.as_u16,
4866	.float_array,
4867	.i32_array,
4868	.i64_array,
4869	=> continue,
4870
4871	.slice => {
4872	assert(!it.byval_attr);
4873	const param_ty = fn_info.param_types[it.zig_index - 1].toType();
4874	const ptr_info = param_ty.ptrInfo(mod);
4875	const llvm_arg_i = it.llvm_index - 2;
4876
4877	if (math.cast(u5, it.zig_index - 1)) \|i\| {
4878	if (@as(u1, @truncate(fn_info.noalias_bits >> i)) != 0) {
4879	o.addArgAttr(call, llvm_arg_i, "noalias");
4880	}
4881	}
4882	if (param_ty.zigTypeTag(mod) != .Optional) {
4883	o.addArgAttr(call, llvm_arg_i, "nonnull");
4884	}
4885	if (ptr_info.flags.is_const) {
4886	o.addArgAttr(call, llvm_arg_i, "readonly");
4887	}
4888	const elem_align = ptr_info.flags.alignment.toByteUnitsOptional() orelse
4889	@max(ptr_info.child.toType().abiAlignment(mod), 1);
4890	o.addArgAttrInt(call, llvm_arg_i, "align", elem_align);
4891	},
4892	};
4893	}
4894
4895	if (fn_info.return_type == .noreturn_type and attr != .AlwaysTail) {
4896	return null;
4897	}
4898
4899	if (self.liveness.isUnused(inst) or !return_type.hasRuntimeBitsIgnoreComptime(mod)) {
4900	return null;
4901	}
4902
4903	const llvm_ret_ty = try o.lowerType(return_type);
4904
4905	if (ret_ptr) \|rp\| {
4906	call.setCallSret(llvm_ret_ty);
4907	if (isByRef(return_type, mod)) {
4908	return rp;
4909	} else {
4910	// our by-ref status disagrees with sret so we must load.
4911	const loaded = self.builder.buildLoad(llvm_ret_ty, rp, "");
4912	loaded.setAlignment(return_type.abiAlignment(mod));
4913	return loaded;
4914	}
4915	}
4916
4917	const abi_ret_ty = try lowerFnRetTy(o, fn_info);
4918
4919	if (abi_ret_ty != llvm_ret_ty) {
4920	// In this case the function return type is honoring the calling convention by having
4921	// a different LLVM type than the usual one. We solve this here at the callsite
4922	// by using our canonical type, then loading it if necessary.
4923	const alignment = o.target_data.abiAlignmentOfType(abi_ret_ty);
4924	const rp = self.buildAlloca(llvm_ret_ty, alignment);
4925	const store_inst = self.builder.buildStore(call, rp);
4926	store_inst.setAlignment(alignment);
4927	if (isByRef(return_type, mod)) {
4928	return rp;
4929	} else {
4930	const load_inst = self.builder.buildLoad(llvm_ret_ty, rp, "");
4931	load_inst.setAlignment(alignment);
4932	return load_inst;
4933	}
4934	}
4935
4936	if (isByRef(return_type, mod)) {
4937	// our by-ref status disagrees with sret so we must allocate, store,
4938	// and return the allocation pointer.
4939	const alignment = return_type.abiAlignment(mod);
4940	const rp = self.buildAlloca(llvm_ret_ty, alignment);
4941	const store_inst = self.builder.buildStore(call, rp);
4942	store_inst.setAlignment(alignment);
4943	return rp;
4944	} else {
4945	return call;
4946	}
4947	}	5049	}
4948		5050
4949	fn buildSimplePanic(fg: *FuncGen, panic_id: Module.PanicId) !void {	5051	fn buildSimplePanic(fg: *FuncGen, panic_id: Module.PanicId) !void {
...	@@ -4988,14 +5090,27 @@ pub const FuncGen = struct {	...	@@ -4988,14 +5090,27 @@ pub const FuncGen = struct {
4988	_ = fg.builder.buildUnreachable();	5090	_ = fg.builder.buildUnreachable();
4989	}	5091	}
4990		5092
4991	fn airCallAsync(self: FuncGen, inst: Air.Inst.Index) !?llvm.Value {	5093	fn genFrameSize(fg: FuncGen, llvm_fn: llvm.Value) *llvm.Value {
4992	_ = inst;	5094	const o = fg.dg.object;
4993	return self.todo("lower call_async", .{});	5095	const mod = o.module;
4994	}	5096	const target = mod.getTarget();
4995		5097	const llvm_usize = o.context.intType(target.ptrBitWidth());
4996	fn airCallAsyncAlloc(self: FuncGen, inst: Air.Inst.Index) !?llvm.Value {	5098	const llvm_ptr_ty = o.context.pointerType(0);
4997	_ = inst;	5099	const casted_fn_val = fg.builder.buildBitCast(llvm_fn, llvm_ptr_ty, "");
4998	return self.todo("lower call_async_alloc", .{});	5100	const indices: [1]*llvm.Value = .{
		5101	o.context.intType(32).constInt(@bitCast(@as(c_longlong, -1)), .True),
		5102	};
		5103	const prefix_ptr = fg.builder.buildInBoundsGEP(llvm_usize, casted_fn_val, &indices, indices.len, "");
		5104	const load_inst = fg.builder.buildLoad(llvm_usize, prefix_ptr, "");
		5105
		5106	// Some architectures (e.g SPARCv9) has different alignment
		5107	// requirements between a function/usize pointer and also require all
		5108	// loads to be aligned. On those architectures, not explicitly setting
		5109	// the alignment will lead into @frameSize generating usize-aligned
		5110	// load instruction that could crash if the function pointer happens to
		5111	// be not usize-aligned.
		5112	load_inst.setAlignment(1);
		5113	return load_inst;
4999	}	5114	}
5000		5115
5001	fn airRet(self: FuncGen, inst: Air.Inst.Index) !?llvm.Value {	5116	fn airRet(self: FuncGen, inst: Air.Inst.Index) !?llvm.Value {
...	@@ -11452,3 +11567,29 @@ fn constraintAllowsRegister(constraint: []const u8) bool {	...	@@ -11452,3 +11567,29 @@ fn constraintAllowsRegister(constraint: []const u8) bool {
11452	}	11567	}
11453	} else return false;	11568	} else return false;
11454	}	11569	}
		11570
		11571	/// Each field is the index in the LLVM struct. The doc comments describe what
		11572	/// the corresponding field of the LLVM struct does; not the field of the
		11573	/// AsyncFrameLayout struct.
		11574	const AsyncFrameLayout = struct {
		11575	/// Points to the return value inside the frame.
		11576	ret_val: u16,
		11577	/// This field of the frame points to the owner function so that a resume
		11578	/// on the frame pointer knows which function to call.
		11579	fn_ptr: u16,
		11580	/// This field tells which suspension point to resume from next time the function is called.
		11581	resume_index: u16,
		11582	/// This field tracks which frame is the one awaiting the frame for the purposes of resuming
		11583	/// on return.
		11584	/// A value of zero means the async function has been started, and there is no awaiter yet.
		11585	awaiter: u16,
		11586	};
		11587
		11588	fn asyncFrameLayout() AsyncFrameLayout {
		11589	return .{
		11590	.fn_ptr = 0,
		11591	.resume_index = 1,
		11592	.awaiter = 2,
		11593	.ret_val = 3,
		11594	};
		11595	}

src/codegen/llvm/bindings.zig+3

...	@@ -549,6 +549,9 @@ pub const Builder = opaque {	...	@@ -549,6 +549,9 @@ pub const Builder = opaque {
549	pub const buildAlloca = LLVMBuildAlloca;	549	pub const buildAlloca = LLVMBuildAlloca;
550	extern fn LLVMBuildAlloca(Builder, Ty: Type, Name: [:0]const u8) Value;	550	extern fn LLVMBuildAlloca(Builder, Ty: Type, Name: [:0]const u8) Value;
551		551
		552	pub const buildArrayAlloca = LLVMBuildArrayAlloca;
		553	extern fn LLVMBuildArrayAlloca(Builder, Ty: Type, Val: Value, Name: [:0]const u8) *Value;
		554
552	pub const buildStore = LLVMBuildStore;	555	pub const buildStore = LLVMBuildStore;
553	extern fn LLVMBuildStore(Builder, Val: Value, Ptr: Value) Value;	556	extern fn LLVMBuildStore(Builder, Val: Value, Ptr: Value) Value;
554		557

src/link/Coff.zig+1-1

...	@@ -1222,7 +1222,7 @@ fn updateLazySymbolAtom(	...	@@ -1222,7 +1222,7 @@ fn updateLazySymbolAtom(
1222	Module.SrcLoc{	1222	Module.SrcLoc{
1223	.file_scope = undefined,	1223	.file_scope = undefined,
1224	.parent_decl_node = undefined,	1224	.parent_decl_node = undefined,
1225	.lazy = .unneeded,	1225	.lazy = Module.LazySrcLoc.un(),
1226	};	1226	};
1227	const res = try codegen.generateLazySymbol(	1227	const res = try codegen.generateLazySymbol(
1228	&self.base,	1228	&self.base,

src/link/Elf.zig+1-1

...	@@ -2743,7 +2743,7 @@ fn updateLazySymbolAtom(	...	@@ -2743,7 +2743,7 @@ fn updateLazySymbolAtom(
2743	Module.SrcLoc{	2743	Module.SrcLoc{
2744	.file_scope = undefined,	2744	.file_scope = undefined,
2745	.parent_decl_node = undefined,	2745	.parent_decl_node = undefined,
2746	.lazy = .unneeded,	2746	.lazy = Module.LazySrcLoc.un(),
2747	};	2747	};
2748	const res = try codegen.generateLazySymbol(	2748	const res = try codegen.generateLazySymbol(
2749	&self.base,	2749	&self.base,

src/link/MachO.zig+1-1

...	@@ -2084,7 +2084,7 @@ fn updateLazySymbolAtom(	...	@@ -2084,7 +2084,7 @@ fn updateLazySymbolAtom(
2084	Module.SrcLoc{	2084	Module.SrcLoc{
2085	.file_scope = undefined,	2085	.file_scope = undefined,
2086	.parent_decl_node = undefined,	2086	.parent_decl_node = undefined,
2087	.lazy = .unneeded,	2087	.lazy = Module.LazySrcLoc.un(),
2088	};	2088	};
2089	const res = try codegen.generateLazySymbol(	2089	const res = try codegen.generateLazySymbol(
2090	&self.base,	2090	&self.base,

src/link/Plan9.zig+1-1

...	@@ -1051,7 +1051,7 @@ fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Ind	...	@@ -1051,7 +1051,7 @@ fn updateLazySymbolAtom(self: *Plan9, sym: File.LazySymbol, atom_index: Atom.Ind
1051	Module.SrcLoc{	1051	Module.SrcLoc{
1052	.file_scope = undefined,	1052	.file_scope = undefined,
1053	.parent_decl_node = undefined,	1053	.parent_decl_node = undefined,
1054	.lazy = .unneeded,	1054	.lazy = Module.LazySrcLoc.un(),
1055	};	1055	};
1056	const res = try codegen.generateLazySymbol(	1056	const res = try codegen.generateLazySymbol(
1057	&self.base,	1057	&self.base,

...	@@ -1887,7 +1887,7 @@ pub fn setupErrorReturnTrace(sema: Sema, block: Block, last_arg_index: usize)	...	@@ -1887,7 +1887,7 @@ pub fn setupErrorReturnTrace(sema: Sema, block: Block, last_arg_index: usize)
1887	var err_trace_block = block.makeSubBlock();	1887	var err_trace_block = block.makeSubBlock();
1888	defer err_trace_block.instructions.deinit(gpa);	1888	defer err_trace_block.instructions.deinit(gpa);
1889		1889
1890	const src: LazySrcLoc = .unneeded;	1890	const src = LazySrcLoc.un();
1891		1891
1892	// var addrs: [err_return_trace_addr_count]usize = undefined;	1892	// var addrs: [err_return_trace_addr_count]usize = undefined;
1893	const err_return_trace_addr_count = 32;	1893	const err_return_trace_addr_count = 32;
...	@@ -2913,7 +2913,7 @@ fn createAnonymousDeclTypeNamed(	...	@@ -2913,7 +2913,7 @@ fn createAnonymousDeclTypeNamed(
2913	// If not then this is a struct type being returned from a non-generic	2913	// If not then this is a struct type being returned from a non-generic
2914	// function and the name doesn't matter since it will later	2914	// function and the name doesn't matter since it will later
2915	// result in a compile error.	2915	// result in a compile error.
2916	const arg_val = sema.resolveConstMaybeUndefVal(block, .unneeded, arg, "") catch	2916	const arg_val = sema.resolveConstMaybeUndefVal(block, LazySrcLoc.un(), arg, "") catch
2917	return sema.createAnonymousDeclTypeNamed(block, src, typed_value, .anon, anon_prefix, null);	2917	return sema.createAnonymousDeclTypeNamed(block, src, typed_value, .anon, anon_prefix, null);
2918		2918
2919	if (arg_i != 0) try writer.writeByte(',');	2919	if (arg_i != 0) try writer.writeByte(',');
...	@@ -3161,7 +3161,7 @@ fn zirEnumDecl(	...	@@ -3161,7 +3161,7 @@ fn zirEnumDecl(
3161	const tag_val_ref = @as(Zir.Inst.Ref, @enumFromInt(sema.code.extra[extra_index]));	3161	const tag_val_ref = @as(Zir.Inst.Ref, @enumFromInt(sema.code.extra[extra_index]));
3162	extra_index += 1;	3162	extra_index += 1;
3163	const tag_inst = try sema.resolveInst(tag_val_ref);	3163	const tag_inst = try sema.resolveInst(tag_val_ref);
3164	last_tag_val = sema.resolveConstValue(block, .unneeded, tag_inst, "") catch \|err\| switch (err) {	3164	last_tag_val = sema.resolveConstValue(block, LazySrcLoc.un(), tag_inst, "") catch \|err\| switch (err) {
3165	error.NeededSourceLocation => {	3165	error.NeededSourceLocation => {
3166	const value_src = mod.fieldSrcLoc(new_decl_index, .{	3166	const value_src = mod.fieldSrcLoc(new_decl_index, .{
3167	.index = field_i,	3167	.index = field_i,
...	@@ -5834,7 +5834,7 @@ fn zirExport(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void	...	@@ -5834,7 +5834,7 @@ fn zirExport(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void
5834	break :index_blk maybe_index orelse	5834	break :index_blk maybe_index orelse
5835	return sema.failWithBadMemberAccess(block, container_ty, operand_src, decl_name);	5835	return sema.failWithBadMemberAccess(block, container_ty, operand_src, decl_name);
5836	} else try sema.lookupIdentifier(block, operand_src, decl_name);	5836	} else try sema.lookupIdentifier(block, operand_src, decl_name);
5837	const options = sema.resolveExportOptions(block, .unneeded, extra.options) catch \|err\| switch (err) {	5837	const options = sema.resolveExportOptions(block, LazySrcLoc.un(), extra.options) catch \|err\| switch (err) {
5838	error.NeededSourceLocation => {	5838	error.NeededSourceLocation => {
5839	_ = try sema.resolveExportOptions(block, options_src, extra.options);	5839	_ = try sema.resolveExportOptions(block, options_src, extra.options);
5840	unreachable;	5840	unreachable;
...	@@ -5861,7 +5861,7 @@ fn zirExportValue(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError	...	@@ -5861,7 +5861,7 @@ fn zirExportValue(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError
5861	const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };	5861	const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
5862	const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };	5862	const options_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
5863	const operand = try sema.resolveInstConst(block, operand_src, extra.operand, "export target must be comptime-known");	5863	const operand = try sema.resolveInstConst(block, operand_src, extra.operand, "export target must be comptime-known");
5864	const options = sema.resolveExportOptions(block, .unneeded, extra.options) catch \|err\| switch (err) {	5864	const options = sema.resolveExportOptions(block, LazySrcLoc.un(), extra.options) catch \|err\| switch (err) {
5865	error.NeededSourceLocation => {	5865	error.NeededSourceLocation => {
5866	_ = try sema.resolveExportOptions(block, options_src, extra.options);	5866	_ = try sema.resolveExportOptions(block, options_src, extra.options);
5867	unreachable;	5867	unreachable;