Commit 0bf8617d963dc432ed0204b10285cc414becf2fd | zig

CMakeLists.txt+1-1

...	@@ -519,6 +519,7 @@ set(ZIG_STAGE2_SOURCES	...	@@ -519,6 +519,7 @@ set(ZIG_STAGE2_SOURCES
519	src/Air/Legalize.zig	519	src/Air/Legalize.zig
520	src/Air/Liveness.zig	520	src/Air/Liveness.zig
521	src/Air/Liveness/Verify.zig	521	src/Air/Liveness/Verify.zig
		522	src/Air/print.zig
522	src/Air/types_resolved.zig	523	src/Air/types_resolved.zig
523	src/Builtin.zig	524	src/Builtin.zig
524	src/Compilation.zig	525	src/Compilation.zig
...	@@ -675,7 +676,6 @@ set(ZIG_STAGE2_SOURCES	...	@@ -675,7 +676,6 @@ set(ZIG_STAGE2_SOURCES
675	src/libs/mingw.zig	676	src/libs/mingw.zig
676	src/libs/musl.zig	677	src/libs/musl.zig
677	src/mutable_value.zig	678	src/mutable_value.zig
678	src/print_air.zig
679	src/print_env.zig	679	src/print_env.zig
680	src/print_targets.zig	680	src/print_targets.zig
681	src/print_value.zig	681	src/print_value.zig

lib/std/builtin.zig+13-2

 @@ -61,7 +61,7 @@ pub const StackTrace = struct {
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub const GlobalLinkage = enum {
+pub const GlobalLinkage = enum(u2) {
     internal,
     strong,
     weak,
 @@ -70,7 +70,7 @@ pub const GlobalLinkage = enum {
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub const SymbolVisibility = enum {
+pub const SymbolVisibility = enum(u2) {
     default,
     hidden,
     protected,
 @@ -1030,8 +1030,19 @@ pub const ExternOptions = struct {
     name: []const u8,
     library_name: ?[]const u8 = null,
     linkage: GlobalLinkage = .strong,
+    visibility: SymbolVisibility = .default,
+    /// Setting this to `true` makes the `@extern` a runtime value.
     is_thread_local: bool = false,
     is_dll_import: bool = false,
+    relocation: Relocation = .any,
+    pub const Relocation = enum(u1) {
+        /// Any type of relocation is allowed.
+        any,
+        /// A program-counter-relative relocation is required.
+        /// Using this value makes the `@extern` a runtime value.
+        pcrel,
+    };
 };
 /// This data structure is used by the Zig language code generation and

lib/std/dynamic_library.zig+8-5

 @@ -83,13 +83,16 @@ const RDebug = extern struct {
     r_ldbase: usize,
 };
-/// TODO make it possible to reference this same external symbol 2x so we don't need this
+/// TODO fix comparisons of extern symbol pointers so we don't need this helper function.
-/// helper function.
+pub fn get_DYNAMIC() ?[*]const elf.Dyn {
-pub fn get_DYNAMIC() ?[*]elf.Dyn {
+    return @extern([*]const elf.Dyn, .{
-    return @extern([*]elf.Dyn, .{ .name = "_DYNAMIC", .linkage = .weak });
+        .name = "_DYNAMIC",
+        .linkage = .weak,
+        .visibility = .hidden,
+    });
 }
-pub fn linkmap_iterator(phdrs: []elf.Phdr) error{InvalidExe}!LinkMap.Iterator {
+pub fn linkmap_iterator(phdrs: []const elf.Phdr) error{InvalidExe}!LinkMap.Iterator {
     _ = phdrs;
     const _DYNAMIC = get_DYNAMIC() orelse {
         // No PT_DYNAMIC means this is either a statically-linked program or a

lib/std/pie.zig+174-169

...	@@ -39,167 +39,175 @@ const R_RELATIVE = switch (builtin.cpu.arch) {	...	@@ -39,167 +39,175 @@ const R_RELATIVE = switch (builtin.cpu.arch) {
39	// Obtain a pointer to the _DYNAMIC array.	39	// Obtain a pointer to the _DYNAMIC array.
40	// We have to compute its address as a PC-relative quantity not to require a	40	// We have to compute its address as a PC-relative quantity not to require a
41	// relocation that, at this point, is not yet applied.	41	// relocation that, at this point, is not yet applied.
42	inline fn getDynamicSymbol() [*]elf.Dyn {	42	inline fn getDynamicSymbol() [*]const elf.Dyn {
43	return switch (builtin.cpu.arch) {	43	return switch (builtin.zig_backend) {
44	.x86 => asm volatile (	44	else => switch (builtin.cpu.arch) {
45	\\ .weak _DYNAMIC	45	.x86 => asm volatile (
46	\\ .hidden _DYNAMIC	46	\\ .weak _DYNAMIC
47	\\ call 1f	47	\\ .hidden _DYNAMIC
48	\\ 1: pop %[ret]	48	\\ call 1f
49	\\ lea _DYNAMIC-1b(%[ret]), %[ret]	49	\\ 1: pop %[ret]
50	: [ret] "=r" (-> [*]elf.Dyn),	50	\\ lea _DYNAMIC-1b(%[ret]), %[ret]
51	),	51	: [ret] "=r" (-> [*]const elf.Dyn),
52	.x86_64 => asm volatile (	52	),
53	\\ .weak _DYNAMIC	53	.x86_64 => asm volatile (
54	\\ .hidden _DYNAMIC	54	\\ .weak _DYNAMIC
55	\\ lea _DYNAMIC(%%rip), %[ret]	55	\\ .hidden _DYNAMIC
56	: [ret] "=r" (-> [*]elf.Dyn),	56	\\ lea _DYNAMIC(%%rip), %[ret]
57	),	57	: [ret] "=r" (-> [*]const elf.Dyn),
58	.arc => asm volatile (	58	),
59	\\ .weak _DYNAMIC	59	.arc => asm volatile (
60	\\ .hidden _DYNAMIC	60	\\ .weak _DYNAMIC
61	\\ add %[ret], pcl, _DYNAMIC@pcl	61	\\ .hidden _DYNAMIC
62	: [ret] "=r" (-> [*]elf.Dyn),	62	\\ add %[ret], pcl, _DYNAMIC@pcl
63	),	63	: [ret] "=r" (-> [*]const elf.Dyn),
64	// Work around the limited offset range of `ldr`	64	),
65	.arm, .armeb, .thumb, .thumbeb => asm volatile (	65	// Work around the limited offset range of `ldr`
66	\\ .weak _DYNAMIC	66	.arm, .armeb, .thumb, .thumbeb => asm volatile (
67	\\ .hidden _DYNAMIC	67	\\ .weak _DYNAMIC
68	\\ ldr %[ret], 1f	68	\\ .hidden _DYNAMIC
69	\\ add %[ret], pc	69	\\ ldr %[ret], 1f
70	\\ b 2f	70	\\ add %[ret], pc
71	\\ 1: .word _DYNAMIC-1b	71	\\ b 2f
72	\\ 2:	72	\\ 1: .word _DYNAMIC-1b
73	: [ret] "=r" (-> [*]elf.Dyn),	73	\\ 2:
74	),	74	: [ret] "=r" (-> [*]const elf.Dyn),
75	// A simple `adr` is not enough as it has a limited offset range	75	),
76	.aarch64, .aarch64_be => asm volatile (	76	// A simple `adr` is not enough as it has a limited offset range
77	\\ .weak _DYNAMIC	77	.aarch64, .aarch64_be => asm volatile (
78	\\ .hidden _DYNAMIC	78	\\ .weak _DYNAMIC
79	\\ adrp %[ret], _DYNAMIC	79	\\ .hidden _DYNAMIC
80	\\ add %[ret], %[ret], #:lo12:_DYNAMIC	80	\\ adrp %[ret], _DYNAMIC
81	: [ret] "=r" (-> [*]elf.Dyn),	81	\\ add %[ret], %[ret], #:lo12:_DYNAMIC
82	),	82	: [ret] "=r" (-> [*]const elf.Dyn),
83	// The CSKY ABI requires the gb register to point to the GOT. Additionally, the first	83	),
84	// entry in the GOT is defined to hold the address of _DYNAMIC.	84	// The CSKY ABI requires the gb register to point to the GOT. Additionally, the first
85	.csky => asm volatile (	85	// entry in the GOT is defined to hold the address of _DYNAMIC.
86	\\ mov %[ret], gb	86	.csky => asm volatile (
87	\\ ldw %[ret], %[ret]	87	\\ mov %[ret], gb
88	: [ret] "=r" (-> [*]elf.Dyn),	88	\\ ldw %[ret], %[ret]
89	),	89	: [ret] "=r" (-> [*]const elf.Dyn),
90	.hexagon => asm volatile (	90	),
91	\\ .weak _DYNAMIC	91	.hexagon => asm volatile (
92	\\ .hidden _DYNAMIC	92	\\ .weak _DYNAMIC
93	\\ jump 1f	93	\\ .hidden _DYNAMIC
94	\\ .word _DYNAMIC - .	94	\\ jump 1f
95	\\ 1:	95	\\ .word _DYNAMIC - .
96	\\ r1 = pc	96	\\ 1:
97	\\ r1 = add(r1, #-4)	97	\\ r1 = pc
98	\\ %[ret] = memw(r1)	98	\\ r1 = add(r1, #-4)
99	\\ %[ret] = add(r1, %[ret])	99	\\ %[ret] = memw(r1)
100	: [ret] "=r" (-> [*]elf.Dyn),	100	\\ %[ret] = add(r1, %[ret])
101	:	101	: [ret] "=r" (-> [*]const elf.Dyn),
102	: "r1"	102	:
103	),	103	: "r1"
104	.loongarch32, .loongarch64 => asm volatile (	104	),
105	\\ .weak _DYNAMIC	105	.loongarch32, .loongarch64 => asm volatile (
106	\\ .hidden _DYNAMIC	106	\\ .weak _DYNAMIC
107	\\ la.local %[ret], _DYNAMIC	107	\\ .hidden _DYNAMIC
108	: [ret] "=r" (-> [*]elf.Dyn),	108	\\ la.local %[ret], _DYNAMIC
109	),	109	: [ret] "=r" (-> [*]const elf.Dyn),
110	// Note that the - 8 is needed because pc in the second lea instruction points into the	110	),
111	// middle of that instruction. (The first lea is 6 bytes, the second is 4 bytes.)	111	// Note that the - 8 is needed because pc in the second lea instruction points into the
112	.m68k => asm volatile (	112	// middle of that instruction. (The first lea is 6 bytes, the second is 4 bytes.)
113	\\ .weak _DYNAMIC	113	.m68k => asm volatile (
114	\\ .hidden _DYNAMIC	114	\\ .weak _DYNAMIC
115	\\ lea _DYNAMIC - . - 8, %[ret]	115	\\ .hidden _DYNAMIC
116	\\ lea (%[ret], %%pc), %[ret]	116	\\ lea _DYNAMIC - . - 8, %[ret]
117	: [ret] "=r" (-> [*]elf.Dyn),	117	\\ lea (%[ret], %%pc), %[ret]
118	),	118	: [ret] "=r" (-> [*]const elf.Dyn),
119	.mips, .mipsel => asm volatile (	119	),
120	\\ .weak _DYNAMIC	120	.mips, .mipsel => asm volatile (
121	\\ .hidden _DYNAMIC	121	\\ .weak _DYNAMIC
122	\\ bal 1f	122	\\ .hidden _DYNAMIC
123	\\ .gpword _DYNAMIC	123	\\ bal 1f
124	\\ 1:	124	\\ .gpword _DYNAMIC
125	\\ lw %[ret], 0($ra)	125	\\ 1:
126	\\ addu %[ret], %[ret], $gp	126	\\ lw %[ret], 0($ra)
127	: [ret] "=r" (-> [*]elf.Dyn),	127	\\ addu %[ret], %[ret], $gp
128	:	128	: [ret] "=r" (-> [*]const elf.Dyn),
129	: "lr"	129	:
130	),	130	: "lr"
131	.mips64, .mips64el => asm volatile (	131	),
132	\\ .weak _DYNAMIC	132	.mips64, .mips64el => asm volatile (
133	\\ .hidden _DYNAMIC	133	\\ .weak _DYNAMIC
134	\\ .balign 8	134	\\ .hidden _DYNAMIC
135	\\ bal 1f	135	\\ .balign 8
136	\\ .gpdword _DYNAMIC	136	\\ bal 1f
137	\\ 1:	137	\\ .gpdword _DYNAMIC
138	\\ ld %[ret], 0($ra)	138	\\ 1:
139	\\ daddu %[ret], %[ret], $gp	139	\\ ld %[ret], 0($ra)
140	: [ret] "=r" (-> [*]elf.Dyn),	140	\\ daddu %[ret], %[ret], $gp
141	:	141	: [ret] "=r" (-> [*]const elf.Dyn),
142	: "lr"	142	:
143	),	143	: "lr"
144	.powerpc, .powerpcle => asm volatile (	144	),
145	\\ .weak _DYNAMIC	145	.powerpc, .powerpcle => asm volatile (
146	\\ .hidden _DYNAMIC	146	\\ .weak _DYNAMIC
147	\\ bl 1f	147	\\ .hidden _DYNAMIC
148	\\ .long _DYNAMIC - .	148	\\ bl 1f
149	\\ 1:	149	\\ .long _DYNAMIC - .
150	\\ mflr %[ret]	150	\\ 1:
151	\\ lwz 4, 0(%[ret])	151	\\ mflr %[ret]
152	\\ add %[ret], 4, %[ret]	152	\\ lwz 4, 0(%[ret])
153	: [ret] "=r" (-> [*]elf.Dyn),	153	\\ add %[ret], 4, %[ret]
154	:	154	: [ret] "=r" (-> [*]const elf.Dyn),
155	: "lr", "r4"	155	:
156	),	156	: "lr", "r4"
157	.powerpc64, .powerpc64le => asm volatile (	157	),
158	\\ .weak _DYNAMIC	158	.powerpc64, .powerpc64le => asm volatile (
159	\\ .hidden _DYNAMIC	159	\\ .weak _DYNAMIC
160	\\ bl 1f	160	\\ .hidden _DYNAMIC
161	\\ .quad _DYNAMIC - .	161	\\ bl 1f
162	\\ 1:	162	\\ .quad _DYNAMIC - .
163	\\ mflr %[ret]	163	\\ 1:
164	\\ ld 4, 0(%[ret])	164	\\ mflr %[ret]
165	\\ add %[ret], 4, %[ret]	165	\\ ld 4, 0(%[ret])
166	: [ret] "=r" (-> [*]elf.Dyn),	166	\\ add %[ret], 4, %[ret]
167	:	167	: [ret] "=r" (-> [*]const elf.Dyn),
168	: "lr", "r4"	168	:
169	),	169	: "lr", "r4"
170	.riscv32, .riscv64 => asm volatile (	170	),
171	\\ .weak _DYNAMIC	171	.riscv32, .riscv64 => asm volatile (
172	\\ .hidden _DYNAMIC	172	\\ .weak _DYNAMIC
173	\\ lla %[ret], _DYNAMIC	173	\\ .hidden _DYNAMIC
174	: [ret] "=r" (-> [*]elf.Dyn),	174	\\ lla %[ret], _DYNAMIC
175	),	175	: [ret] "=r" (-> [*]const elf.Dyn),
176	.s390x => asm volatile (	176	),
177	\\ .weak _DYNAMIC	177	.s390x => asm volatile (
178	\\ .hidden _DYNAMIC	178	\\ .weak _DYNAMIC
179	\\ larl %[ret], 1f	179	\\ .hidden _DYNAMIC
180	\\ ag %[ret], 0(%[ret])	180	\\ larl %[ret], 1f
181	\\ jg 2f	181	\\ ag %[ret], 0(%[ret])
182	\\ 1: .quad _DYNAMIC - .	182	\\ jg 2f
183	\\ 2:	183	\\ 1: .quad _DYNAMIC - .
184	: [ret] "=r" (-> [*]elf.Dyn),	184	\\ 2:
185	),	185	: [ret] "=r" (-> [*]const elf.Dyn),
186	// The compiler does not necessarily have any obligation to load the `l7` register (pointing	186	),
187	// to the GOT), so do it ourselves just in case.	187	// The compiler does not necessarily have any obligation to load the `l7` register (pointing
188	.sparc, .sparc64 => asm volatile (	188	// to the GOT), so do it ourselves just in case.
189	\\ sethi %%hi(_GLOBAL_OFFSET_TABLE_ - 4), %%l7	189	.sparc, .sparc64 => asm volatile (
190	\\ call 1f	190	\\ sethi %%hi(_GLOBAL_OFFSET_TABLE_ - 4), %%l7
191	\\ add %%l7, %%lo(_GLOBAL_OFFSET_TABLE_ + 4), %%l7	191	\\ call 1f
192	\\ 1:	192	\\ add %%l7, %%lo(_GLOBAL_OFFSET_TABLE_ + 4), %%l7
193	\\ add %%l7, %%o7, %[ret]	193	\\ 1:
194	: [ret] "=r" (-> [*]elf.Dyn),	194	\\ add %%l7, %%o7, %[ret]
195	),	195	: [ret] "=r" (-> [*]const elf.Dyn),
196	else => {	196	),
197	@compileError("PIE startup is not yet supported for this target!");	197	else => {
		198	@compileError("PIE startup is not yet supported for this target!");
		199	},
198	},	200	},
		201	.stage2_x86_64 => @extern([*]const elf.Dyn, .{
		202	.name = "_DYNAMIC",
		203	.linkage = .weak,
		204	.visibility = .hidden,
		205	.relocation = .pcrel,
		206	}).?,
199	};	207	};
200	}	208	}
201		209
202	pub fn relocate(phdrs: []elf.Phdr) void {	210	pub fn relocate(phdrs: []const elf.Phdr) void {
203	@setRuntimeSafety(false);	211	@setRuntimeSafety(false);
204	@disableInstrumentation();	212	@disableInstrumentation();
205		213
...	@@ -256,10 +264,9 @@ pub fn relocate(phdrs: []elf.Phdr) void {	...	@@ -256,10 +264,9 @@ pub fn relocate(phdrs: []elf.Phdr) void {
256		264
257	const rel = sorted_dynv[elf.DT_REL];	265	const rel = sorted_dynv[elf.DT_REL];
258	if (rel != 0) {	266	if (rel != 0) {
259	const rels = @call(.always_inline, std.mem.bytesAsSlice, .{	267	const rels: []const elf.Rel = @alignCast(@ptrCast(
260	elf.Rel,	268	@as([*]align(@alignOf(elf.Rel)) const u8, @ptrFromInt(base_addr + rel))[0..sorted_dynv[elf.DT_RELSZ]],
261	@as([*]u8, @ptrFromInt(base_addr + rel))[0..sorted_dynv[elf.DT_RELSZ]],	269	));
262	});
263	for (rels) \|r\| {	270	for (rels) \|r\| {
264	if (r.r_type() != R_RELATIVE) continue;	271	if (r.r_type() != R_RELATIVE) continue;
265	@as(usize, @ptrFromInt(base_addr + r.r_offset)). += base_addr;	272	@as(usize, @ptrFromInt(base_addr + r.r_offset)). += base_addr;
...	@@ -268,10 +275,9 @@ pub fn relocate(phdrs: []elf.Phdr) void {	...	@@ -268,10 +275,9 @@ pub fn relocate(phdrs: []elf.Phdr) void {
268		275
269	const rela = sorted_dynv[elf.DT_RELA];	276	const rela = sorted_dynv[elf.DT_RELA];
270	if (rela != 0) {	277	if (rela != 0) {
271	const relas = @call(.always_inline, std.mem.bytesAsSlice, .{	278	const relas: []const elf.Rela = @alignCast(@ptrCast(
272	elf.Rela,	279	@as([*]align(@alignOf(elf.Rela)) const u8, @ptrFromInt(base_addr + rela))[0..sorted_dynv[elf.DT_RELASZ]],
273	@as([*]u8, @ptrFromInt(base_addr + rela))[0..sorted_dynv[elf.DT_RELASZ]],	280	));
274	});
275	for (relas) \|r\| {	281	for (relas) \|r\| {
276	if (r.r_type() != R_RELATIVE) continue;	282	if (r.r_type() != R_RELATIVE) continue;
277	@as(usize, @ptrFromInt(base_addr + r.r_offset)). = base_addr + @as(usize, @bitCast(r.r_addend));	283	@as(usize, @ptrFromInt(base_addr + r.r_offset)). = base_addr + @as(usize, @bitCast(r.r_addend));
...	@@ -280,10 +286,9 @@ pub fn relocate(phdrs: []elf.Phdr) void {	...	@@ -280,10 +286,9 @@ pub fn relocate(phdrs: []elf.Phdr) void {
280		286
281	const relr = sorted_dynv[elf.DT_RELR];	287	const relr = sorted_dynv[elf.DT_RELR];
282	if (relr != 0) {	288	if (relr != 0) {
283	const relrs = @call(.always_inline, std.mem.bytesAsSlice, .{	289	const relrs: []const elf.Relr = @ptrCast(
284	elf.Relr,	290	@as([*]align(@alignOf(elf.Relr)) const u8, @ptrFromInt(base_addr + relr))[0..sorted_dynv[elf.DT_RELRSZ]],
285	@as([*]u8, @ptrFromInt(base_addr + relr))[0..sorted_dynv[elf.DT_RELRSZ]],	291	);
286	});
287	var current: [*]usize = undefined;	292	var current: [*]usize = undefined;
288	for (relrs) \|r\| {	293	for (relrs) \|r\| {
289	if ((r & 1) == 0) {	294	if ((r & 1) == 0) {

lib/std/start.zig+6-6

...	@@ -163,7 +163,7 @@ fn exit2(code: usize) noreturn {	...	@@ -163,7 +163,7 @@ fn exit2(code: usize) noreturn {
163	// exits(0)	163	// exits(0)
164	.plan9 => std.os.plan9.exits(null),	164	.plan9 => std.os.plan9.exits(null),
165	.windows => {	165	.windows => {
166	std.os.windows.ntdll.RtlExitUserProcess(@as(u32, @truncate(code)));	166	std.os.windows.ntdll.RtlExitUserProcess(@truncate(code));
167	},	167	},
168	else => @compileError("TODO"),	168	else => @compileError("TODO"),
169	}	169	}
...	@@ -511,7 +511,7 @@ fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.c) noreturn {	...	@@ -511,7 +511,7 @@ fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.c) noreturn {
511	// Code coverage instrumentation might try to use thread local variables.	511	// Code coverage instrumentation might try to use thread local variables.
512	@disableInstrumentation();	512	@disableInstrumentation();
513	const argc = argc_argv_ptr[0];	513	const argc = argc_argv_ptr[0];
514	const argv = @as([][:0]u8, @ptrCast(argc_argv_ptr + 1));	514	const argv: [][:0]u8 = @ptrCast(argc_argv_ptr + 1);
515		515
516	const envp_optional: [:null]?[:0]u8 = @ptrCast(@alignCast(argv + argc + 1));	516	const envp_optional: [:null]?[:0]u8 = @ptrCast(@alignCast(argv + argc + 1));
517	var envp_count: usize = 0;	517	var envp_count: usize = 0;
...	@@ -573,11 +573,11 @@ fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.c) noreturn {	...	@@ -573,11 +573,11 @@ fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.c) noreturn {
573	expandStackSize(phdrs);	573	expandStackSize(phdrs);
574	}	574	}
575		575
576	const opt_init_array_start = @extern([]const fn () callconv(.c) void, .{	576	const opt_init_array_start = @extern([]const const fn () callconv(.c) void, .{
577	.name = "__init_array_start",	577	.name = "__init_array_start",
578	.linkage = .weak,	578	.linkage = .weak,
579	});	579	});
580	const opt_init_array_end = @extern([]const fn () callconv(.c) void, .{	580	const opt_init_array_end = @extern([]const const fn () callconv(.c) void, .{
581	.name = "__init_array_end",	581	.name = "__init_array_end",
582	.linkage = .weak,	582	.linkage = .weak,
583	});	583	});
...	@@ -651,7 +651,7 @@ fn main(c_argc: c_int, c_argv: [][:0]c_char, c_envp: [:null]?[:0]c_char) cal	...	@@ -651,7 +651,7 @@ fn main(c_argc: c_int, c_argv: [][:0]c_char, c_envp: [:null]?[:0]c_char) cal
651	}	651	}
652		652
653	fn mainWithoutEnv(c_argc: c_int, c_argv: [][:0]c_char) callconv(.c) c_int {	653	fn mainWithoutEnv(c_argc: c_int, c_argv: [][:0]c_char) callconv(.c) c_int {
654	std.os.argv = @as([][:0]u8, @ptrCast(c_argv))[0..@as(usize, @intCast(c_argc))];	654	std.os.argv = @as([][:0]u8, @ptrCast(c_argv))[0..@intCast(c_argc)];
655	return callMain();	655	return callMain();
656	}	656	}
657		657
...	@@ -701,7 +701,7 @@ pub inline fn callMain() u8 {	...	@@ -701,7 +701,7 @@ pub inline fn callMain() u8 {
701	pub fn call_wWinMain() std.os.windows.INT {	701	pub fn call_wWinMain() std.os.windows.INT {
702	const peb = std.os.windows.peb();	702	const peb = std.os.windows.peb();
703	const MAIN_HINSTANCE = @typeInfo(@TypeOf(root.wWinMain)).@"fn".params[0].type.?;	703	const MAIN_HINSTANCE = @typeInfo(@TypeOf(root.wWinMain)).@"fn".params[0].type.?;
704	const hInstance = @as(MAIN_HINSTANCE, @ptrCast(peb.ImageBaseAddress));	704	const hInstance: MAIN_HINSTANCE = @ptrCast(peb.ImageBaseAddress);
705	const lpCmdLine: [*:0]u16 = @ptrCast(peb.ProcessParameters.CommandLine.Buffer);	705	const lpCmdLine: [*:0]u16 = @ptrCast(peb.ProcessParameters.CommandLine.Buffer);
706		706
707	// There are various types used for the 'show window' variable through the Win32 APIs:	707	// There are various types used for the 'show window' variable through the Win32 APIs:

lib/std/zig/llvm/Builder.zig+12

...	@@ -1823,6 +1823,14 @@ pub const Visibility = enum(u2) {	...	@@ -1823,6 +1823,14 @@ pub const Visibility = enum(u2) {
1823	hidden = 1,	1823	hidden = 1,
1824	protected = 2,	1824	protected = 2,
1825		1825
		1826	pub fn fromSymbolVisibility(sv: std.builtin.SymbolVisibility) Visibility {
		1827	return switch (sv) {
		1828	.default => .default,
		1829	.hidden => .hidden,
		1830	.protected => .protected,
		1831	};
		1832	}
		1833
1826	pub fn format(	1834	pub fn format(
1827	self: Visibility,	1835	self: Visibility,
1828	comptime _: []const u8,	1836	comptime _: []const u8,
...	@@ -2555,6 +2563,10 @@ pub const Variable = struct {	...	@@ -2555,6 +2563,10 @@ pub const Variable = struct {
2555	return self.ptrConst(builder).global.setLinkage(linkage, builder);	2563	return self.ptrConst(builder).global.setLinkage(linkage, builder);
2556	}	2564	}
2557		2565
		2566	pub fn setVisibility(self: Index, visibility: Visibility, builder: *Builder) void {
		2567	return self.ptrConst(builder).global.setVisibility(visibility, builder);
		2568	}
		2569
2558	pub fn setDllStorageClass(self: Index, class: DllStorageClass, builder: *Builder) void {	2570	pub fn setDllStorageClass(self: Index, class: DllStorageClass, builder: *Builder) void {
2559	return self.ptrConst(builder).global.setDllStorageClass(class, builder);	2571	return self.ptrConst(builder).global.setDllStorageClass(class, builder);
2560	}	2572	}

lib/zig.h+9

...	@@ -272,6 +272,15 @@	...	@@ -272,6 +272,15 @@
272	#define zig_linksection_fn zig_linksection	272	#define zig_linksection_fn zig_linksection
273	#endif	273	#endif
274		274
		275	#if zig_has_attribute(visibility)
		276	#define zig_visibility(name) __attribute__((visibility(#name)))
		277	#else
		278	#define zig_visibility(name) zig_visibility_##name
		279	#define zig_visibility_default
		280	#define zig_visibility_hidden zig_visibility_hidden_unavailable
		281	#define zig_visibility_protected zig_visibility_protected_unavailable
		282	#endif
		283
275	#if zig_has_builtin(unreachable) \|\| defined(zig_gcc) \|\| defined(zig_tinyc)	284	#if zig_has_builtin(unreachable) \|\| defined(zig_gcc) \|\| defined(zig_tinyc)
276	#define zig_unreachable() __builtin_unreachable()	285	#define zig_unreachable() __builtin_unreachable()
277	#elif defined(zig_msvc)	286	#elif defined(zig_msvc)

src/Air.zig+10-4

 @@ -13,6 +13,7 @@ const InternPool = @import("InternPool.zig");
 const Type = @import("Type.zig");
 const Value = @import("Value.zig");
 const Zcu = @import("Zcu.zig");
+const print = @import("Air/print.zig");
 const types_resolved = @import("Air/types_resolved.zig");
 pub const Legalize = @import("Air/Legalize.zig");
 @@ -863,16 +864,17 @@ pub const Inst = struct {
         /// Uses the `vector_store_elem` field.
         vector_store_elem,
-        /// Compute a pointer to a threadlocal or dllimport `Nav`, meaning one of:
+        /// Compute a pointer to a `Nav` at runtime, always one of:
         ///
         /// * `threadlocal var`
         /// * `extern threadlocal var` (or corresponding `@extern`)
         /// * `@extern` with `.is_dll_import = true`
+        /// * `@extern` with `.relocation = .pcrel`
         ///
         /// Such pointers are runtime values, so cannot be represented with an InternPool index.
         ///
         /// Uses the `ty_nav` field.
-        tlv_dllimport_ptr,
+        runtime_nav_ptr,
         /// Implements @cVaArg builtin.
         /// Uses the `ty_op` field.
 @@ -1708,7 +1710,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
             return .fromInterned(ip.indexToKey(err_union_ty.ip_index).error_union_type.payload_type);
         },
-        .tlv_dllimport_ptr => return .fromInterned(datas[@intFromEnum(inst)].ty_nav.ty),
+        .runtime_nav_ptr => return .fromInterned(datas[@intFromEnum(inst)].ty_nav.ty),
         .work_item_id,
         .work_group_size,
 @@ -1983,7 +1985,7 @@ pub fn mustLower(air: Air, inst: Air.Inst.Index, ip: *const InternPool) bool {
         .err_return_trace,
         .addrspace_cast,
         .save_err_return_trace_index,
-        .tlv_dllimport_ptr,
+        .runtime_nav_ptr,
         .work_item_id,
         .work_group_size,
         .work_group_id,
 @@ -2141,6 +2143,10 @@ pub const typesFullyResolved = types_resolved.typesFullyResolved;
 pub const typeFullyResolved = types_resolved.checkType;
 pub const valFullyResolved = types_resolved.checkVal;
 pub const legalize = Legalize.legalize;
+pub const write = print.write;
+pub const writeInst = print.writeInst;
+pub const dump = print.dump;
+pub const dumpInst = print.dumpInst;
 pub const CoveragePoint = enum(u1) {
     /// Indicates the block is not a place of interest corresponding to

src/Air/Legalize.zig+1-1

...	@@ -622,7 +622,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void {	...	@@ -622,7 +622,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void {
622	.addrspace_cast,	622	.addrspace_cast,
623	.save_err_return_trace_index,	623	.save_err_return_trace_index,
624	.vector_store_elem,	624	.vector_store_elem,
625	.tlv_dllimport_ptr,	625	.runtime_nav_ptr,
626	.c_va_arg,	626	.c_va_arg,
627	.c_va_copy,	627	.c_va_copy,
628	.c_va_end,	628	.c_va_end,

src/Air/Liveness.zig+2-2

...	@@ -339,7 +339,7 @@ pub fn categorizeOperand(	...	@@ -339,7 +339,7 @@ pub fn categorizeOperand(
339	.wasm_memory_size,	339	.wasm_memory_size,
340	.err_return_trace,	340	.err_return_trace,
341	.save_err_return_trace_index,	341	.save_err_return_trace_index,
342	.tlv_dllimport_ptr,	342	.runtime_nav_ptr,
343	.c_va_start,	343	.c_va_start,
344	.work_item_id,	344	.work_item_id,
345	.work_group_size,	345	.work_group_size,
...	@@ -972,7 +972,7 @@ fn analyzeInst(	...	@@ -972,7 +972,7 @@ fn analyzeInst(
972	.wasm_memory_size,	972	.wasm_memory_size,
973	.err_return_trace,	973	.err_return_trace,
974	.save_err_return_trace_index,	974	.save_err_return_trace_index,
975	.tlv_dllimport_ptr,	975	.runtime_nav_ptr,
976	.c_va_start,	976	.c_va_start,
977	.work_item_id,	977	.work_item_id,
978	.work_group_size,	978	.work_group_size,

src/Air/Liveness/Verify.zig+1-1

...	@@ -63,7 +63,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {	...	@@ -63,7 +63,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
63	.wasm_memory_size,	63	.wasm_memory_size,
64	.err_return_trace,	64	.err_return_trace,
65	.save_err_return_trace_index,	65	.save_err_return_trace_index,
66	.tlv_dllimport_ptr,	66	.runtime_nav_ptr,
67	.c_va_start,	67	.c_va_start,
68	.work_item_id,	68	.work_item_id,
69	.work_group_size,	69	.work_group_size,

src/Air/print.zig created+1041

...	@@ -0,0 +1,1041 @@
1	const std = @import("std");
2	const Allocator = std.mem.Allocator;
3	const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
4
5	const build_options = @import("build_options");
6	const Zcu = @import("../Zcu.zig");
7	const Value = @import("../Value.zig");
8	const Type = @import("../Type.zig");
9	const Air = @import("../Air.zig");
10	const InternPool = @import("../InternPool.zig");
11
12	pub fn write(air: Air, stream: anytype, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
13	comptime std.debug.assert(build_options.enable_debug_extensions);
14	const instruction_bytes = air.instructions.len *
15	// Here we don't use @sizeOf(Air.Inst.Data) because it would include
16	// the debug safety tag but we want to measure release size.
17	(@sizeOf(Air.Inst.Tag) + 8);
18	const extra_bytes = air.extra.items.len * @sizeOf(u32);
19	const tomb_bytes = if (liveness) \|l\| l.tomb_bits.len * @sizeOf(usize) else 0;
20	const liveness_extra_bytes = if (liveness) \|l\| l.extra.len * @sizeOf(u32) else 0;
21	const liveness_special_bytes = if (liveness) \|l\| l.special.count() * 8 else 0;
22	const total_bytes = @sizeOf(Air) + instruction_bytes + extra_bytes +
23	@sizeOf(Air.Liveness) + liveness_extra_bytes +
24	liveness_special_bytes + tomb_bytes;
25
26	// zig fmt: off
27	stream.print(
28	\\# Total AIR+Liveness bytes: {}
29	\\# AIR Instructions: {d} ({})
30	\\# AIR Extra Data: {d} ({})
31	\\# Liveness tomb_bits: {}
32	\\# Liveness Extra Data: {d} ({})
33	\\# Liveness special table: {d} ({})
34	\\
35	, .{
36	fmtIntSizeBin(total_bytes),
37	air.instructions.len, fmtIntSizeBin(instruction_bytes),
38	air.extra.items.len, fmtIntSizeBin(extra_bytes),
39	fmtIntSizeBin(tomb_bytes),
40	if (liveness) \|l\| l.extra.len else 0, fmtIntSizeBin(liveness_extra_bytes),
41	if (liveness) \|l\| l.special.count() else 0, fmtIntSizeBin(liveness_special_bytes),
42	}) catch return;
43	// zig fmt: on
44
45	var writer: Writer = .{
46	.pt = pt,
47	.gpa = pt.zcu.gpa,
48	.air = air,
49	.liveness = liveness,
50	.indent = 2,
51	.skip_body = false,
52	};
53	writer.writeBody(stream, air.getMainBody()) catch return;
54	}
55
56	pub fn writeInst(
57	air: Air,
58	stream: anytype,
59	inst: Air.Inst.Index,
60	pt: Zcu.PerThread,
61	liveness: ?Air.Liveness,
62	) void {
63	comptime std.debug.assert(build_options.enable_debug_extensions);
64	var writer: Writer = .{
65	.pt = pt,
66	.gpa = pt.zcu.gpa,
67	.air = air,
68	.liveness = liveness,
69	.indent = 2,
70	.skip_body = true,
71	};
72	writer.writeInst(stream, inst) catch return;
73	}
74
75	pub fn dump(air: Air, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
76	air.write(std.io.getStdErr().writer(), pt, liveness);
77	}
78
79	pub fn dumpInst(air: Air, inst: Air.Inst.Index, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
80	air.writeInst(std.io.getStdErr().writer(), inst, pt, liveness);
81	}
82
83	const Writer = struct {
84	pt: Zcu.PerThread,
85	gpa: Allocator,
86	air: Air,
87	liveness: ?Air.Liveness,
88	indent: usize,
89	skip_body: bool,
90
91	fn writeBody(w: *Writer, s: anytype, body: []const Air.Inst.Index) @TypeOf(s).Error!void {
92	for (body) \|inst\| {
93	try w.writeInst(s, inst);
94	try s.writeByte('\n');
95	}
96	}
97
98	fn writeInst(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
99	const tag = w.air.instructions.items(.tag)[@intFromEnum(inst)];
100	try s.writeByteNTimes(' ', w.indent);
101	try s.print("{}{c}= {s}(", .{
102	inst,
103	@as(u8, if (if (w.liveness) \|liveness\| liveness.isUnused(inst) else false) '!' else ' '),
104	@tagName(tag),
105	});
106	switch (tag) {
107	.add,
108	.add_optimized,
109	.add_safe,
110	.add_wrap,
111	.add_sat,
112	.sub,
113	.sub_optimized,
114	.sub_safe,
115	.sub_wrap,
116	.sub_sat,
117	.mul,
118	.mul_optimized,
119	.mul_safe,
120	.mul_wrap,
121	.mul_sat,
122	.div_float,
123	.div_trunc,
124	.div_floor,
125	.div_exact,
126	.rem,
127	.mod,
128	.bit_and,
129	.bit_or,
130	.xor,
131	.cmp_lt,
132	.cmp_lte,
133	.cmp_eq,
134	.cmp_gte,
135	.cmp_gt,
136	.cmp_neq,
137	.bool_and,
138	.bool_or,
139	.store,
140	.store_safe,
141	.array_elem_val,
142	.slice_elem_val,
143	.ptr_elem_val,
144	.shl,
145	.shl_exact,
146	.shl_sat,
147	.shr,
148	.shr_exact,
149	.set_union_tag,
150	.min,
151	.max,
152	.div_float_optimized,
153	.div_trunc_optimized,
154	.div_floor_optimized,
155	.div_exact_optimized,
156	.rem_optimized,
157	.mod_optimized,
158	.cmp_lt_optimized,
159	.cmp_lte_optimized,
160	.cmp_eq_optimized,
161	.cmp_gte_optimized,
162	.cmp_gt_optimized,
163	.cmp_neq_optimized,
164	.memcpy,
165	.memmove,
166	.memset,
167	.memset_safe,
168	=> try w.writeBinOp(s, inst),
169
170	.is_null,
171	.is_non_null,
172	.is_null_ptr,
173	.is_non_null_ptr,
174	.is_err,
175	.is_non_err,
176	.is_err_ptr,
177	.is_non_err_ptr,
178	.ret,
179	.ret_safe,
180	.ret_load,
181	.is_named_enum_value,
182	.tag_name,
183	.error_name,
184	.sqrt,
185	.sin,
186	.cos,
187	.tan,
188	.exp,
189	.exp2,
190	.log,
191	.log2,
192	.log10,
193	.floor,
194	.ceil,
195	.round,
196	.trunc_float,
197	.neg,
198	.neg_optimized,
199	.cmp_lt_errors_len,
200	.set_err_return_trace,
201	.c_va_end,
202	=> try w.writeUnOp(s, inst),
203
204	.trap,
205	.breakpoint,
206	.dbg_empty_stmt,
207	.unreach,
208	.ret_addr,
209	.frame_addr,
210	.save_err_return_trace_index,
211	=> try w.writeNoOp(s, inst),
212
213	.alloc,
214	.ret_ptr,
215	.err_return_trace,
216	.c_va_start,
217	=> try w.writeTy(s, inst),
218
219	.arg => try w.writeArg(s, inst),
220
221	.not,
222	.bitcast,
223	.load,
224	.fptrunc,
225	.fpext,
226	.intcast,
227	.intcast_safe,
228	.trunc,
229	.optional_payload,
230	.optional_payload_ptr,
231	.optional_payload_ptr_set,
232	.errunion_payload_ptr_set,
233	.wrap_optional,
234	.unwrap_errunion_payload,
235	.unwrap_errunion_err,
236	.unwrap_errunion_payload_ptr,
237	.unwrap_errunion_err_ptr,
238	.wrap_errunion_payload,
239	.wrap_errunion_err,
240	.slice_ptr,
241	.slice_len,
242	.ptr_slice_len_ptr,
243	.ptr_slice_ptr_ptr,
244	.struct_field_ptr_index_0,
245	.struct_field_ptr_index_1,
246	.struct_field_ptr_index_2,
247	.struct_field_ptr_index_3,
248	.array_to_slice,
249	.float_from_int,
250	.splat,
251	.int_from_float,
252	.int_from_float_optimized,
253	.get_union_tag,
254	.clz,
255	.ctz,
256	.popcount,
257	.byte_swap,
258	.bit_reverse,
259	.abs,
260	.error_set_has_value,
261	.addrspace_cast,
262	.c_va_arg,
263	.c_va_copy,
264	=> try w.writeTyOp(s, inst),
265
266	.block, .dbg_inline_block => try w.writeBlock(s, tag, inst),
267
268	.loop => try w.writeLoop(s, inst),
269
270	.slice,
271	.slice_elem_ptr,
272	.ptr_elem_ptr,
273	.ptr_add,
274	.ptr_sub,
275	.add_with_overflow,
276	.sub_with_overflow,
277	.mul_with_overflow,
278	.shl_with_overflow,
279	=> try w.writeTyPlBin(s, inst),
280
281	.call,
282	.call_always_tail,
283	.call_never_tail,
284	.call_never_inline,
285	=> try w.writeCall(s, inst),
286
287	.dbg_var_ptr,
288	.dbg_var_val,
289	.dbg_arg_inline,
290	=> try w.writeDbgVar(s, inst),
291
292	.struct_field_ptr => try w.writeStructField(s, inst),
293	.struct_field_val => try w.writeStructField(s, inst),
294	.inferred_alloc => @panic("TODO"),
295	.inferred_alloc_comptime => @panic("TODO"),
296	.assembly => try w.writeAssembly(s, inst),
297	.dbg_stmt => try w.writeDbgStmt(s, inst),
298
299	.aggregate_init => try w.writeAggregateInit(s, inst),
300	.union_init => try w.writeUnionInit(s, inst),
301	.br => try w.writeBr(s, inst),
302	.switch_dispatch => try w.writeBr(s, inst),
303	.repeat => try w.writeRepeat(s, inst),
304	.cond_br => try w.writeCondBr(s, inst),
305	.@"try", .try_cold => try w.writeTry(s, inst),
306	.try_ptr, .try_ptr_cold => try w.writeTryPtr(s, inst),
307	.loop_switch_br, .switch_br => try w.writeSwitchBr(s, inst),
308	.cmpxchg_weak, .cmpxchg_strong => try w.writeCmpxchg(s, inst),
309	.atomic_load => try w.writeAtomicLoad(s, inst),
310	.prefetch => try w.writePrefetch(s, inst),
311	.atomic_store_unordered => try w.writeAtomicStore(s, inst, .unordered),
312	.atomic_store_monotonic => try w.writeAtomicStore(s, inst, .monotonic),
313	.atomic_store_release => try w.writeAtomicStore(s, inst, .release),
314	.atomic_store_seq_cst => try w.writeAtomicStore(s, inst, .seq_cst),
315	.atomic_rmw => try w.writeAtomicRmw(s, inst),
316	.field_parent_ptr => try w.writeFieldParentPtr(s, inst),
317	.wasm_memory_size => try w.writeWasmMemorySize(s, inst),
318	.wasm_memory_grow => try w.writeWasmMemoryGrow(s, inst),
319	.mul_add => try w.writeMulAdd(s, inst),
320	.select => try w.writeSelect(s, inst),
321	.shuffle_one => try w.writeShuffleOne(s, inst),
322	.shuffle_two => try w.writeShuffleTwo(s, inst),
323	.reduce, .reduce_optimized => try w.writeReduce(s, inst),
324	.cmp_vector, .cmp_vector_optimized => try w.writeCmpVector(s, inst),
325	.vector_store_elem => try w.writeVectorStoreElem(s, inst),
326	.runtime_nav_ptr => try w.writeRuntimeNavPtr(s, inst),
327
328	.work_item_id,
329	.work_group_size,
330	.work_group_id,
331	=> try w.writeWorkDimension(s, inst),
332	}
333	try s.writeByte(')');
334	}
335
336	fn writeBinOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
337	const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
338	try w.writeOperand(s, inst, 0, bin_op.lhs);
339	try s.writeAll(", ");
340	try w.writeOperand(s, inst, 1, bin_op.rhs);
341	}
342
343	fn writeUnOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
344	const un_op = w.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
345	try w.writeOperand(s, inst, 0, un_op);
346	}
347
348	fn writeNoOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
349	_ = w;
350	_ = inst;
351	// no-op, no argument to write
352	}
353
354	fn writeType(w: *Writer, s: anytype, ty: Type) !void {
355	return ty.print(s, w.pt);
356	}
357
358	fn writeTy(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
359	const ty = w.air.instructions.items(.data)[@intFromEnum(inst)].ty;
360	try w.writeType(s, ty);
361	}
362
363	fn writeArg(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
364	const arg = w.air.instructions.items(.data)[@intFromEnum(inst)].arg;
365	try w.writeType(s, arg.ty.toType());
366	switch (arg.name) {
367	.none => {},
368	_ => try s.print(", \"{}\"", .{std.zig.fmtEscapes(arg.name.toSlice(w.air))}),
369	}
370	}
371
372	fn writeTyOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
373	const ty_op = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
374	try w.writeType(s, ty_op.ty.toType());
375	try s.writeAll(", ");
376	try w.writeOperand(s, inst, 0, ty_op.operand);
377	}
378
379	fn writeBlock(w: *Writer, s: anytype, tag: Air.Inst.Tag, inst: Air.Inst.Index) @TypeOf(s).Error!void {
380	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
381	try w.writeType(s, ty_pl.ty.toType());
382	const body: []const Air.Inst.Index = @ptrCast(switch (tag) {
383	inline .block, .dbg_inline_block => \|comptime_tag\| body: {
384	const extra = w.air.extraData(switch (comptime_tag) {
385	.block => Air.Block,
386	.dbg_inline_block => Air.DbgInlineBlock,
387	else => unreachable,
388	}, ty_pl.payload);
389	switch (comptime_tag) {
390	.block => {},
391	.dbg_inline_block => {
392	try s.writeAll(", ");
393	try w.writeInstRef(s, Air.internedToRef(extra.data.func), false);
394	},
395	else => unreachable,
396	}
397	break :body w.air.extra.items[extra.end..][0..extra.data.body_len];
398	},
399	else => unreachable,
400	});
401	if (w.skip_body) return s.writeAll(", ...");
402	const liveness_block: Air.Liveness.BlockSlices = if (w.liveness) \|liveness\|
403	liveness.getBlock(inst)
404	else
405	.{ .deaths = &.{} };
406
407	try s.writeAll(", {\n");
408	const old_indent = w.indent;
409	w.indent += 2;
410	try w.writeBody(s, body);
411	w.indent = old_indent;
412	try s.writeByteNTimes(' ', w.indent);
413	try s.writeAll("}");
414
415	for (liveness_block.deaths) \|operand\| {
416	try s.print(" {}!", .{operand});
417	}
418	}
419
420	fn writeLoop(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
421	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
422	const extra = w.air.extraData(Air.Block, ty_pl.payload);
423	const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
424
425	try w.writeType(s, ty_pl.ty.toType());
426	if (w.skip_body) return s.writeAll(", ...");
427	try s.writeAll(", {\n");
428	const old_indent = w.indent;
429	w.indent += 2;
430	try w.writeBody(s, body);
431	w.indent = old_indent;
432	try s.writeByteNTimes(' ', w.indent);
433	try s.writeAll("}");
434	}
435
436	fn writeAggregateInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
437	const zcu = w.pt.zcu;
438	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
439	const vector_ty = ty_pl.ty.toType();
440	const len = @as(usize, @intCast(vector_ty.arrayLen(zcu)));
441	const elements = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[ty_pl.payload..][0..len]));
442
443	try w.writeType(s, vector_ty);
444	try s.writeAll(", [");
445	for (elements, 0..) \|elem, i\| {
446	if (i != 0) try s.writeAll(", ");
447	try w.writeOperand(s, inst, i, elem);
448	}
449	try s.writeAll("]");
450	}
451
452	fn writeUnionInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
453	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
454	const extra = w.air.extraData(Air.UnionInit, ty_pl.payload).data;
455
456	try s.print("{d}, ", .{extra.field_index});
457	try w.writeOperand(s, inst, 0, extra.init);
458	}
459
460	fn writeStructField(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
461	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
462	const extra = w.air.extraData(Air.StructField, ty_pl.payload).data;
463
464	try w.writeOperand(s, inst, 0, extra.struct_operand);
465	try s.print(", {d}", .{extra.field_index});
466	}
467
468	fn writeTyPlBin(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
469	const data = w.air.instructions.items(.data);
470	const ty_pl = data[@intFromEnum(inst)].ty_pl;
471	const extra = w.air.extraData(Air.Bin, ty_pl.payload).data;
472
473	const inst_ty = data[@intFromEnum(inst)].ty_pl.ty.toType();
474	try w.writeType(s, inst_ty);
475	try s.writeAll(", ");
476	try w.writeOperand(s, inst, 0, extra.lhs);
477	try s.writeAll(", ");
478	try w.writeOperand(s, inst, 1, extra.rhs);
479	}
480
481	fn writeCmpxchg(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
482	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
483	const extra = w.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
484
485	try w.writeOperand(s, inst, 0, extra.ptr);
486	try s.writeAll(", ");
487	try w.writeOperand(s, inst, 1, extra.expected_value);
488	try s.writeAll(", ");
489	try w.writeOperand(s, inst, 2, extra.new_value);
490	try s.print(", {s}, {s}", .{
491	@tagName(extra.successOrder()), @tagName(extra.failureOrder()),
492	});
493	}
494
495	fn writeMulAdd(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
496	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
497	const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
498
499	try w.writeOperand(s, inst, 0, extra.lhs);
500	try s.writeAll(", ");
501	try w.writeOperand(s, inst, 1, extra.rhs);
502	try s.writeAll(", ");
503	try w.writeOperand(s, inst, 2, pl_op.operand);
504	}
505
506	fn writeShuffleOne(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
507	const unwrapped = w.air.unwrapShuffleOne(w.pt.zcu, inst);
508	try w.writeType(s, unwrapped.result_ty);
509	try s.writeAll(", ");
510	try w.writeOperand(s, inst, 0, unwrapped.operand);
511	try s.writeAll(", [");
512	for (unwrapped.mask, 0..) \|mask_elem, mask_idx\| {
513	if (mask_idx > 0) try s.writeAll(", ");
514	switch (mask_elem.unwrap()) {
515	.elem => \|idx\| try s.print("elem {d}", .{idx}),
516	.value => \|val\| try s.print("val {}", .{Value.fromInterned(val).fmtValue(w.pt)}),
517	}
518	}
519	try s.writeByte(']');
520	}
521
522	fn writeShuffleTwo(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
523	const unwrapped = w.air.unwrapShuffleTwo(w.pt.zcu, inst);
524	try w.writeType(s, unwrapped.result_ty);
525	try s.writeAll(", ");
526	try w.writeOperand(s, inst, 0, unwrapped.operand_a);
527	try s.writeAll(", ");
528	try w.writeOperand(s, inst, 1, unwrapped.operand_b);
529	try s.writeAll(", [");
530	for (unwrapped.mask, 0..) \|mask_elem, mask_idx\| {
531	if (mask_idx > 0) try s.writeAll(", ");
532	switch (mask_elem.unwrap()) {
533	.a_elem => \|idx\| try s.print("a_elem {d}", .{idx}),
534	.b_elem => \|idx\| try s.print("b_elem {d}", .{idx}),
535	.undef => try s.writeAll("undef"),
536	}
537	}
538	try s.writeByte(']');
539	}
540
541	fn writeSelect(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
542	const zcu = w.pt.zcu;
543	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
544	const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
545
546	const elem_ty = w.typeOfIndex(inst).childType(zcu);
547	try w.writeType(s, elem_ty);
548	try s.writeAll(", ");
549	try w.writeOperand(s, inst, 0, pl_op.operand);
550	try s.writeAll(", ");
551	try w.writeOperand(s, inst, 1, extra.lhs);
552	try s.writeAll(", ");
553	try w.writeOperand(s, inst, 2, extra.rhs);
554	}
555
556	fn writeReduce(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
557	const reduce = w.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
558
559	try w.writeOperand(s, inst, 0, reduce.operand);
560	try s.print(", {s}", .{@tagName(reduce.operation)});
561	}
562
563	fn writeCmpVector(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
564	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
565	const extra = w.air.extraData(Air.VectorCmp, ty_pl.payload).data;
566
567	try s.print("{s}, ", .{@tagName(extra.compareOperator())});
568	try w.writeOperand(s, inst, 0, extra.lhs);
569	try s.writeAll(", ");
570	try w.writeOperand(s, inst, 1, extra.rhs);
571	}
572
573	fn writeVectorStoreElem(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
574	const data = w.air.instructions.items(.data)[@intFromEnum(inst)].vector_store_elem;
575	const extra = w.air.extraData(Air.VectorCmp, data.payload).data;
576
577	try w.writeOperand(s, inst, 0, data.vector_ptr);
578	try s.writeAll(", ");
579	try w.writeOperand(s, inst, 1, extra.lhs);
580	try s.writeAll(", ");
581	try w.writeOperand(s, inst, 2, extra.rhs);
582	}
583
584	fn writeRuntimeNavPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
585	const ip = &w.pt.zcu.intern_pool;
586	const ty_nav = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
587	try w.writeType(s, .fromInterned(ty_nav.ty));
588	try s.print(", '{}'", .{ip.getNav(ty_nav.nav).fqn.fmt(ip)});
589	}
590
591	fn writeAtomicLoad(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
592	const atomic_load = w.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
593
594	try w.writeOperand(s, inst, 0, atomic_load.ptr);
595	try s.print(", {s}", .{@tagName(atomic_load.order)});
596	}
597
598	fn writePrefetch(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
599	const prefetch = w.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
600
601	try w.writeOperand(s, inst, 0, prefetch.ptr);
602	try s.print(", {s}, {d}, {s}", .{
603	@tagName(prefetch.rw), prefetch.locality, @tagName(prefetch.cache),
604	});
605	}
606
607	fn writeAtomicStore(
608	w: *Writer,
609	s: anytype,
610	inst: Air.Inst.Index,
611	order: std.builtin.AtomicOrder,
612	) @TypeOf(s).Error!void {
613	const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
614	try w.writeOperand(s, inst, 0, bin_op.lhs);
615	try s.writeAll(", ");
616	try w.writeOperand(s, inst, 1, bin_op.rhs);
617	try s.print(", {s}", .{@tagName(order)});
618	}
619
620	fn writeAtomicRmw(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
621	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
622	const extra = w.air.extraData(Air.AtomicRmw, pl_op.payload).data;
623
624	try w.writeOperand(s, inst, 0, pl_op.operand);
625	try s.writeAll(", ");
626	try w.writeOperand(s, inst, 1, extra.operand);
627	try s.print(", {s}, {s}", .{ @tagName(extra.op()), @tagName(extra.ordering()) });
628	}
629
630	fn writeFieldParentPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
631	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
632	const extra = w.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
633
634	try w.writeOperand(s, inst, 0, extra.field_ptr);
635	try s.print(", {d}", .{extra.field_index});
636	}
637
638	fn writeAssembly(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
639	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
640	const extra = w.air.extraData(Air.Asm, ty_pl.payload);
641	const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
642	const clobbers_len = @as(u31, @truncate(extra.data.flags));
643	var extra_i: usize = extra.end;
644	var op_index: usize = 0;
645
646	const ret_ty = w.typeOfIndex(inst);
647	try w.writeType(s, ret_ty);
648
649	if (is_volatile) {
650	try s.writeAll(", volatile");
651	}
652
653	const outputs = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra_i..][0..extra.data.outputs_len]));
654	extra_i += outputs.len;
655	const inputs = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra_i..][0..extra.data.inputs_len]));
656	extra_i += inputs.len;
657
658	for (outputs) \|output\| {
659	const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
660	const constraint = std.mem.sliceTo(extra_bytes, 0);
661	const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
662
663	// This equation accounts for the fact that even if we have exactly 4 bytes
664	// for the strings and their null terminators, we still use the next u32
665	// for the null terminator.
666	extra_i += (constraint.len + name.len + (2 + 3)) / 4;
667
668	if (output == .none) {
669	try s.print(", [{s}] -> {s}", .{ name, constraint });
670	} else {
671	try s.print(", [{s}] out {s} = (", .{ name, constraint });
672	try w.writeOperand(s, inst, op_index, output);
673	op_index += 1;
674	try s.writeByte(')');
675	}
676	}
677
678	for (inputs) \|input\| {
679	const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
680	const constraint = std.mem.sliceTo(extra_bytes, 0);
681	const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
682	// This equation accounts for the fact that even if we have exactly 4 bytes
683	// for the strings and their null terminators, we still use the next u32
684	// for the null terminator.
685	extra_i += (constraint.len + name.len + 1) / 4 + 1;
686
687	try s.print(", [{s}] in {s} = (", .{ name, constraint });
688	try w.writeOperand(s, inst, op_index, input);
689	op_index += 1;
690	try s.writeByte(')');
691	}
692
693	{
694	var clobber_i: u32 = 0;
695	while (clobber_i < clobbers_len) : (clobber_i += 1) {
696	const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
697	const clobber = std.mem.sliceTo(extra_bytes, 0);
698	// This equation accounts for the fact that even if we have exactly 4 bytes
699	// for the string, we still use the next u32 for the null terminator.
700	extra_i += clobber.len / 4 + 1;
701
702	try s.writeAll(", ~{");
703	try s.writeAll(clobber);
704	try s.writeAll("}");
705	}
706	}
707	const asm_source = std.mem.sliceAsBytes(w.air.extra.items[extra_i..])[0..extra.data.source_len];
708	try s.print(", \"{}\"", .{std.zig.fmtEscapes(asm_source)});
709	}
710
711	fn writeDbgStmt(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
712	const dbg_stmt = w.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
713	try s.print("{d}:{d}", .{ dbg_stmt.line + 1, dbg_stmt.column + 1 });
714	}
715
716	fn writeDbgVar(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
717	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
718	try w.writeOperand(s, inst, 0, pl_op.operand);
719	const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
720	try s.print(", \"{}\"", .{std.zig.fmtEscapes(name.toSlice(w.air))});
721	}
722
723	fn writeCall(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
724	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
725	const extra = w.air.extraData(Air.Call, pl_op.payload);
726	const args = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra.end..][0..extra.data.args_len]));
727	try w.writeOperand(s, inst, 0, pl_op.operand);
728	try s.writeAll(", [");
729	for (args, 0..) \|arg, i\| {
730	if (i != 0) try s.writeAll(", ");
731	try w.writeOperand(s, inst, 1 + i, arg);
732	}
733	try s.writeAll("]");
734	}
735
736	fn writeBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
737	const br = w.air.instructions.items(.data)[@intFromEnum(inst)].br;
738	try w.writeInstIndex(s, br.block_inst, false);
739	try s.writeAll(", ");
740	try w.writeOperand(s, inst, 0, br.operand);
741	}
742
743	fn writeRepeat(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
744	const repeat = w.air.instructions.items(.data)[@intFromEnum(inst)].repeat;
745	try w.writeInstIndex(s, repeat.loop_inst, false);
746	}
747
748	fn writeTry(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
749	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
750	const extra = w.air.extraData(Air.Try, pl_op.payload);
751	const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
752	const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) \|liveness\|
753	liveness.getCondBr(inst)
754	else
755	.{ .then_deaths = &.{}, .else_deaths = &.{} };
756
757	try w.writeOperand(s, inst, 0, pl_op.operand);
758	if (w.skip_body) return s.writeAll(", ...");
759	try s.writeAll(", {\n");
760	const old_indent = w.indent;
761	w.indent += 2;
762
763	if (liveness_condbr.else_deaths.len != 0) {
764	try s.writeByteNTimes(' ', w.indent);
765	for (liveness_condbr.else_deaths, 0..) \|operand, i\| {
766	if (i != 0) try s.writeAll(" ");
767	try s.print("{}!", .{operand});
768	}
769	try s.writeAll("\n");
770	}
771	try w.writeBody(s, body);
772
773	w.indent = old_indent;
774	try s.writeByteNTimes(' ', w.indent);
775	try s.writeAll("}");
776
777	for (liveness_condbr.then_deaths) \|operand\| {
778	try s.print(" {}!", .{operand});
779	}
780	}
781
782	fn writeTryPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
783	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
784	const extra = w.air.extraData(Air.TryPtr, ty_pl.payload);
785	const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
786	const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) \|liveness\|
787	liveness.getCondBr(inst)
788	else
789	.{ .then_deaths = &.{}, .else_deaths = &.{} };
790
791	try w.writeOperand(s, inst, 0, extra.data.ptr);
792
793	try s.writeAll(", ");
794	try w.writeType(s, ty_pl.ty.toType());
795	if (w.skip_body) return s.writeAll(", ...");
796	try s.writeAll(", {\n");
797	const old_indent = w.indent;
798	w.indent += 2;
799
800	if (liveness_condbr.else_deaths.len != 0) {
801	try s.writeByteNTimes(' ', w.indent);
802	for (liveness_condbr.else_deaths, 0..) \|operand, i\| {
803	if (i != 0) try s.writeAll(" ");
804	try s.print("{}!", .{operand});
805	}
806	try s.writeAll("\n");
807	}
808	try w.writeBody(s, body);
809
810	w.indent = old_indent;
811	try s.writeByteNTimes(' ', w.indent);
812	try s.writeAll("}");
813
814	for (liveness_condbr.then_deaths) \|operand\| {
815	try s.print(" {}!", .{operand});
816	}
817	}
818
819	fn writeCondBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
820	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
821	const extra = w.air.extraData(Air.CondBr, pl_op.payload);
822	const then_body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.then_body_len]);
823	const else_body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
824	const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) \|liveness\|
825	liveness.getCondBr(inst)
826	else
827	.{ .then_deaths = &.{}, .else_deaths = &.{} };
828
829	try w.writeOperand(s, inst, 0, pl_op.operand);
830	if (w.skip_body) return s.writeAll(", ...");
831	try s.writeAll(",");
832	if (extra.data.branch_hints.true != .none) {
833	try s.print(" {s}", .{@tagName(extra.data.branch_hints.true)});
834	}
835	if (extra.data.branch_hints.then_cov != .none) {
836	try s.print(" {s}", .{@tagName(extra.data.branch_hints.then_cov)});
837	}
838	try s.writeAll(" {\n");
839	const old_indent = w.indent;
840	w.indent += 2;
841
842	if (liveness_condbr.then_deaths.len != 0) {
843	try s.writeByteNTimes(' ', w.indent);
844	for (liveness_condbr.then_deaths, 0..) \|operand, i\| {
845	if (i != 0) try s.writeAll(" ");
846	try s.print("{}!", .{operand});
847	}
848	try s.writeAll("\n");
849	}
850
851	try w.writeBody(s, then_body);
852	try s.writeByteNTimes(' ', old_indent);
853	try s.writeAll("},");
854	if (extra.data.branch_hints.false != .none) {
855	try s.print(" {s}", .{@tagName(extra.data.branch_hints.false)});
856	}
857	if (extra.data.branch_hints.else_cov != .none) {
858	try s.print(" {s}", .{@tagName(extra.data.branch_hints.else_cov)});
859	}
860	try s.writeAll(" {\n");
861
862	if (liveness_condbr.else_deaths.len != 0) {
863	try s.writeByteNTimes(' ', w.indent);
864	for (liveness_condbr.else_deaths, 0..) \|operand, i\| {
865	if (i != 0) try s.writeAll(" ");
866	try s.print("{}!", .{operand});
867	}
868	try s.writeAll("\n");
869	}
870
871	try w.writeBody(s, else_body);
872	w.indent = old_indent;
873
874	try s.writeByteNTimes(' ', old_indent);
875	try s.writeAll("}");
876	}
877
878	fn writeSwitchBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
879	const switch_br = w.air.unwrapSwitch(inst);
880
881	const liveness: Air.Liveness.SwitchBrTable = if (w.liveness) \|liveness\|
882	liveness.getSwitchBr(w.gpa, inst, switch_br.cases_len + 1) catch
883	@panic("out of memory")
884	else blk: {
885	const slice = w.gpa.alloc([]const Air.Inst.Index, switch_br.cases_len + 1) catch
886	@panic("out of memory");
887	@memset(slice, &.{});
888	break :blk .{ .deaths = slice };
889	};
890	defer w.gpa.free(liveness.deaths);
891
892	try w.writeOperand(s, inst, 0, switch_br.operand);
893	if (w.skip_body) return s.writeAll(", ...");
894	const old_indent = w.indent;
895	w.indent += 2;
896
897	var it = switch_br.iterateCases();
898	while (it.next()) \|case\| {
899	try s.writeAll(", [");
900	for (case.items, 0..) \|item, item_i\| {
901	if (item_i != 0) try s.writeAll(", ");
902	try w.writeInstRef(s, item, false);
903	}
904	for (case.ranges, 0..) \|range, range_i\| {
905	if (range_i != 0 or case.items.len != 0) try s.writeAll(", ");
906	try w.writeInstRef(s, range[0], false);
907	try s.writeAll("...");
908	try w.writeInstRef(s, range[1], false);
909	}
910	try s.writeAll("] ");
911	const hint = switch_br.getHint(case.idx);
912	if (hint != .none) {
913	try s.print(".{s} ", .{@tagName(hint)});
914	}
915	try s.writeAll("=> {\n");
916	w.indent += 2;
917
918	const deaths = liveness.deaths[case.idx];
919	if (deaths.len != 0) {
920	try s.writeByteNTimes(' ', w.indent);
921	for (deaths, 0..) \|operand, i\| {
922	if (i != 0) try s.writeAll(" ");
923	try s.print("{}!", .{operand});
924	}
925	try s.writeAll("\n");
926	}
927
928	try w.writeBody(s, case.body);
929	w.indent -= 2;
930	try s.writeByteNTimes(' ', w.indent);
931	try s.writeAll("}");
932	}
933
934	const else_body = it.elseBody();
935	if (else_body.len != 0) {
936	try s.writeAll(", else ");
937	const hint = switch_br.getElseHint();
938	if (hint != .none) {
939	try s.print(".{s} ", .{@tagName(hint)});
940	}
941	try s.writeAll("=> {\n");
942	w.indent += 2;
943
944	const deaths = liveness.deaths[liveness.deaths.len - 1];
945	if (deaths.len != 0) {
946	try s.writeByteNTimes(' ', w.indent);
947	for (deaths, 0..) \|operand, i\| {
948	if (i != 0) try s.writeAll(" ");
949	try s.print("{}!", .{operand});
950	}
951	try s.writeAll("\n");
952	}
953
954	try w.writeBody(s, else_body);
955	w.indent -= 2;
956	try s.writeByteNTimes(' ', w.indent);
957	try s.writeAll("}");
958	}
959
960	try s.writeAll("\n");
961	try s.writeByteNTimes(' ', old_indent);
962	}
963
964	fn writeWasmMemorySize(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
965	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
966	try s.print("{d}", .{pl_op.payload});
967	}
968
969	fn writeWasmMemoryGrow(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
970	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
971	try s.print("{d}, ", .{pl_op.payload});
972	try w.writeOperand(s, inst, 0, pl_op.operand);
973	}
974
975	fn writeWorkDimension(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
976	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
977	try s.print("{d}", .{pl_op.payload});
978	}
979
980	fn writeOperand(
981	w: *Writer,
982	s: anytype,
983	inst: Air.Inst.Index,
984	op_index: usize,
985	operand: Air.Inst.Ref,
986	) @TypeOf(s).Error!void {
987	const small_tomb_bits = Air.Liveness.bpi - 1;
988	const dies = if (w.liveness) \|liveness\| blk: {
989	if (op_index < small_tomb_bits)
990	break :blk liveness.operandDies(inst, @intCast(op_index));
991	var extra_index = liveness.special.get(inst).?;
992	var tomb_op_index: usize = small_tomb_bits;
993	while (true) {
994	const bits = liveness.extra[extra_index];
995	if (op_index < tomb_op_index + 31) {
996	break :blk @as(u1, @truncate(bits >> @as(u5, @intCast(op_index - tomb_op_index)))) != 0;
997	}
998	if ((bits >> 31) != 0) break :blk false;
999	extra_index += 1;
1000	tomb_op_index += 31;
1001	}
1002	} else false;
1003	return w.writeInstRef(s, operand, dies);
1004	}
1005
1006	fn writeInstRef(
1007	w: *Writer,
1008	s: anytype,
1009	operand: Air.Inst.Ref,
1010	dies: bool,
1011	) @TypeOf(s).Error!void {
1012	if (@intFromEnum(operand) < InternPool.static_len) {
1013	return s.print("@{}", .{operand});
1014	} else if (operand.toInterned()) \|ip_index\| {
1015	const pt = w.pt;
1016	const ty = Type.fromInterned(pt.zcu.intern_pool.indexToKey(ip_index).typeOf());
1017	try s.print("<{}, {}>", .{
1018	ty.fmt(pt),
1019	Value.fromInterned(ip_index).fmtValue(pt),
1020	});
1021	} else {
1022	return w.writeInstIndex(s, operand.toIndex().?, dies);
1023	}
1024	}
1025
1026	fn writeInstIndex(
1027	w: *Writer,
1028	s: anytype,
1029	inst: Air.Inst.Index,
1030	dies: bool,
1031	) @TypeOf(s).Error!void {
1032	_ = w;
1033	try s.print("{}", .{inst});
1034	if (dies) try s.writeByte('!');
1035	}
1036
1037	fn typeOfIndex(w: *Writer, inst: Air.Inst.Index) Type {
1038	const zcu = w.pt.zcu;
1039	return w.air.typeOfIndex(inst, &zcu.intern_pool);
1040	}
1041	};

src/Air/types_resolved.zig+1-1

...	@@ -321,7 +321,7 @@ fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {	...	@@ -321,7 +321,7 @@ fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
321	if (!checkRef(bin.rhs, zcu)) return false;	321	if (!checkRef(bin.rhs, zcu)) return false;
322	},	322	},
323		323
324	.tlv_dllimport_ptr => {	324	.runtime_nav_ptr => {
325	if (!checkType(.fromInterned(data.ty_nav.ty), zcu)) return false;	325	if (!checkType(.fromInterned(data.ty_nav.ty), zcu)) return false;
326	},	326	},
327		327

src/Compilation/Config.zig+19-12

...	@@ -345,11 +345,19 @@ pub fn resolve(options: Options) ResolveError!Config {	...	@@ -345,11 +345,19 @@ pub fn resolve(options: Options) ResolveError!Config {
345	} else false;	345	} else false;
346	};	346	};
347		347
		348	const is_dyn_lib = switch (options.output_mode) {
		349	.Obj, .Exe => false,
		350	.Lib => link_mode == .dynamic,
		351	};
		352
348	// Make a decision on whether to use LLVM backend for machine code generation.	353	// Make a decision on whether to use LLVM backend for machine code generation.
349	// Note that using the LLVM backend does not necessarily mean using LLVM libraries.	354	// Note that using the LLVM backend does not necessarily mean using LLVM libraries.
350	// For example, Zig can emit .bc and .ll files directly, and this is still considered	355	// For example, Zig can emit .bc and .ll files directly, and this is still considered
351	// using "the LLVM backend".	356	// using "the LLVM backend".
352	const prefer_llvm = b: {	357	const use_llvm = b: {
		358	// If we have no zig code to compile, no need for LLVM.
		359	if (!options.have_zcu) break :b false;
		360
353	// If emitting to LLVM bitcode object format, must use LLVM backend.	361	// If emitting to LLVM bitcode object format, must use LLVM backend.
354	if (options.emit_llvm_ir or options.emit_llvm_bc) {	362	if (options.emit_llvm_ir or options.emit_llvm_bc) {
355	if (options.use_llvm == false)	363	if (options.use_llvm == false)
...	@@ -382,9 +390,9 @@ pub fn resolve(options: Options) ResolveError!Config {	...	@@ -382,9 +390,9 @@ pub fn resolve(options: Options) ResolveError!Config {
382	// Prefer LLVM for release builds.	390	// Prefer LLVM for release builds.
383	if (root_optimize_mode != .Debug) break :b true;	391	if (root_optimize_mode != .Debug) break :b true;
384		392
385	// Self-hosted backends can't handle the inline assembly in std.pie yet	393	// load_dynamic_library standalone test not passing on this combination
386	// https://github.com/ziglang/zig/issues/24046	394	// https://github.com/ziglang/zig/issues/24080
387	if (pie) break :b true;	395	if (target.os.tag == .macos and is_dyn_lib) break :b true;
388		396
389	// At this point we would prefer to use our own self-hosted backend,	397	// At this point we would prefer to use our own self-hosted backend,
390	// because the compilation speed is better than LLVM. But only do it if	398	// because the compilation speed is better than LLVM. But only do it if
...	@@ -392,13 +400,6 @@ pub fn resolve(options: Options) ResolveError!Config {	...	@@ -392,13 +400,6 @@ pub fn resolve(options: Options) ResolveError!Config {
392	break :b !target_util.selfHostedBackendIsAsRobustAsLlvm(target);	400	break :b !target_util.selfHostedBackendIsAsRobustAsLlvm(target);
393	};	401	};
394		402
395	const use_llvm = b: {
396	// If we have no zig code to compile, no need for LLVM.
397	if (!options.have_zcu) break :b false;
398
399	break :b prefer_llvm;
400	};
401
402	if (options.emit_bin and options.have_zcu) {	403	if (options.emit_bin and options.have_zcu) {
403	if (!use_lib_llvm and use_llvm) {	404	if (!use_lib_llvm and use_llvm) {
404	// Explicit request to use LLVM to produce an object file, but without	405	// Explicit request to use LLVM to produce an object file, but without
...	@@ -435,7 +436,13 @@ pub fn resolve(options: Options) ResolveError!Config {	...	@@ -435,7 +436,13 @@ pub fn resolve(options: Options) ResolveError!Config {
435	}	436	}
436		437
437	if (options.use_lld) \|x\| break :b x;	438	if (options.use_lld) \|x\| break :b x;
438	break :b prefer_llvm;	439
		440	// If we have no zig code to compile, no need for the self-hosted linker.
		441	if (!options.have_zcu) break :b true;
		442
		443	// If we do have zig code, match the decision for whether to use the llvm backend,
		444	// so that the llvm backend defaults to lld and the self-hosted backends do not.
		445	break :b use_llvm;
439	};	446	};
440		447
441	const lto: std.zig.LtoMode = b: {	448	const lto: std.zig.LtoMode = b: {

src/InternPool.zig+71-49

 @@ -526,10 +526,10 @@ pub const Nav = struct {
         /// The type of this `Nav` is resolved; the value is queued for resolution.
         type_resolved: struct {
             type: InternPool.Index,
+            is_const: bool,
             alignment: Alignment,
             @"linksection": OptionalNullTerminatedString,
             @"addrspace": std.builtin.AddressSpace,
-            is_const: bool,
             is_threadlocal: bool,
             /// This field is whether this `Nav` is a literal `extern` definition.
             /// It does *not* tell you whether this might alias an extern fn (see #21027).
 @@ -538,6 +538,7 @@ pub const Nav = struct {
         /// The value of this `Nav` is resolved.
         fully_resolved: struct {
             val: InternPool.Index,
+            is_const: bool,
             alignment: Alignment,
             @"linksection": OptionalNullTerminatedString,
             @"addrspace": std.builtin.AddressSpace,
 @@ -727,12 +728,12 @@ pub const Nav = struct {
         const Bits = packed struct(u16) {
             status: enum(u2) { unresolved, type_resolved, fully_resolved, type_resolved_extern_decl },
             /// Populated only if `bits.status != .unresolved`.
+            is_const: bool,
+            /// Populated only if `bits.status != .unresolved`.
             alignment: Alignment,
             /// Populated only if `bits.status != .unresolved`.
             @"addrspace": std.builtin.AddressSpace,
             /// Populated only if `bits.status == .type_resolved`.
-            is_const: bool,
-            /// Populated only if `bits.status == .type_resolved`.
             is_threadlocal: bool,
             is_usingnamespace: bool,
         };
 @@ -753,15 +754,16 @@ pub const Nav = struct {
                     .unresolved => .unresolved,
                     .type_resolved, .type_resolved_extern_decl => .{ .type_resolved = .{
                         .type = repr.type_or_val,
+                        .is_const = repr.bits.is_const,
                         .alignment = repr.bits.alignment,
                         .@"linksection" = repr.@"linksection",
                         .@"addrspace" = repr.bits.@"addrspace",
-                        .is_const = repr.bits.is_const,
                         .is_threadlocal = repr.bits.is_threadlocal,
                         .is_extern_decl = repr.bits.status == .type_resolved_extern_decl,
                     } },
                     .fully_resolved => .{ .fully_resolved = .{
                         .val = repr.type_or_val,
+                        .is_const = repr.bits.is_const,
                         .alignment = repr.bits.alignment,
                         .@"linksection" = repr.@"linksection",
                         .@"addrspace" = repr.bits.@"addrspace",
 @@ -792,26 +794,26 @@ pub const Nav = struct {
             .bits = switch (nav.status) {
                 .unresolved => .{
                     .status = .unresolved,
+                    .is_const = false,
                     .alignment = .none,
                     .@"addrspace" = .generic,
                     .is_usingnamespace = nav.is_usingnamespace,
-                    .is_const = false,
                     .is_threadlocal = false,
                 },
                 .type_resolved => |r| .{
                     .status = if (r.is_extern_decl) .type_resolved_extern_decl else .type_resolved,
+                    .is_const = r.is_const,
                     .alignment = r.alignment,
                     .@"addrspace" = r.@"addrspace",
                     .is_usingnamespace = nav.is_usingnamespace,
-                    .is_const = r.is_const,
                     .is_threadlocal = r.is_threadlocal,
                 },
                 .fully_resolved => |r| .{
                     .status = .fully_resolved,
+                    .is_const = r.is_const,
                     .alignment = r.alignment,
                     .@"addrspace" = r.@"addrspace",
                     .is_usingnamespace = nav.is_usingnamespace,
-                    .is_const = false,
                     .is_threadlocal = false,
                 },
             },
 @@ -2221,7 +2223,6 @@ pub const Key = union(enum) {
         init: Index,
         owner_nav: Nav.Index,
         is_threadlocal: bool,
-        is_weak_linkage: bool,
     };
     pub const Extern = struct {
 @@ -2234,10 +2235,12 @@ pub const Key = union(enum) {
         /// For example `extern "c" fn write(...) usize` would have 'c' as library name.
         /// Index into the string table bytes.
         lib_name: OptionalNullTerminatedString,
-        is_const: bool,
+        linkage: std.builtin.GlobalLinkage,
+        visibility: std.builtin.SymbolVisibility,
         is_threadlocal: bool,
-        is_weak_linkage: bool,
         is_dll_import: bool,
+        relocation: std.builtin.ExternOptions.Relocation,
+        is_const: bool,
         alignment: Alignment,
         @"addrspace": std.builtin.AddressSpace,
         /// The ZIR instruction which created this extern; used only for source locations.
 @@ -2844,9 +2847,10 @@ pub const Key = union(enum) {
             .@"extern" => |e| Hash.hash(seed, asBytes(&e.name) ++
                 asBytes(&e.ty) ++ asBytes(&e.lib_name) ++
-                asBytes(&e.is_const) ++ asBytes(&e.is_threadlocal) ++
+                asBytes(&e.linkage) ++ asBytes(&e.visibility) ++
-                asBytes(&e.is_weak_linkage) ++ asBytes(&e.alignment) ++
+                asBytes(&e.is_threadlocal) ++ asBytes(&e.is_dll_import) ++
-                asBytes(&e.is_dll_import) ++ asBytes(&e.@"addrspace") ++
+                asBytes(&e.relocation) ++
+                asBytes(&e.is_const) ++ asBytes(&e.alignment) ++ asBytes(&e.@"addrspace") ++
                 asBytes(&e.zir_index)),
         };
     }
 @@ -2928,21 +2932,22 @@ pub const Key = union(enum) {
             .variable => |a_info| {
                 const b_info = b.variable;
-                return a_info.owner_nav == b_info.owner_nav and
+                return a_info.ty == b_info.ty and
-                    a_info.ty == b_info.ty and
                     a_info.init == b_info.init and
-                    a_info.is_threadlocal == b_info.is_threadlocal and
+                    a_info.owner_nav == b_info.owner_nav and
-                    a_info.is_weak_linkage == b_info.is_weak_linkage;
+                    a_info.is_threadlocal == b_info.is_threadlocal;
             },
             .@"extern" => |a_info| {
                 const b_info = b.@"extern";
                 return a_info.name == b_info.name and
                     a_info.ty == b_info.ty and
                     a_info.lib_name == b_info.lib_name and
-                    a_info.is_const == b_info.is_const and
+                    a_info.linkage == b_info.linkage and
+                    a_info.visibility == b_info.visibility and
                     a_info.is_threadlocal == b_info.is_threadlocal and
-                    a_info.is_weak_linkage == b_info.is_weak_linkage and
                     a_info.is_dll_import == b_info.is_dll_import and
+                    a_info.relocation == b_info.relocation and
+                    a_info.is_const == b_info.is_const and
                     a_info.alignment == b_info.alignment and
                     a_info.@"addrspace" == b_info.@"addrspace" and
                     a_info.zir_index == b_info.zir_index;
 @@ -4889,6 +4894,7 @@ pub const Index = enum(u32) {
         float_c_longdouble_f128: struct { data: *Float128 },
         float_comptime_float: struct { data: *Float128 },
         variable: struct { data: *Tag.Variable },
+        threadlocal_variable: struct { data: *Tag.Variable },
         @"extern": struct { data: *Tag.Extern },
         func_decl: struct {
             const @"data.analysis.inferred_error_set" = opaque {};
 @@ -5548,6 +5554,9 @@ pub const Tag = enum(u8) {
     /// A global variable.
     /// data is extra index to Variable.
     variable,
+    /// A global threadlocal variable.
+    /// data is extra index to Variable.
+    threadlocal_variable,
     /// An extern function or variable.
     /// data is extra index to Extern.
     /// Some parts of the key are stored in `owner_nav`.
 @@ -5863,6 +5872,7 @@ pub const Tag = enum(u8) {
         .float_c_longdouble_f128 = .{ .summary = .@"@as(c_longdouble, {.payload%value})", .payload = f128 },
         .float_comptime_float = .{ .summary = .@"{.payload%value}", .payload = f128 },
         .variable = .{ .summary = .@"{.payload.owner_nav.fqn%summary#\"}", .payload = Variable },
+        .threadlocal_variable = .{ .summary = .@"{.payload.owner_nav.fqn%summary#\"}", .payload = Variable },
         .@"extern" = .{ .summary = .@"{.payload.owner_nav.fqn%summary#\"}", .payload = Extern },
         .func_decl = .{
             .summary = .@"{.payload.owner_nav.fqn%summary#\"}",
 @@ -5913,24 +5923,24 @@ pub const Tag = enum(u8) {
         /// May be `none`.
         init: Index,
         owner_nav: Nav.Index,
-        flags: Flags,
-        pub const Flags = packed struct(u32) {
-            is_const: bool,
-            is_threadlocal: bool,
-            is_weak_linkage: bool,
-            is_dll_import: bool,
-            _: u28 = 0,
-        };
     };
     pub const Extern = struct {
-        // name, alignment, addrspace come from `owner_nav`.
+        // name, is_const, alignment, addrspace come from `owner_nav`.
         ty: Index,
         lib_name: OptionalNullTerminatedString,
-        flags: Variable.Flags,
+        flags: Flags,
         owner_nav: Nav.Index,
         zir_index: TrackedInst.Index,
+        pub const Flags = packed struct(u32) {
+            linkage: std.builtin.GlobalLinkage,
+            visibility: std.builtin.SymbolVisibility,
+            is_threadlocal: bool,
+            is_dll_import: bool,
+            relocation: std.builtin.ExternOptions.Relocation,
+            _: u25 = 0,
+        };
     };
     /// Trailing:
 @@ -7248,14 +7258,17 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             .ty = .comptime_float_type,
             .storage = .{ .f128 = extraData(unwrapped_index.getExtra(ip), Float128, data).get() },
         } },
-        .variable => {
+        .variable, .threadlocal_variable => {
             const extra = extraData(unwrapped_index.getExtra(ip), Tag.Variable, data);
             return .{ .variable = .{
                 .ty = extra.ty,
                 .init = extra.init,
                 .owner_nav = extra.owner_nav,
-                .is_threadlocal = extra.flags.is_threadlocal,
+                .is_threadlocal = switch (item.tag) {
-                .is_weak_linkage = extra.flags.is_weak_linkage,
+                    else => unreachable,
+                    .variable => false,
+                    .threadlocal_variable => true,
+                },
             } };
         },
         .@"extern" => {
 @@ -7265,10 +7278,12 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 .name = nav.name,
                 .ty = extra.ty,
                 .lib_name = extra.lib_name,
-                .is_const = extra.flags.is_const,
+                .linkage = extra.flags.linkage,
+                .visibility = extra.flags.visibility,
                 .is_threadlocal = extra.flags.is_threadlocal,
-                .is_weak_linkage = extra.flags.is_weak_linkage,
                 .is_dll_import = extra.flags.is_dll_import,
+                .relocation = extra.flags.relocation,
+                .is_const = nav.status.fully_resolved.is_const,
                 .alignment = nav.status.fully_resolved.alignment,
                 .@"addrspace" = nav.status.fully_resolved.@"addrspace",
                 .zir_index = extra.zir_index,
 @@ -7895,17 +7910,14 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
             const has_init = variable.init != .none;
             if (has_init) assert(variable.ty == ip.typeOf(variable.init));
             items.appendAssumeCapacity(.{
-                .tag = .variable,
+                .tag = switch (variable.is_threadlocal) {
+                    false => .variable,
+                    true => .threadlocal_variable,
+                },
                 .data = try addExtra(extra, Tag.Variable{
                     .ty = variable.ty,
                     .init = variable.init,
                     .owner_nav = variable.owner_nav,
-                    .flags = .{
-                        .is_const = false,
-                        .is_threadlocal = variable.is_threadlocal,
-                        .is_weak_linkage = variable.is_weak_linkage,
-                        .is_dll_import = false,
-                    },
                 }),
             });
         },
 @@ -9128,6 +9140,7 @@ pub fn getExtern(
         .name = key.name,
         .fqn = key.name,
         .val = extern_index,
+        .is_const = key.is_const,
         .alignment = key.alignment,
         .@"linksection" = .none,
         .@"addrspace" = key.@"addrspace",
 @@ -9136,10 +9149,11 @@ pub fn getExtern(
         .ty = key.ty,
         .lib_name = key.lib_name,
         .flags = .{
-            .is_const = key.is_const,
+            .linkage = key.linkage,
+            .visibility = key.visibility,
             .is_threadlocal = key.is_threadlocal,
-            .is_weak_linkage = key.is_weak_linkage,
             .is_dll_import = key.is_dll_import,
+            .relocation = key.relocation,
         },
         .zir_index = key.zir_index,
         .owner_nav = owner_nav,
 @@ -9714,6 +9728,7 @@ fn finishFuncInstance(
         .name = nav_name,
         .fqn = try ip.namespacePtr(fn_namespace).internFullyQualifiedName(ip, gpa, tid, nav_name),
         .val = func_index,
+        .is_const = fn_owner_nav.status.fully_resolved.is_const,
         .alignment = fn_owner_nav.status.fully_resolved.alignment,
         .@"linksection" = fn_owner_nav.status.fully_resolved.@"linksection",
         .@"addrspace" = fn_owner_nav.status.fully_resolved.@"addrspace",
 @@ -10300,13 +10315,13 @@ fn addExtraAssumeCapacity(extra: Local.Extra.Mutable, item: anytype) u32 {
             u32,
             i32,
             FuncAnalysis,
+            Tag.Extern.Flags,
             Tag.TypePointer.Flags,
             Tag.TypeFunction.Flags,
             Tag.TypePointer.PackedOffset,
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
             Tag.TypeStructPacked.Flags,
-            Tag.Variable.Flags,
             => @bitCast(@field(item, field.name)),
             else => @compileError("bad field type: " ++ @typeName(field.type)),
 @@ -10361,13 +10376,13 @@ fn extraDataTrail(extra: Local.Extra, comptime T: type, index: u32) struct { dat
             u32,
             i32,
+            Tag.Extern.Flags,
             Tag.TypePointer.Flags,
             Tag.TypeFunction.Flags,
             Tag.TypePointer.PackedOffset,
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
             Tag.TypeStructPacked.Flags,
-            Tag.Variable.Flags,
             FuncAnalysis,
             => @bitCast(extra_item),
 @@ -11162,7 +11177,7 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
                 .float_c_longdouble_f80 => @sizeOf(Float80),
                 .float_c_longdouble_f128 => @sizeOf(Float128),
                 .float_comptime_float => @sizeOf(Float128),
-                .variable => @sizeOf(Tag.Variable),
+                .variable, .threadlocal_variable => @sizeOf(Tag.Variable),
                 .@"extern" => @sizeOf(Tag.Extern),
                 .func_decl => @sizeOf(Tag.FuncDecl),
                 .func_instance => b: {
 @@ -11282,6 +11297,7 @@ fn dumpAllFallible(ip: *const InternPool) anyerror!void {
                 .float_c_longdouble_f128,
                 .float_comptime_float,
                 .variable,
+                .threadlocal_variable,
                 .@"extern",
                 .func_decl,
                 .func_instance,
 @@ -11414,6 +11430,7 @@ pub fn createNav(
         name: NullTerminatedString,
         fqn: NullTerminatedString,
         val: InternPool.Index,
+        is_const: bool,
         alignment: Alignment,
         @"linksection": OptionalNullTerminatedString,
         @"addrspace": std.builtin.AddressSpace,
 @@ -11430,6 +11447,7 @@ pub fn createNav(
         .analysis = null,
         .status = .{ .fully_resolved = .{
             .val = opts.val,
+            .is_const = opts.is_const,
             .alignment = opts.alignment,
             .@"linksection" = opts.@"linksection",
             .@"addrspace" = opts.@"addrspace",
 @@ -11482,10 +11500,10 @@ pub fn resolveNavType(
     nav: Nav.Index,
     resolved: struct {
         type: InternPool.Index,
+        is_const: bool,
         alignment: Alignment,
         @"linksection": OptionalNullTerminatedString,
         @"addrspace": std.builtin.AddressSpace,
-        is_const: bool,
         is_threadlocal: bool,
         is_extern_decl: bool,
     },
 @@ -11512,9 +11530,9 @@ pub fn resolveNavType(
     var bits = nav_bits[unwrapped.index];
     bits.status = if (resolved.is_extern_decl) .type_resolved_extern_decl else .type_resolved;
+    bits.is_const = resolved.is_const;
     bits.alignment = resolved.alignment;
     bits.@"addrspace" = resolved.@"addrspace";
-    bits.is_const = resolved.is_const;
     bits.is_threadlocal = resolved.is_threadlocal;
     @atomicStore(Nav.Repr.Bits, &nav_bits[unwrapped.index], bits, .release);
 }
 @@ -11526,6 +11544,7 @@ pub fn resolveNavValue(
     nav: Nav.Index,
     resolved: struct {
         val: InternPool.Index,
+        is_const: bool,
         alignment: Alignment,
         @"linksection": OptionalNullTerminatedString,
         @"addrspace": std.builtin.AddressSpace,
 @@ -11553,6 +11572,7 @@ pub fn resolveNavValue(
     var bits = nav_bits[unwrapped.index];
     bits.status = .fully_resolved;
+    bits.is_const = resolved.is_const;
     bits.alignment = resolved.alignment;
     bits.@"addrspace" = resolved.@"addrspace";
     @atomicStore(Nav.Repr.Bits, &nav_bits[unwrapped.index], bits, .release);
 @@ -12007,6 +12027,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
                 .error_union_error,
                 .enum_tag,
                 .variable,
+                .threadlocal_variable,
                 .@"extern",
                 .func_decl,
                 .func_instance,
 @@ -12391,6 +12412,7 @@ pub fn zigTypeTag(ip: *const InternPool, index: Index) std.builtin.TypeId {
             .float_c_longdouble_f128,
             .float_comptime_float,
             .variable,
+            .threadlocal_variable,
             .@"extern",
             .func_decl,
             .func_instance,

src/Sema.zig+42-11

 @@ -26089,10 +26089,12 @@ fn resolveExternOptions(
     zir_ref: Zir.Inst.Ref,
 ) CompileError!struct {
     name: InternPool.NullTerminatedString,
-    library_name: InternPool.OptionalNullTerminatedString = .none,
+    library_name: InternPool.OptionalNullTerminatedString,
-    linkage: std.builtin.GlobalLinkage = .strong,
+    linkage: std.builtin.GlobalLinkage,
-    is_thread_local: bool = false,
+    visibility: std.builtin.SymbolVisibility,
-    is_dll_import: bool = false,
+    is_thread_local: bool,
+    is_dll_import: bool,
+    relocation: std.builtin.ExternOptions.Relocation,
 } {
     const pt = sema.pt;
     const zcu = pt.zcu;
 @@ -26105,8 +26107,10 @@ fn resolveExternOptions(
     const name_src = block.src(.{ .init_field_name = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const library_src = block.src(.{ .init_field_library = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const linkage_src = block.src(.{ .init_field_linkage = src.offset.node_offset_builtin_call_arg.builtin_call_node });
+    const visibility_src = block.src(.{ .init_field_visibility = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const thread_local_src = block.src(.{ .init_field_thread_local = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const dll_import_src = block.src(.{ .init_field_dll_import = src.offset.node_offset_builtin_call_arg.builtin_call_node });
+    const relocation_src = block.src(.{ .init_field_relocation = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const name_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "name", .no_embedded_nulls), name_src);
     const name = try sema.toConstString(block, name_src, name_ref, .{ .simple = .extern_options });
 @@ -26118,6 +26122,10 @@ fn resolveExternOptions(
     const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_ref, .{ .simple = .extern_options });
     const linkage = try sema.interpretBuiltinType(block, linkage_src, linkage_val, std.builtin.GlobalLinkage);
+    const visibility_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "visibility", .no_embedded_nulls), visibility_src);
+    const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_ref, .{ .simple = .extern_options });
+    const visibility = try sema.interpretBuiltinType(block, visibility_src, visibility_val, std.builtin.SymbolVisibility);
     const is_thread_local = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "is_thread_local", .no_embedded_nulls), thread_local_src);
     const is_thread_local_val = try sema.resolveConstDefinedValue(block, thread_local_src, is_thread_local, .{ .simple = .extern_options });
 @@ -26133,6 +26141,10 @@ fn resolveExternOptions(
     const is_dll_import_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "is_dll_import", .no_embedded_nulls), dll_import_src);
     const is_dll_import_val = try sema.resolveConstDefinedValue(block, dll_import_src, is_dll_import_ref, .{ .simple = .extern_options });
+    const relocation_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "relocation", .no_embedded_nulls), relocation_src);
+    const relocation_val = try sema.resolveConstDefinedValue(block, relocation_src, relocation_ref, .{ .simple = .extern_options });
+    const relocation = try sema.interpretBuiltinType(block, relocation_src, relocation_val, std.builtin.ExternOptions.Relocation);
     if (name.len == 0) {
         return sema.fail(block, name_src, "extern symbol name cannot be empty", .{});
     }
 @@ -26145,8 +26157,10 @@ fn resolveExternOptions(
         .name = try ip.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls),
         .library_name = try ip.getOrPutStringOpt(gpa, pt.tid, library_name, .no_embedded_nulls),
         .linkage = linkage,
+        .visibility = visibility,
         .is_thread_local = is_thread_local_val.toBool(),
         .is_dll_import = is_dll_import_val.toBool(),
+        .relocation = relocation,
     };
 }
 @@ -26178,6 +26192,17 @@ fn zirBuiltinExtern(
     }
     const options = try sema.resolveExternOptions(block, options_src, extra.rhs);
+    switch (options.linkage) {
+        .internal => if (options.visibility != .default) {
+            return sema.fail(block, options_src, "internal symbol cannot have non-default visibility", .{});
+        },
+        .strong, .weak => {},
+        .link_once => return sema.fail(block, options_src, "external symbol cannot have link once linkage", .{}),
+    }
+    switch (options.relocation) {
+        .any => {},
+        .pcrel => if (options.visibility == .default) return sema.fail(block, options_src, "cannot require a pc-relative relocation to a symbol with default visibility", .{}),
+    }
     // TODO: error for threadlocal functions, non-const functions, etc
 @@ -26190,10 +26215,12 @@ fn zirBuiltinExtern(
         .name = options.name,
         .ty = ptr_info.child,
         .lib_name = options.library_name,
-        .is_const = ptr_info.flags.is_const,
+        .linkage = options.linkage,
+        .visibility = options.visibility,
         .is_threadlocal = options.is_thread_local,
-        .is_weak_linkage = options.linkage == .weak,
         .is_dll_import = options.is_dll_import,
+        .relocation = options.relocation,
+        .is_const = ptr_info.flags.is_const,
         .alignment = ptr_info.flags.alignment,
         .@"addrspace" = ptr_info.flags.address_space,
         // This instruction is just for source locations.
 @@ -31685,12 +31712,15 @@ fn analyzeNavRefInner(sema: *Sema, block: *Block, src: LazySrcLoc, orig_nav_inde
     const nav_status = ip.getNav(nav_index).status;
-    const is_tlv_or_dllimport = switch (nav_status) {
+    const is_runtime = switch (nav_status) {
         .unresolved => unreachable,
         // dllimports go straight to `fully_resolved`; the only option is threadlocal
         .type_resolved => |r| r.is_threadlocal,
         .fully_resolved => |r| switch (ip.indexToKey(r.val)) {
-            .@"extern" => |e| e.is_threadlocal or e.is_dll_import,
+            .@"extern" => |e| e.is_threadlocal or e.is_dll_import or switch (e.relocation) {
+                .any => false,
+                .pcrel => true,
+            },
             .variable => |v| v.is_threadlocal,
             else => false,
         },
 @@ -31699,7 +31729,7 @@ fn analyzeNavRefInner(sema: *Sema, block: *Block, src: LazySrcLoc, orig_nav_inde
     const ty, const alignment, const @"addrspace", const is_const = switch (nav_status) {
         .unresolved => unreachable,
         .type_resolved => |r| .{ r.type, r.alignment, r.@"addrspace", r.is_const },
-        .fully_resolved => |r| .{ ip.typeOf(r.val), r.alignment, r.@"addrspace", zcu.navValIsConst(r.val) },
+        .fully_resolved => |r| .{ ip.typeOf(r.val), r.alignment, r.@"addrspace", r.is_const },
     };
     const ptr_ty = try pt.ptrTypeSema(.{
         .child = ty,
 @@ -31710,10 +31740,10 @@ fn analyzeNavRefInner(sema: *Sema, block: *Block, src: LazySrcLoc, orig_nav_inde
         },
     });
-    if (is_tlv_or_dllimport) {
+    if (is_runtime) {
         // This pointer is runtime-known; we need to emit an AIR instruction to create it.
         return block.addInst(.{
-            .tag = .tlv_dllimport_ptr,
+            .tag = .runtime_nav_ptr,
             .data = .{ .ty_nav = .{
                 .ty = ptr_ty.toIntern(),
                 .nav = nav_index,
 @@ -36432,6 +36462,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
             .float_c_longdouble_f128,
             .float_comptime_float,
             .variable,
+            .threadlocal_variable,
             .@"extern",
             .func_decl,
             .func_instance,

src/Zcu.zig+3-9

 @@ -2047,6 +2047,7 @@ pub const SrcLoc = struct {
             .init_field_library,
             .init_field_thread_local,
             .init_field_dll_import,
+            .init_field_relocation,
             => |builtin_call_node| {
                 const wanted = switch (src_loc.lazy) {
                     .init_field_name => "name",
 @@ -2059,6 +2060,7 @@ pub const SrcLoc = struct {
                     .init_field_library => "library",
                     .init_field_thread_local => "thread_local",
                     .init_field_dll_import => "dll_import",
+                    .init_field_relocation => "relocation",
                     else => unreachable,
                 };
                 const tree = try src_loc.file_scope.getTree(zcu);
 @@ -2506,6 +2508,7 @@ pub const LazySrcLoc = struct {
         init_field_library: Ast.Node.Offset,
         init_field_thread_local: Ast.Node.Offset,
         init_field_dll_import: Ast.Node.Offset,
+        init_field_relocation: Ast.Node.Offset,
         /// The source location points to the value of an item in a specific
         /// case of a `switch`.
         switch_case_item: SwitchItem,
 @@ -4562,15 +4565,6 @@ pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enu
     return .ok;
 }
-/// Given that a `Nav` has value `val`, determine if a ref of that `Nav` gives a `const` pointer.
-pub fn navValIsConst(zcu: *const Zcu, val: InternPool.Index) bool {
-    return switch (zcu.intern_pool.indexToKey(val)) {
-        .variable => false,
-        .@"extern" => |e| e.is_const,
-        else => true,
-    };
-}
 pub const CodegenFailError = error{
     /// Indicates the error message has been already stored at `Zcu.failed_codegen`.
     CodegenFail,

src/Zcu/PerThread.zig+29-21

 @@ -1153,18 +1153,23 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
     // First, we must resolve the declaration's type. To do this, we analyze the type body if available,
     // or otherwise, we analyze the value body, populating `early_val` in the process.
-    switch (zir_decl.kind) {
+    const is_const = is_const: switch (zir_decl.kind) {
         .@"comptime" => unreachable, // this is not a Nav
-        .unnamed_test, .@"test", .decltest => assert(nav_ty.zigTypeTag(zcu) == .@"fn"),
+        .unnamed_test, .@"test", .decltest => {
-        .@"usingnamespace" => {},
+            assert(nav_ty.zigTypeTag(zcu) == .@"fn");
-        .@"const" => {},
+            break :is_const true;
-        .@"var" => try sema.validateVarType(
+        },
-            &block,
+        .@"usingnamespace", .@"const" => true,
-            if (zir_decl.type_body != null) ty_src else init_src,
+        .@"var" => {
-            nav_ty,
+            try sema.validateVarType(
-            zir_decl.linkage == .@"extern",
+                &block,
-        ),
+                if (zir_decl.type_body != null) ty_src else init_src,
-    }
+                nav_ty,
+                zir_decl.linkage == .@"extern",
+            );
+            break :is_const false;
+        },
+    };
     // Now that we know the type, we can evaluate the alignment, linksection, and addrspace, to determine
     // the full pointer type of this declaration.
 @@ -1195,7 +1200,6 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
                 .init = final_val.?.toIntern(),
                 .owner_nav = nav_id,
                 .is_threadlocal = zir_decl.is_threadlocal,
-                .is_weak_linkage = false,
             } })),
             else => final_val.?,
         },
 @@ -1212,10 +1216,12 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
                 .name = old_nav.name,
                 .ty = nav_ty.toIntern(),
                 .lib_name = try ip.getOrPutStringOpt(gpa, pt.tid, lib_name, .no_embedded_nulls),
-                .is_const = zir_decl.kind == .@"const",
                 .is_threadlocal = zir_decl.is_threadlocal,
-                .is_weak_linkage = false,
+                .linkage = .strong,
+                .visibility = .default,
                 .is_dll_import = false,
+                .relocation = .any,
+                .is_const = is_const,
                 .alignment = modifiers.alignment,
                 .@"addrspace" = modifiers.@"addrspace",
                 .zir_index = old_nav.analysis.?.zir_index, // `declaration` instruction
 @@ -1243,6 +1249,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
         }
         ip.resolveNavValue(nav_id, .{
             .val = nav_val.toIntern(),
+            .is_const = is_const,
             .alignment = .none,
             .@"linksection" = .none,
             .@"addrspace" = .generic,
 @@ -1286,6 +1293,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
     ip.resolveNavValue(nav_id, .{
         .val = nav_val.toIntern(),
+        .is_const = is_const,
         .alignment = modifiers.alignment,
         .@"linksection" = modifiers.@"linksection",
         .@"addrspace" = modifiers.@"addrspace",
 @@ -1515,8 +1523,6 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
     // the pointer modifiers, i.e. alignment, linksection, addrspace.
     const modifiers = try sema.resolveNavPtrModifiers(&block, zir_decl, inst_resolved.inst, resolved_ty);
-    // Usually, we can infer this information from the resolved `Nav` value; see `Zcu.navValIsConst`.
-    // However, since we don't have one, we need to quickly check the ZIR to figure this out.
     const is_const = switch (zir_decl.kind) {
         .@"comptime" => unreachable,
         .unnamed_test, .@"test", .decltest, .@"usingnamespace", .@"const" => true,
 @@ -1542,7 +1548,7 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
             r.alignment != modifiers.alignment or
             r.@"linksection" != modifiers.@"linksection" or
             r.@"addrspace" != modifiers.@"addrspace" or
-            zcu.navValIsConst(r.val) != is_const or
+            r.is_const != is_const or
             (old_nav.getExtern(ip) != null) != is_extern_decl,
     };
 @@ -1550,10 +1556,10 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr
     ip.resolveNavType(nav_id, .{
         .type = resolved_ty.toIntern(),
+        .is_const = is_const,
         .alignment = modifiers.alignment,
         .@"linksection" = modifiers.@"linksection",
         .@"addrspace" = modifiers.@"addrspace",
-        .is_const = is_const,
         .is_threadlocal = zir_decl.is_threadlocal,
         .is_extern_decl = is_extern_decl,
     });
 @@ -1750,7 +1756,7 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: *A
     if (build_options.enable_debug_extensions and comp.verbose_air) {
         std.debug.print("# Begin Function AIR: {}:\n", .{nav.fqn.fmt(ip)});
-        @import("../print_air.zig").dump(pt, air.*, liveness);
+        air.dump(pt, liveness);
         std.debug.print("# End Function AIR: {}\n\n", .{nav.fqn.fmt(ip)});
     }
 @@ -3577,8 +3583,10 @@ pub fn getCoerced(pt: Zcu.PerThread, val: Value, new_ty: Type) Allocator.Error!V
                 .lib_name = e.lib_name,
                 .is_const = e.is_const,
                 .is_threadlocal = e.is_threadlocal,
-                .is_weak_linkage = e.is_weak_linkage,
+                .linkage = e.linkage,
+                .visibility = e.visibility,
                 .is_dll_import = e.is_dll_import,
+                .relocation = e.relocation,
                 .alignment = e.alignment,
                 .@"addrspace" = e.@"addrspace",
                 .zir_index = e.zir_index,
 @@ -3954,7 +3962,7 @@ pub fn navPtrType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Allocator.Err
     const ty, const alignment, const @"addrspace", const is_const = switch (ip.getNav(nav_id).status) {
         .unresolved => unreachable,
         .type_resolved => |r| .{ r.type, r.alignment, r.@"addrspace", r.is_const },
-        .fully_resolved => |r| .{ ip.typeOf(r.val), r.alignment, r.@"addrspace", zcu.navValIsConst(r.val) },
+        .fully_resolved => |r| .{ ip.typeOf(r.val), r.alignment, r.@"addrspace", r.is_const },
     };
     return pt.ptrType(.{
         .child = ty,

src/arch/aarch64/CodeGen.zig+1-1

...	@@ -880,7 +880,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -880,7 +880,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
880	.is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),	880	.is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
881	.error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),	881	.error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),
882	.vector_store_elem => return self.fail("TODO implement vector_store_elem", .{}),	882	.vector_store_elem => return self.fail("TODO implement vector_store_elem", .{}),
883	.tlv_dllimport_ptr => return self.fail("TODO implement tlv_dllimport_ptr", .{}),	883	.runtime_nav_ptr => return self.fail("TODO implement runtime_nav_ptr", .{}),
884		884
885	.c_va_arg => return self.fail("TODO implement c_va_arg", .{}),	885	.c_va_arg => return self.fail("TODO implement c_va_arg", .{}),
886	.c_va_copy => return self.fail("TODO implement c_va_copy", .{}),	886	.c_va_copy => return self.fail("TODO implement c_va_copy", .{}),

src/arch/arm/CodeGen.zig+1-1

...	@@ -869,7 +869,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -869,7 +869,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
869	.is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),	869	.is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
870	.error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),	870	.error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),
871	.vector_store_elem => return self.fail("TODO implement vector_store_elem", .{}),	871	.vector_store_elem => return self.fail("TODO implement vector_store_elem", .{}),
872	.tlv_dllimport_ptr => return self.fail("TODO implement tlv_dllimport_ptr", .{}),	872	.runtime_nav_ptr => return self.fail("TODO implement runtime_nav_ptr", .{}),
873		873
874	.c_va_arg => return self.fail("TODO implement c_va_arg", .{}),	874	.c_va_arg => return self.fail("TODO implement c_va_arg", .{}),
875	.c_va_copy => return self.fail("TODO implement c_va_copy", .{}),	875	.c_va_copy => return self.fail("TODO implement c_va_copy", .{}),

src/arch/riscv64/CodeGen.zig+4-9

...	@@ -1041,12 +1041,7 @@ fn formatAir(	...	@@ -1041,12 +1041,7 @@ fn formatAir(
1041	_: std.fmt.FormatOptions,	1041	_: std.fmt.FormatOptions,
1042	writer: anytype,	1042	writer: anytype,
1043	) @TypeOf(writer).Error!void {	1043	) @TypeOf(writer).Error!void {
1044	@import("../../print_air.zig").dumpInst(	1044	data.func.air.dumpInst(data.inst, data.func.pt, data.func.liveness);
1045	data.inst,
1046	data.func.pt,
1047	data.func.air,
1048	data.func.liveness,
1049	);
1050	}	1045	}
1051	fn fmtAir(func: *Func, inst: Air.Inst.Index) std.fmt.Formatter(formatAir) {	1046	fn fmtAir(func: *Func, inst: Air.Inst.Index) std.fmt.Formatter(formatAir) {
1052	return .{ .data = .{ .func = func, .inst = inst } };	1047	return .{ .data = .{ .func = func, .inst = inst } };
...	@@ -1656,7 +1651,7 @@ fn genBody(func: *Func, body: []const Air.Inst.Index) InnerError!void {	...	@@ -1656,7 +1651,7 @@ fn genBody(func: *Func, body: []const Air.Inst.Index) InnerError!void {
1656	.wrap_errunion_payload => try func.airWrapErrUnionPayload(inst),	1651	.wrap_errunion_payload => try func.airWrapErrUnionPayload(inst),
1657	.wrap_errunion_err => try func.airWrapErrUnionErr(inst),	1652	.wrap_errunion_err => try func.airWrapErrUnionErr(inst),
1658		1653
1659	.tlv_dllimport_ptr => try func.airTlvDllimportPtr(inst),	1654	.runtime_nav_ptr => try func.airRuntimeNavPtr(inst),
1660		1655
1661	.add_optimized,	1656	.add_optimized,
1662	.sub_optimized,	1657	.sub_optimized,
...	@@ -3626,7 +3621,7 @@ fn airWrapErrUnionErr(func: *Func, inst: Air.Inst.Index) !void {	...	@@ -3626,7 +3621,7 @@ fn airWrapErrUnionErr(func: *Func, inst: Air.Inst.Index) !void {
3626	return func.finishAir(inst, result, .{ ty_op.operand, .none, .none });	3621	return func.finishAir(inst, result, .{ ty_op.operand, .none, .none });
3627	}	3622	}
3628		3623
3629	fn airTlvDllimportPtr(func: *Func, inst: Air.Inst.Index) !void {	3624	fn airRuntimeNavPtr(func: *Func, inst: Air.Inst.Index) !void {
3630	const zcu = func.pt.zcu;	3625	const zcu = func.pt.zcu;
3631	const ip = &zcu.intern_pool;	3626	const ip = &zcu.intern_pool;
3632	const ty_nav = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;	3627	const ty_nav = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
...	@@ -3641,7 +3636,7 @@ fn airTlvDllimportPtr(func: *Func, inst: Air.Inst.Index) !void {	...	@@ -3641,7 +3636,7 @@ fn airTlvDllimportPtr(func: *Func, inst: Air.Inst.Index) !void {
3641	break :sym sym;	3636	break :sym sym;
3642	}	3637	}
3643	break :sym try zo.getOrCreateMetadataForNav(zcu, ty_nav.nav);	3638	break :sym try zo.getOrCreateMetadataForNav(zcu, ty_nav.nav);
3644	} else return func.fail("TODO tlv_dllimport_ptr on {}", .{func.bin_file.tag});	3639	} else return func.fail("TODO runtime_nav_ptr on {}", .{func.bin_file.tag});
3645		3640
3646	const dest_mcv = try func.allocRegOrMem(ptr_ty, inst, true);	3641	const dest_mcv = try func.allocRegOrMem(ptr_ty, inst, true);
3647	if (dest_mcv.isRegister()) {	3642	if (dest_mcv.isRegister()) {

src/arch/sparc64/CodeGen.zig+1-1

...	@@ -723,7 +723,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	...	@@ -723,7 +723,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
723	.is_named_enum_value => @panic("TODO implement is_named_enum_value"),	723	.is_named_enum_value => @panic("TODO implement is_named_enum_value"),
724	.error_set_has_value => @panic("TODO implement error_set_has_value"),	724	.error_set_has_value => @panic("TODO implement error_set_has_value"),
725	.vector_store_elem => @panic("TODO implement vector_store_elem"),	725	.vector_store_elem => @panic("TODO implement vector_store_elem"),
726	.tlv_dllimport_ptr => @panic("TODO implement tlv_dllimport_ptr"),	726	.runtime_nav_ptr => @panic("TODO implement runtime_nav_ptr"),
727		727
728	.c_va_arg => return self.fail("TODO implement c_va_arg", .{}),	728	.c_va_arg => return self.fail("TODO implement c_va_arg", .{}),
729	.c_va_copy => return self.fail("TODO implement c_va_copy", .{}),	729	.c_va_copy => return self.fail("TODO implement c_va_copy", .{}),

src/arch/wasm/CodeGen.zig+2-2

...	@@ -2057,7 +2057,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -2057,7 +2057,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
2057	.error_set_has_value => cg.airErrorSetHasValue(inst),	2057	.error_set_has_value => cg.airErrorSetHasValue(inst),
2058	.frame_addr => cg.airFrameAddress(inst),	2058	.frame_addr => cg.airFrameAddress(inst),
2059		2059
2060	.tlv_dllimport_ptr => cg.airTlvDllimportPtr(inst),	2060	.runtime_nav_ptr => cg.airRuntimeNavPtr(inst),
2061		2061
2062	.assembly,	2062	.assembly,
2063	.is_err_ptr,	2063	.is_err_ptr,
...	@@ -7616,7 +7616,7 @@ fn airFrameAddress(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -7616,7 +7616,7 @@ fn airFrameAddress(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
7616	return cg.finishAir(inst, .stack, &.{});	7616	return cg.finishAir(inst, .stack, &.{});
7617	}	7617	}
7618		7618
7619	fn airTlvDllimportPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	7619	fn airRuntimeNavPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
7620	const ty_nav = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;	7620	const ty_nav = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
7621	const mod = cg.pt.zcu.navFileScope(cg.owner_nav).mod.?;	7621	const mod = cg.pt.zcu.navFileScope(cg.owner_nav).mod.?;
7622	if (mod.single_threaded) {	7622	if (mod.single_threaded) {

src/arch/x86_64/CodeGen.zig+173-42

 @@ -274,6 +274,12 @@ pub const MCValue = union(enum) {
     load_symbol: bits.SymbolOffset,
     /// The address of the memory location not-yet-allocated by the linker.
     lea_symbol: bits.SymbolOffset,
+    /// The value is in memory at an address not-yet-allocated by the linker.
+    /// This must use a non-got pc-relative relocation.
+    load_pcrel: bits.SymbolOffset,
+    /// The address of the memory location not-yet-allocated by the linker.
+    /// This must use a non-got pc-relative relocation.
+    lea_pcrel: bits.SymbolOffset,
     /// The value is in memory at a constant offset from the address in a register.
     indirect: bits.RegisterOffset,
     /// The value is in memory.
 @@ -314,6 +320,7 @@ pub const MCValue = union(enum) {
             .eflags,
             .register_overflow,
             .lea_symbol,
+            .lea_pcrel,
             .lea_direct,
             .lea_got,
             .lea_frame,
 @@ -327,6 +334,7 @@ pub const MCValue = union(enum) {
             .register_quadruple,
             .memory,
             .load_symbol,
+            .load_pcrel,
             .load_got,
             .load_direct,
             .indirect,
 @@ -429,6 +437,7 @@ pub const MCValue = union(enum) {
             .register_overflow,
             .register_mask,
             .lea_symbol,
+            .lea_pcrel,
             .lea_direct,
             .lea_got,
             .lea_frame,
 @@ -445,6 +454,7 @@ pub const MCValue = union(enum) {
             .load_got => |sym_index| .{ .lea_got = sym_index },
             .load_frame => |frame_addr| .{ .lea_frame = frame_addr },
             .load_symbol => |sym_off| .{ .lea_symbol = sym_off },
+            .load_pcrel => |sym_off| .{ .lea_pcrel = sym_off },
         };
     }
 @@ -466,6 +476,7 @@ pub const MCValue = union(enum) {
             .load_got,
             .load_frame,
             .load_symbol,
+            .load_pcrel,
             .elementwise_args,
             .reserved_frame,
             .air_ref,
 @@ -477,6 +488,7 @@ pub const MCValue = union(enum) {
             .lea_got => |sym_index| .{ .load_got = sym_index },
             .lea_frame => |frame_addr| .{ .load_frame = frame_addr },
             .lea_symbol => |sym_index| .{ .load_symbol = sym_index },
+            .lea_pcrel => |sym_index| .{ .load_pcrel = sym_index },
         };
     }
 @@ -505,6 +517,8 @@ pub const MCValue = union(enum) {
             .load_frame,
             .load_symbol,
             .lea_symbol,
+            .load_pcrel,
+            .lea_pcrel,
             => switch (off) {
                 0 => mcv,
                 else => unreachable, // not offsettable
 @@ -543,6 +557,7 @@ pub const MCValue = union(enum) {
             .elementwise_args,
             .reserved_frame,
             .lea_symbol,
+            .lea_pcrel,
             => unreachable,
             .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr| .{
                 .base = .{ .reg = .ds },
 @@ -583,6 +598,18 @@ pub const MCValue = union(enum) {
                     } },
                 };
             },
+            .load_pcrel => |sym_off| {
+                assert(sym_off.off == 0);
+                return .{
+                    .base = .{ .pcrel = sym_off.sym_index },
+                    .mod = .{ .rm = .{
+                        .size = mod_rm.size,
+                        .index = mod_rm.index,
+                        .scale = mod_rm.scale,
+                        .disp = sym_off.off + mod_rm.disp,
+                    } },
+                };
+            },
             .air_ref => |ref| (try function.resolveInst(ref)).mem(function, mod_rm),
         };
     }
 @@ -618,6 +645,8 @@ pub const MCValue = union(enum) {
             }),
             .load_symbol => |pl| try writer.print("[sym:{} + 0x{x}]", .{ pl.sym_index, pl.off }),
             .lea_symbol => |pl| try writer.print("sym:{} + 0x{x}", .{ pl.sym_index, pl.off }),
+            .load_pcrel => |pl| try writer.print("[sym@pcrel:{} + 0x{x}]", .{ pl.sym_index, pl.off }),
+            .lea_pcrel => |pl| try writer.print("sym@pcrel:{} + 0x{x}", .{ pl.sym_index, pl.off }),
             .indirect => |pl| try writer.print("[{s} + 0x{x}]", .{ @tagName(pl.reg), pl.off }),
             .load_direct => |pl| try writer.print("[direct:{d}]", .{pl}),
             .lea_direct => |pl| try writer.print("direct:{d}", .{pl}),
 @@ -655,6 +684,8 @@ const InstTracking = struct {
             .lea_frame,
             .load_symbol,
             .lea_symbol,
+            .load_pcrel,
+            .lea_pcrel,
             => result,
             .dead,
             .elementwise_args,
 @@ -755,6 +786,8 @@ const InstTracking = struct {
             .lea_frame,
             .load_symbol,
             .lea_symbol,
+            .load_pcrel,
+            .lea_pcrel,
             => assert(std.meta.eql(self.long, target.long)),
             .dead,
             .eflags,
 @@ -1228,12 +1261,7 @@ fn formatAir(
     _: std.fmt.FormatOptions,
     writer: anytype,
 ) @TypeOf(writer).Error!void {
-    @import("../../print_air.zig").dumpInst(
+    data.self.air.dumpInst(data.inst, data.self.pt, data.self.liveness);
-        data.inst,
-        data.self.pt,
-        data.self.air,
-        data.self.liveness,
-    );
 }
 fn fmtAir(self: *CodeGen, inst: Air.Inst.Index) std.fmt.Formatter(formatAir) {
     return .{ .data = .{ .self = self, .inst = inst } };
 @@ -163487,31 +163515,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 for (ops) |op| try op.die(cg);
             },
-            .tlv_dllimport_ptr => switch (cg.bin_file.tag) {
+            .runtime_nav_ptr => switch (cg.bin_file.tag) {
                 .elf, .macho => {
                     const ty_nav = air_datas[@intFromEnum(inst)].ty_nav;
                     const nav = ip.getNav(ty_nav.nav);
-                    const tlv_sym_index = sym: {
+                    const sym_index, const relocation = sym: {
                         if (cg.bin_file.cast(.elf)) |elf_file| {
                             const zo = elf_file.zigObjectPtr().?;
                             if (nav.getExtern(ip)) |e| {
                                 const sym = try elf_file.getGlobalSymbol(nav.name.toSlice(ip), e.lib_name.toSlice(ip));
-                                zo.symbol(sym).flags.is_extern_ptr = true;
+                                linkage: switch (e.linkage) {
-                                break :sym sym;
+                                    .internal => {},
-                            }
+                                    .strong => switch (e.visibility) {
-                            break :sym try zo.getOrCreateMetadataForNav(zcu, ty_nav.nav);
+                                        .default => zo.symbol(sym).flags.is_extern_ptr = true,
-                        }
+                                        .hidden, .protected => {},
-                        if (cg.bin_file.cast(.macho)) |macho_file| {
+                                    },
+                                    .weak => {
+                                        zo.symbol(sym).flags.weak = true;
+                                        continue :linkage .strong;
+                                    },
+                                    .link_once => unreachable,
+                                }
+                                break :sym .{ sym, e.relocation };
+                            } else break :sym .{ try zo.getOrCreateMetadataForNav(zcu, ty_nav.nav), .any };
+                        } else if (cg.bin_file.cast(.macho)) |macho_file| {
                             const zo = macho_file.getZigObject().?;
                             if (nav.getExtern(ip)) |e| {
                                 const sym = try macho_file.getGlobalSymbol(nav.name.toSlice(ip), e.lib_name.toSlice(ip));
-                                zo.symbols.items[sym].flags.is_extern_ptr = true;
+                                linkage: switch (e.linkage) {
-                                break :sym sym;
+                                    .internal => {},
-                            }
+                                    .strong => switch (e.visibility) {
-                            break :sym try zo.getOrCreateMetadataForNav(macho_file, ty_nav.nav);
+                                        .default => zo.symbols.items[sym].flags.is_extern_ptr = true,
-                        }
+                                        .hidden, .protected => {},
-                        unreachable;
+                                    },
+                                    .weak => {
+                                        zo.symbols.items[sym].flags.weak = true;
+                                        continue :linkage .strong;
+                                    },
+                                    .link_once => unreachable,
+                                }
+                                break :sym .{ sym, e.relocation };
+                            } else break :sym .{ try zo.getOrCreateMetadataForNav(macho_file, ty_nav.nav), .any };
+                        } else unreachable;
                     };
                     if (cg.mod.pic) {
 @@ -163520,13 +163566,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         try cg.spillRegisters(&.{.rax});
                     }
-                    var slot = try cg.tempInit(.usize, .{ .lea_symbol = .{
+                    var slot = try cg.tempInit(.usize, switch (relocation) {
-                        .sym_index = tlv_sym_index,
+                        .any => .{ .lea_symbol = .{ .sym_index = sym_index } },
-                    } });
+                        .pcrel => .{ .lea_pcrel = .{ .sym_index = sym_index } },
+                    });
                     while (try slot.toRegClass(true, .general_purpose, cg)) {}
                     try slot.finish(inst, &.{}, &.{}, cg);
                 },
-                else => return cg.fail("TODO implement tlv/dllimport on {}", .{cg.bin_file.tag}),
+                else => return cg.fail("TODO implement runtime_nav_ptr on {}", .{cg.bin_file.tag}),
             },
             .c_va_arg => try cg.airVaArg(inst),
             .c_va_copy => try cg.airVaCopy(inst),
 @@ -169189,6 +169236,7 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE
         .register,
         .register_offset,
         .lea_symbol,
+        .lea_pcrel,
         .lea_direct,
         .lea_got,
         .lea_frame,
 @@ -169196,6 +169244,7 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE
         .memory,
         .indirect,
         .load_symbol,
+        .load_pcrel,
         .load_direct,
         .load_got,
         .load_frame,
 @@ -169407,6 +169456,7 @@ fn store(
         .register,
         .register_offset,
         .lea_symbol,
+        .lea_pcrel,
         .lea_direct,
         .lea_got,
         .lea_frame,
 @@ -169414,6 +169464,7 @@ fn store(
         .memory,
         .indirect,
         .load_symbol,
+        .load_pcrel,
         .load_direct,
         .load_got,
         .load_frame,
 @@ -169883,6 +169934,7 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv:
         .register_overflow,
         .register_mask,
         .lea_symbol,
+        .lea_pcrel,
         .lea_direct,
         .lea_got,
         .lea_frame,
 @@ -169892,7 +169944,7 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv:
         => unreachable, // unmodifiable destination
         .register => |dst_reg| try self.asmRegister(mir_tag, registerAlias(dst_reg, abi_size)),
         .register_pair, .register_triple, .register_quadruple => unreachable, // unimplemented
-        .memory, .load_symbol, .load_got, .load_direct => {
+        .memory, .load_symbol, .load_pcrel, .load_got, .load_direct => {
             const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
             const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
             defer self.register_manager.unlockReg(addr_reg_lock);
 @@ -171552,6 +171604,8 @@ fn genBinOp(
                         .register_mask,
                         .load_symbol,
                         .lea_symbol,
+                        .load_pcrel,
+                        .lea_pcrel,
                         .load_direct,
                         .lea_direct,
                         .load_got,
 @@ -172740,6 +172794,7 @@ fn genBinOpMir(
         .lea_got,
         .lea_frame,
         .lea_symbol,
+        .lea_pcrel,
         .elementwise_args,
         .reserved_frame,
         .air_ref,
 @@ -172831,6 +172886,8 @@ fn genBinOpMir(
                     .indirect,
                     .load_symbol,
                     .lea_symbol,
+                    .load_pcrel,
+                    .lea_pcrel,
                     .load_direct,
                     .lea_direct,
                     .load_got,
 @@ -172906,7 +172963,7 @@ fn genBinOpMir(
                 }
             }
         },
-        .memory, .indirect, .load_symbol, .load_got, .load_direct, .load_frame => {
+        .memory, .indirect, .load_symbol, .load_pcrel, .load_got, .load_direct, .load_frame => {
             const OpInfo = ?struct { addr_reg: Register, addr_lock: RegisterLock };
             const limb_abi_size: u32 = @min(abi_size, 8);
 @@ -172953,8 +173010,9 @@ fn genBinOpMir(
                 .load_frame,
                 .lea_frame,
                 .lea_symbol,
+                .lea_pcrel,
                 => null,
-                .memory, .load_symbol, .load_got, .load_direct => src: {
+                .memory, .load_symbol, .load_pcrel, .load_got, .load_direct => src: {
                     switch (resolved_src_mcv) {
                         .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr))) != null and
                             std.math.cast(i32, @as(i64, @bitCast(addr)) + abi_size - limb_abi_size) != null)
 @@ -173093,6 +173151,8 @@ fn genBinOpMir(
                     .indirect,
                     .load_symbol,
                     .lea_symbol,
+                    .load_pcrel,
+                    .lea_pcrel,
                     .load_direct,
                     .lea_direct,
                     .load_got,
 @@ -173160,6 +173220,7 @@ fn genIntMulComplexOpMir(self: *CodeGen, dst_ty: Type, dst_mcv: MCValue, src_mcv
         .register_overflow,
         .register_mask,
         .lea_symbol,
+        .lea_pcrel,
         .lea_direct,
         .lea_got,
         .lea_frame,
 @@ -173222,6 +173283,8 @@ fn genIntMulComplexOpMir(self: *CodeGen, dst_ty: Type, dst_mcv: MCValue, src_mcv
                 .eflags,
                 .load_symbol,
                 .lea_symbol,
+                .load_pcrel,
+                .lea_pcrel,
                 .load_direct,
                 .lea_direct,
                 .load_got,
 @@ -173281,7 +173344,7 @@ fn genIntMulComplexOpMir(self: *CodeGen, dst_ty: Type, dst_mcv: MCValue, src_mcv
             }
         },
         .register_pair, .register_triple, .register_quadruple => unreachable, // unimplemented
-        .memory, .indirect, .load_symbol, .load_direct, .load_got, .load_frame => {
+        .memory, .indirect, .load_symbol, .load_pcrel, .load_direct, .load_got, .load_frame => {
             const tmp_reg = try self.copyToTmpRegister(dst_ty, dst_mcv);
             const tmp_mcv = MCValue{ .register = tmp_reg };
             const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
 @@ -173450,7 +173513,8 @@ fn genLocalDebugInfo(
                     .disp = frame_addr.off,
                 } },
             }),
-            .lea_symbol => |sym_off| try self.asmAirMemory(.dbg_local, inst, .{
+            // debug info should explicitly ignore pcrel requirements
+            .lea_symbol, .lea_pcrel => |sym_off| try self.asmAirMemory(.dbg_local, inst, .{
                 .base = .{ .reloc = sym_off.sym_index },
                 .mod = .{ .rm = .{
                     .size = .qword,
 @@ -174108,12 +174172,13 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v
                                     .lea_got,
                                     .lea_frame,
                                     .lea_symbol,
+                                    .lea_pcrel,
                                     .elementwise_args,
                                     .reserved_frame,
                                     .air_ref,
                                     => unreachable,
                                     .register, .register_pair, .register_triple, .register_quadruple, .load_frame => null,
-                                    .memory, .load_symbol, .load_got, .load_direct => dst: {
+                                    .memory, .load_symbol, .load_pcrel, .load_got, .load_direct => dst: {
                                         switch (resolved_dst_mcv) {
                                             .memory => |addr| if (std.math.cast(
                                                 i32,
 @@ -174122,7 +174187,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v
                                                 i32,
                                                 @as(i64, @bitCast(addr)) + abi_size - 8,
                                             ) != null) break :dst null,
-                                            .load_symbol, .load_got, .load_direct => {},
+                                            .load_symbol, .load_pcrel, .load_got, .load_direct => {},
                                             else => unreachable,
                                         }
 @@ -174160,6 +174225,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v
                                     .register_mask,
                                     .indirect,
                                     .lea_symbol,
+                                    .lea_pcrel,
                                     .lea_direct,
                                     .lea_got,
                                     .lea_frame,
 @@ -174168,7 +174234,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v
                                     .air_ref,
                                     => unreachable,
                                     .register_pair, .register_triple, .register_quadruple, .load_frame => null,
-                                    .memory, .load_symbol, .load_got, .load_direct => src: {
+                                    .memory, .load_symbol, .load_pcrel, .load_got, .load_direct => src: {
                                         switch (resolved_src_mcv) {
                                             .memory => |addr| if (std.math.cast(
                                                 i32,
 @@ -174177,7 +174243,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v
                                                 i32,
                                                 @as(i64, @bitCast(addr)) + abi_size - 8,
                                             ) != null) break :src null,
-                                            .load_symbol, .load_got, .load_direct => {},
+                                            .load_symbol, .load_pcrel, .load_got, .load_direct => {},
                                             else => unreachable,
                                         }
 @@ -174568,6 +174634,7 @@ fn isNull(self: *CodeGen, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue)
         .lea_direct,
         .lea_got,
         .lea_symbol,
+        .lea_pcrel,
         .elementwise_args,
         .reserved_frame,
         .air_ref,
 @@ -174616,6 +174683,7 @@ fn isNull(self: *CodeGen, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue)
         .memory,
         .load_symbol,
+        .load_pcrel,
         .load_got,
         .load_direct,
         => {
 @@ -176625,6 +176693,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
         .lea_got,
         .lea_frame,
         .lea_symbol,
+        .lea_pcrel,
         .elementwise_args,
         .reserved_frame,
         .air_ref,
 @@ -176719,7 +176788,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
                     }
                     return;
                 },
-                .load_symbol, .load_direct, .load_got => {
+                .load_symbol, .load_pcrel, .load_direct, .load_got => {
                     const src_addr_reg =
                         (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to64();
                     const src_addr_lock = self.register_manager.lockRegAssumeUnused(src_addr_reg);
 @@ -176752,7 +176821,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
                         .undef => if (opts.safety and part_i > 0) .{ .register = dst_regs[0] } else .undef,
                         dst_tag => |src_regs| .{ .register = src_regs[part_i] },
                         .memory, .indirect, .load_frame => src_mcv.address().offset(part_disp).deref(),
-                        .load_symbol, .load_direct, .load_got => .{ .indirect = .{
+                        .load_symbol, .load_pcrel, .load_direct, .load_got => .{ .indirect = .{
                             .reg = src_info.?.addr_reg,
                             .off = part_disp,
                         } },
 @@ -176773,11 +176842,11 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
             src_mcv,
             opts,
         ),
-        .memory, .load_symbol, .load_direct, .load_got => {
+        .memory, .load_symbol, .load_pcrel, .load_direct, .load_got => {
             switch (dst_mcv) {
                 .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr|
                     return self.genSetMem(.{ .reg = .ds }, small_addr, ty, src_mcv, opts),
-                .load_symbol, .load_direct, .load_got => {},
+                .load_symbol, .load_pcrel, .load_direct, .load_got => {},
                 else => unreachable,
             }
 @@ -177234,7 +177303,7 @@ fn genSetReg(
             if (src_reg_mask.info.inverted) try self.asmRegister(.{ ._, .not }, registerAlias(bits_reg, abi_size));
             try self.genSetReg(dst_reg, ty, .{ .register = bits_reg }, .{});
         },
-        .memory, .load_symbol, .load_direct, .load_got => {
+        .memory, .load_symbol, .load_pcrel, .load_direct, .load_got => {
             switch (src_mcv) {
                 .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr|
                     return (try self.moveStrategy(
 @@ -177263,6 +177332,21 @@ fn genSetReg(
                     .segment, .mmx, .ip, .cr, .dr => unreachable,
                     .x87, .sse => {},
                 },
+                .load_pcrel => |sym_off| switch (dst_reg.class()) {
+                    .general_purpose, .gphi => {
+                        assert(sym_off.off == 0);
+                        try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
+                            .base = .{ .pcrel = sym_off.sym_index },
+                            .mod = .{ .rm = .{
+                                .size = self.memSize(ty),
+                                .disp = sym_off.off,
+                            } },
+                        });
+                        return;
+                    },
+                    .segment, .mmx, .ip, .cr, .dr => unreachable,
+                    .x87, .sse => {},
+                },
                 .load_direct => |sym_index| switch (dst_reg.class()) {
                     .general_purpose, .gphi => {
                         _ = try self.addInst(.{
 @@ -177313,6 +177397,28 @@ fn genSetReg(
                 @tagName(self.bin_file.tag),
             }),
         },
+        .lea_pcrel => |sym_off| switch (self.bin_file.tag) {
+            .elf, .macho => {
+                try self.asmRegisterMemory(
+                    .{ ._, .lea },
+                    dst_reg.to64(),
+                    .{
+                        .base = .{ .pcrel = sym_off.sym_index },
+                    },
+                );
+                if (sym_off.off != 0) try self.asmRegisterMemory(
+                    .{ ._, .lea },
+                    dst_reg.to64(),
+                    .{
+                        .base = .{ .reg = dst_reg.to64() },
+                        .mod = .{ .rm = .{ .disp = sym_off.off } },
+                    },
+                );
+            },
+            else => return self.fail("TODO emit symbol sequence on {s}", .{
+                @tagName(self.bin_file.tag),
+            }),
+        },
         .lea_direct, .lea_got => |sym_index| _ = try self.addInst(.{
             .tag = switch (src_mcv) {
                 .lea_direct => .lea,
 @@ -177350,6 +177456,7 @@ fn genSetMem(
         .frame => |base_frame_index| .{ .lea_frame = .{ .index = base_frame_index, .off = disp } },
         .table, .rip_inst => unreachable,
         .reloc => |sym_index| .{ .lea_symbol = .{ .sym_index = sym_index, .off = disp } },
+        .pcrel => |sym_index| .{ .lea_pcrel = .{ .sym_index = sym_index, .off = disp } },
     };
     switch (src_mcv) {
         .none,
 @@ -177466,7 +177573,7 @@ fn genSetMem(
                     .off = disp,
                 }).compare(.gte, src_align),
                 .table, .rip_inst => unreachable,
-                .reloc => false,
+                .reloc, .pcrel => false,
             })).write(
                 self,
                 .{ .base = base, .mod = .{ .rm = .{
 @@ -177557,6 +177664,8 @@ fn genSetMem(
         .lea_frame,
         .load_symbol,
         .lea_symbol,
+        .load_pcrel,
+        .lea_pcrel,
         => switch (abi_size) {
             0 => {},
             1, 2, 4, 8 => {
 @@ -178110,7 +178219,7 @@ fn airCmpxchg(self: *CodeGen, inst: Air.Inst.Index) !void {
         .off => return self.fail("TODO airCmpxchg with {s}", .{@tagName(ptr_mcv)}),
     }
     const ptr_lock = switch (ptr_mem.base) {
-        .none, .frame, .reloc => null,
+        .none, .frame, .reloc, .pcrel => null,
         .reg => |reg| self.register_manager.lockReg(reg),
         .table, .rip_inst => unreachable,
     };
 @@ -178193,7 +178302,7 @@ fn atomicOp(
         .off => return self.fail("TODO airCmpxchg with {s}", .{@tagName(ptr_mcv)}),
     }
     const mem_lock = switch (ptr_mem.base) {
-        .none, .frame, .reloc => null,
+        .none, .frame, .reloc, .pcrel => null,
         .reg => |reg| self.register_manager.lockReg(reg),
         .table, .rip_inst => unreachable,
     };
 @@ -182266,6 +182375,8 @@ const Temp = struct {
                 .memory,
                 .load_symbol,
                 .lea_symbol,
+                .load_pcrel,
+                .lea_pcrel,
                 .indirect,
                 .load_direct,
                 .lea_direct,
 @@ -182427,6 +182538,22 @@ const Temp = struct {
                 assert(limb_index == 0);
                 new_temp_index.tracking(cg).* = .init(.{ .lea_symbol = sym_off });
             },
+            .load_pcrel => |sym_off| {
+                const new_reg =
+                    try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
+                new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
+                try cg.asmRegisterMemory(.{ ._, .mov }, new_reg.to64(), .{
+                    .base = .{ .pcrel = sym_off.sym_index },
+                    .mod = .{ .rm = .{
+                        .size = .qword,
+                        .disp = sym_off.off + @as(u31, limb_index) * 8,
+                    } },
+                });
+            },
+            .lea_pcrel => |sym_off| {
+                assert(limb_index == 0);
+                new_temp_index.tracking(cg).* = .init(.{ .lea_pcrel = sym_off });
+            },
             .load_frame => |frame_addr| {
                 const new_reg =
                     try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp);
 @@ -182721,11 +182848,12 @@ const Temp = struct {
             .memory,
             .indirect,
             .load_symbol,
+            .load_pcrel,
             .load_direct,
             .load_got,
             .load_frame,
             => return temp.toRegClass(true, .general_purpose, cg),
-            .lea_symbol => |sym_off| {
+            .lea_symbol, .lea_pcrel => |sym_off| {
                 const off = sym_off.off;
                 // hack around linker relocation bugs
                 if (false and off == 0) return false;
 @@ -187464,6 +187592,8 @@ const Temp = struct {
                         .memory,
                         .load_symbol,
                         .lea_symbol,
+                        .load_pcrel,
+                        .lea_pcrel,
                         .indirect,
                         .load_direct,
                         .lea_direct,
 @@ -190044,6 +190174,7 @@ const Select = struct {
                         .register => |base_reg| .{ .reg = base_reg.toSize(.ptr, s.cg.target) },
                         .register_offset => |base_reg_off| .{ .reg = base_reg_off.reg.toSize(.ptr, s.cg.target) },
                         .lea_symbol => |base_sym_off| .{ .reloc = base_sym_off.sym_index },
+                        .lea_pcrel => |base_sym_off| .{ .pcrel = base_sym_off.sym_index },
                     },
                     .mod = .{ .rm = .{
                         .size = op.flags.base.size,

src/arch/x86_64/Emit.zig+4-3

src/arch/x86_64/Lower.zig+19-2

 @@ -66,6 +66,7 @@ pub const Reloc = struct {
         inst: Mir.Inst.Index,
         table,
         linker_reloc: u32,
+        linker_pcrel: u32,
         linker_tlsld: u32,
         linker_dtpoff: u32,
         linker_extern_fn: u32,
 @@ -421,9 +422,9 @@ fn emit(lower: *Lower, prefix: Prefix, mnemonic: Mnemonic, ops: []const Operand)
     for (emit_ops, ops, 0..) |*emit_op, op, op_index| {
         emit_op.* = switch (op) {
             else => op,
-            .mem => |mem_op| switch (mem_op.base()) {
+            .mem => |mem_op| op: switch (mem_op.base()) {
                 else => op,
-                .reloc => |sym_index| op: {
+                .reloc => |sym_index| {
                     assert(prefix == .none);
                     assert(mem_op.sib.disp == 0);
                     assert(mem_op.sib.scale_index.scale == 0);
 @@ -559,6 +560,22 @@ fn emit(lower: *Lower, prefix: Prefix, mnemonic: Mnemonic, ops: []const Operand)
                         return lower.fail("TODO: bin format '{s}'", .{@tagName(lower.bin_file.tag)});
                     }
                 },
+                .pcrel => |sym_index| {
+                    assert(prefix == .none);
+                    assert(mem_op.sib.disp == 0);
+                    assert(mem_op.sib.scale_index.scale == 0);
+                    _ = lower.reloc(@intCast(op_index), .{ .linker_pcrel = sym_index }, 0);
+                    break :op switch (lower.bin_file.tag) {
+                        .elf => op,
+                        .macho => switch (mnemonic) {
+                            .lea => .{ .mem = Memory.initRip(.none, 0) },
+                            .mov => .{ .mem = Memory.initRip(mem_op.sib.ptr_size, 0) },
+                            else => unreachable,
+                        },
+                        else => |tag| return lower.fail("TODO: bin format '{s}'", .{@tagName(tag)}),
+                    };
+                },
             },
         };
     }

src/arch/x86_64/Mir.zig+3-2

src/arch/x86_64/bits.zig+1

...	@@ -762,6 +762,7 @@ pub const Memory = struct {	...	@@ -762,6 +762,7 @@ pub const Memory = struct {
762	frame: FrameIndex,	762	frame: FrameIndex,
763	table,	763	table,
764	reloc: u32,	764	reloc: u32,
		765	pcrel: u32,
765	rip_inst: Mir.Inst.Index,	766	rip_inst: Mir.Inst.Index,
766		767
767	pub const Tag = @typeInfo(Base).@"union".tag_type.?;	768	pub const Tag = @typeInfo(Base).@"union".tag_type.?;

src/arch/x86_64/encoder.zig+4-3

src/codegen.zig+57-24

...	@@ -921,41 +921,74 @@ fn genNavRef(	...	@@ -921,41 +921,74 @@ fn genNavRef(
921	const nav = ip.getNav(nav_index);	921	const nav = ip.getNav(nav_index);
922	assert(!nav.isThreadlocal(ip));	922	assert(!nav.isThreadlocal(ip));
923		923
924	const is_extern, const lib_name = if (nav.getExtern(ip)) \|e\|	924	const lib_name, const linkage, const visibility = if (nav.getExtern(ip)) \|e\|
925	.{ true, e.lib_name }	925	.{ e.lib_name, e.linkage, e.visibility }
926	else	926	else
927	.{ false, .none };	927	.{ .none, .internal, .default };
928		928
929	const name = nav.name;	929	const name = nav.name;
930	if (lf.cast(.elf)) \|elf_file\| {	930	if (lf.cast(.elf)) \|elf_file\| {
931	const zo = elf_file.zigObjectPtr().?;	931	const zo = elf_file.zigObjectPtr().?;
932	if (is_extern) {	932	switch (linkage) {
933	const sym_index = try elf_file.getGlobalSymbol(name.toSlice(ip), lib_name.toSlice(ip));	933	.internal => {
934	zo.symbol(sym_index).flags.is_extern_ptr = true;	934	const sym_index = try zo.getOrCreateMetadataForNav(zcu, nav_index);
935	return .{ .mcv = .{ .lea_symbol = sym_index } };	935	return .{ .mcv = .{ .lea_symbol = sym_index } };
		936	},
		937	.strong, .weak => {
		938	const sym_index = try elf_file.getGlobalSymbol(name.toSlice(ip), lib_name.toSlice(ip));
		939	switch (linkage) {
		940	.internal => unreachable,
		941	.strong => {},
		942	.weak => zo.symbol(sym_index).flags.weak = true,
		943	.link_once => unreachable,
		944	}
		945	switch (visibility) {
		946	.default => zo.symbol(sym_index).flags.is_extern_ptr = true,
		947	.hidden, .protected => {},
		948	}
		949	return .{ .mcv = .{ .lea_symbol = sym_index } };
		950	},
		951	.link_once => unreachable,
936	}	952	}
937	const sym_index = try zo.getOrCreateMetadataForNav(zcu, nav_index);
938	return .{ .mcv = .{ .lea_symbol = sym_index } };
939	} else if (lf.cast(.macho)) \|macho_file\| {	953	} else if (lf.cast(.macho)) \|macho_file\| {
940	const zo = macho_file.getZigObject().?;	954	const zo = macho_file.getZigObject().?;
941	if (is_extern) {	955	switch (linkage) {
942	const sym_index = try macho_file.getGlobalSymbol(name.toSlice(ip), lib_name.toSlice(ip));	956	.internal => {
943	zo.symbols.items[sym_index].flags.is_extern_ptr = true;	957	const sym_index = try zo.getOrCreateMetadataForNav(macho_file, nav_index);
944	return .{ .mcv = .{ .lea_symbol = sym_index } };	958	const sym = zo.symbols.items[sym_index];
		959	return .{ .mcv = .{ .lea_symbol = sym.nlist_idx } };
		960	},
		961	.strong, .weak => {
		962	const sym_index = try macho_file.getGlobalSymbol(name.toSlice(ip), lib_name.toSlice(ip));
		963	switch (linkage) {
		964	.internal => unreachable,
		965	.strong => {},
		966	.weak => zo.symbols.items[sym_index].flags.weak = true,
		967	.link_once => unreachable,
		968	}
		969	switch (visibility) {
		970	.default => zo.symbols.items[sym_index].flags.is_extern_ptr = true,
		971	.hidden, .protected => {},
		972	}
		973	return .{ .mcv = .{ .lea_symbol = sym_index } };
		974	},
		975	.link_once => unreachable,
945	}	976	}
946	const sym_index = try zo.getOrCreateMetadataForNav(macho_file, nav_index);
947	const sym = zo.symbols.items[sym_index];
948	return .{ .mcv = .{ .lea_symbol = sym.nlist_idx } };
949	} else if (lf.cast(.coff)) \|coff_file\| {	977	} else if (lf.cast(.coff)) \|coff_file\| {
950	if (is_extern) {	978	// TODO audit this
951	// TODO audit this	979	switch (linkage) {
952	const global_index = try coff_file.getGlobalSymbol(name.toSlice(ip), lib_name.toSlice(ip));	980	.internal => {
953	try coff_file.need_got_table.put(gpa, global_index, {}); // needs GOT	981	const atom_index = try coff_file.getOrCreateAtomForNav(nav_index);
954	return .{ .mcv = .{ .load_got = link.File.Coff.global_symbol_bit \| global_index } };	982	const sym_index = coff_file.getAtom(atom_index).getSymbolIndex().?;
		983	return .{ .mcv = .{ .load_got = sym_index } };
		984	},
		985	.strong, .weak => {
		986	const global_index = try coff_file.getGlobalSymbol(name.toSlice(ip), lib_name.toSlice(ip));
		987	try coff_file.need_got_table.put(gpa, global_index, {}); // needs GOT
		988	return .{ .mcv = .{ .load_got = link.File.Coff.global_symbol_bit \| global_index } };
		989	},
		990	.link_once => unreachable,
955	}	991	}
956	const atom_index = try coff_file.getOrCreateAtomForNav(nav_index);
957	const sym_index = coff_file.getAtom(atom_index).getSymbolIndex().?;
958	return .{ .mcv = .{ .load_got = sym_index } };
959	} else if (lf.cast(.plan9)) \|p9\| {	992	} else if (lf.cast(.plan9)) \|p9\| {
960	const atom_index = try p9.seeNav(pt, nav_index);	993	const atom_index = try p9.seeNav(pt, nav_index);
961	const atom = p9.getAtom(atom_index);	994	const atom = p9.getAtom(atom_index);

src/codegen/c.zig+22-12

 @@ -2255,19 +2255,30 @@ pub const DeclGen = struct {
     fn renderFwdDecl(
         dg: *DeclGen,
         nav_index: InternPool.Nav.Index,
-        flags: struct {
+        flags: packed struct {
-            is_extern: bool,
             is_const: bool,
             is_threadlocal: bool,
-            is_weak_linkage: bool,
+            linkage: std.builtin.GlobalLinkage,
+            visibility: std.builtin.SymbolVisibility,
         },
     ) !void {
         const zcu = dg.pt.zcu;
         const ip = &zcu.intern_pool;
         const nav = ip.getNav(nav_index);
         const fwd = dg.fwdDeclWriter();
-        try fwd.writeAll(if (flags.is_extern) "zig_extern " else "static ");
+        try fwd.writeAll(switch (flags.linkage) {
-        if (flags.is_weak_linkage) try fwd.writeAll("zig_weak_linkage ");
+            .internal => "static ",
+            .strong, .weak, .link_once => "zig_extern ",
+        });
+        switch (flags.linkage) {
+            .internal, .strong => {},
+            .weak => try fwd.writeAll("zig_weak_linkage "),
+            .link_once => return dg.fail("TODO: CBE: implement linkonce linkage?", .{}),
+        }
+        switch (flags.linkage) {
+            .internal => {},
+            .strong, .weak, .link_once => try fwd.print("zig_visibility({s}) ", .{@tagName(flags.visibility)}),
+        }
         if (flags.is_threadlocal and !dg.mod.single_threaded) try fwd.writeAll("zig_threadlocal ");
         try dg.renderTypeAndName(
             fwd,
 @@ -2994,10 +3005,10 @@ pub fn genDecl(o: *Object) !void {
     switch (ip.indexToKey(nav.status.fully_resolved.val)) {
         .@"extern" => |@"extern"| {
             if (!ip.isFunctionType(nav_ty.toIntern())) return o.dg.renderFwdDecl(o.dg.pass.nav, .{
-                .is_extern = true,
                 .is_const = @"extern".is_const,
                 .is_threadlocal = @"extern".is_threadlocal,
-                .is_weak_linkage = @"extern".is_weak_linkage,
+                .linkage = @"extern".linkage,
+                .visibility = @"extern".visibility,
             });
             const fwd = o.dg.fwdDeclWriter();
 @@ -3016,13 +3027,12 @@ pub fn genDecl(o: *Object) !void {
         },
         .variable => |variable| {
             try o.dg.renderFwdDecl(o.dg.pass.nav, .{
-                .is_extern = false,
                 .is_const = false,
                 .is_threadlocal = variable.is_threadlocal,
-                .is_weak_linkage = variable.is_weak_linkage,
+                .linkage = .internal,
+                .visibility = .default,
             });
             const w = o.writer();
-            if (variable.is_weak_linkage) try w.writeAll("zig_weak_linkage ");
             if (variable.is_threadlocal and !o.dg.mod.single_threaded) try w.writeAll("zig_threadlocal ");
             if (nav.status.fully_resolved.@"linksection".toSlice(&zcu.intern_pool)) |s|
                 try w.print("zig_linksection({s}) ", .{fmtStringLiteral(s, null)});
 @@ -3467,7 +3477,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
             .error_set_has_value => return f.fail("TODO: C backend: implement error_set_has_value", .{}),
             .vector_store_elem => return f.fail("TODO: C backend: implement vector_store_elem", .{}),
-            .tlv_dllimport_ptr => try airTlvDllimportPtr(f, inst),
+            .runtime_nav_ptr => try airRuntimeNavPtr(f, inst),
             .c_va_start => try airCVaStart(f, inst),
             .c_va_arg => try airCVaArg(f, inst),
 @@ -7672,7 +7682,7 @@ fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue {
     return local;
 }
-fn airTlvDllimportPtr(f: *Function, inst: Air.Inst.Index) !CValue {
+fn airRuntimeNavPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     const ty_nav = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
     const writer = f.object.writer();
     const local = try f.allocLocal(inst, .fromInterned(ty_nav.ty));

src/codegen/llvm.zig+73-50

 @@ -2979,36 +2979,49 @@ pub const Object = struct {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
         const nav = ip.getNav(nav_index);
-        const is_extern, const is_threadlocal, const is_weak_linkage, const is_dll_import = switch (nav.status) {
+        const linkage: std.builtin.GlobalLinkage, const visibility: Builder.Visibility, const is_threadlocal, const is_dll_import = switch (nav.status) {
             .unresolved => unreachable,
             .fully_resolved => |r| switch (ip.indexToKey(r.val)) {
-                .variable => |variable| .{ false, variable.is_threadlocal, variable.is_weak_linkage, false },
+                .variable => |variable| .{ .internal, .default, variable.is_threadlocal, false },
-                .@"extern" => |@"extern"| .{ true, @"extern".is_threadlocal, @"extern".is_weak_linkage, @"extern".is_dll_import },
+                .@"extern" => |@"extern"| .{ @"extern".linkage, .fromSymbolVisibility(@"extern".visibility), @"extern".is_threadlocal, @"extern".is_dll_import },
-                else => .{ false, false, false, false },
+                else => .{ .internal, .default, false, false },
             },
             // This means it's a source declaration which is not `extern`!
-            .type_resolved => |r| .{ false, r.is_threadlocal, false, false },
+            .type_resolved => |r| .{ .internal, .default, r.is_threadlocal, false },
         };
         const variable_index = try o.builder.addVariable(
-            try o.builder.strtabString((if (is_extern) nav.name else nav.fqn).toSlice(ip)),
+            try o.builder.strtabString(switch (linkage) {
+                .internal => nav.fqn,
+                .strong, .weak => nav.name,
+                .link_once => unreachable,
+            }.toSlice(ip)),
             try o.lowerType(Type.fromInterned(nav.typeOf(ip))),
             toLlvmGlobalAddressSpace(nav.getAddrspace(), zcu.getTarget()),
         );
         gop.value_ptr.* = variable_index.ptrConst(&o.builder).global;
         // This is needed for declarations created by `@extern`.
-        if (is_extern) {
+        switch (linkage) {
-            variable_index.setLinkage(.external, &o.builder);
+            .internal => {
-            variable_index.setUnnamedAddr(.default, &o.builder);
+                variable_index.setLinkage(.internal, &o.builder);
-            if (is_threadlocal and !zcu.navFileScope(nav_index).mod.?.single_threaded)
+                variable_index.setUnnamedAddr(.unnamed_addr, &o.builder);
-                variable_index.setThreadLocal(.generaldynamic, &o.builder);
+            },
-            if (is_weak_linkage) variable_index.setLinkage(.extern_weak, &o.builder);
+            .strong, .weak => {
-            if (is_dll_import) variable_index.setDllStorageClass(.dllimport, &o.builder);
+                variable_index.setLinkage(switch (linkage) {
-        } else {
+                    .internal => unreachable,
-            variable_index.setLinkage(.internal, &o.builder);
+                    .strong => .external,
-            variable_index.setUnnamedAddr(.unnamed_addr, &o.builder);
+                    .weak => .extern_weak,
-        }
+                    .link_once => unreachable,
+                }, &o.builder);
+                variable_index.setUnnamedAddr(.default, &o.builder);
+                if (is_threadlocal and !zcu.navFileScope(nav_index).mod.?.single_threaded)
+                    variable_index.setThreadLocal(.generaldynamic, &o.builder);
+                if (is_dll_import) variable_index.setDllStorageClass(.dllimport, &o.builder);
+            },
+            .link_once => unreachable,
+        }
+        variable_index.setVisibility(visibility, &o.builder);
         return variable_index;
     }
 @@ -4530,14 +4543,14 @@ pub const NavGen = struct {
         const nav = ip.getNav(nav_index);
         const resolved = nav.status.fully_resolved;
-        const is_extern, const lib_name, const is_threadlocal, const is_weak_linkage, const is_dll_import, const is_const, const init_val, const owner_nav = switch (ip.indexToKey(resolved.val)) {
+        const lib_name, const linkage, const visibility: Builder.Visibility, const is_threadlocal, const is_dll_import, const is_const, const init_val, const owner_nav = switch (ip.indexToKey(resolved.val)) {
-            .variable => |variable| .{ false, .none, variable.is_threadlocal, variable.is_weak_linkage, false, false, variable.init, variable.owner_nav },
+            .variable => |variable| .{ .none, .internal, .default, variable.is_threadlocal, false, false, variable.init, variable.owner_nav },
-            .@"extern" => |@"extern"| .{ true, @"extern".lib_name, @"extern".is_threadlocal, @"extern".is_weak_linkage, @"extern".is_dll_import, @"extern".is_const, .none, @"extern".owner_nav },
+            .@"extern" => |@"extern"| .{ @"extern".lib_name, @"extern".linkage, .fromSymbolVisibility(@"extern".visibility), @"extern".is_threadlocal, @"extern".is_dll_import, @"extern".is_const, .none, @"extern".owner_nav },
-            else => .{ false, .none, false, false, false, true, resolved.val, nav_index },
+            else => .{ .none, .internal, .default, false, false, true, resolved.val, nav_index },
         };
         const ty = Type.fromInterned(nav.typeOf(ip));
-        if (is_extern and ip.isFunctionType(ty.toIntern())) {
+        if (linkage != .internal and ip.isFunctionType(ty.toIntern())) {
             _ = try o.resolveLlvmFunction(owner_nav);
         } else {
             const variable_index = try o.resolveGlobalNav(nav_index);
 @@ -4549,6 +4562,7 @@ pub const NavGen = struct {
                 .none => .no_init,
                 else => try o.lowerValue(init_val),
             }, &o.builder);
+            variable_index.setVisibility(visibility, &o.builder);
             const file_scope = zcu.navFileScopeIndex(nav_index);
             const mod = zcu.fileByIndex(file_scope).mod.?;
 @@ -4568,7 +4582,7 @@ pub const NavGen = struct {
                     line_number,
                     try o.lowerDebugType(ty),
                     variable_index,
-                    .{ .local = !is_extern },
+                    .{ .local = linkage == .internal },
                 );
                 const debug_expression = try o.builder.debugExpression(&.{});
 @@ -4583,38 +4597,47 @@ pub const NavGen = struct {
             }
         }
-        if (is_extern) {
+        switch (linkage) {
-            const global_index = o.nav_map.get(nav_index).?;
+            .internal => {},
+            .strong, .weak => {
+                const global_index = o.nav_map.get(nav_index).?;
-            const decl_name = decl_name: {
+                const decl_name = decl_name: {
-                if (zcu.getTarget().cpu.arch.isWasm() and ty.zigTypeTag(zcu) == .@"fn") {
+                    if (zcu.getTarget().cpu.arch.isWasm() and ty.zigTypeTag(zcu) == .@"fn") {
-                    if (lib_name.toSlice(ip)) |lib_name_slice| {
+                        if (lib_name.toSlice(ip)) |lib_name_slice| {
-                        if (!std.mem.eql(u8, lib_name_slice, "c")) {
+                            if (!std.mem.eql(u8, lib_name_slice, "c")) {
-                            break :decl_name try o.builder.strtabStringFmt("{}|{s}", .{ nav.name.fmt(ip), lib_name_slice });
+                                break :decl_name try o.builder.strtabStringFmt("{}|{s}", .{ nav.name.fmt(ip), lib_name_slice });
+                            }
                         }
                     }
-                }
+                    break :decl_name try o.builder.strtabString(nav.name.toSlice(ip));
-                break :decl_name try o.builder.strtabString(nav.name.toSlice(ip));
+                };
-            };
-            if (o.builder.getGlobal(decl_name)) |other_global| {
+                if (o.builder.getGlobal(decl_name)) |other_global| {
-                if (other_global != global_index) {
+                    if (other_global != global_index) {
-                    // Another global already has this name; just use it in place of this global.
+                        // Another global already has this name; just use it in place of this global.
-                    try global_index.replace(other_global, &o.builder);
+                        try global_index.replace(other_global, &o.builder);
-                    return;
+                        return;
+                    }
                 }
-            }
-            try global_index.rename(decl_name, &o.builder);
+                try global_index.rename(decl_name, &o.builder);
-            global_index.setLinkage(.external, &o.builder);
+                global_index.setUnnamedAddr(.default, &o.builder);
-            global_index.setUnnamedAddr(.default, &o.builder);
+                if (is_dll_import) {
-            if (is_dll_import) {
+                    global_index.setDllStorageClass(.dllimport, &o.builder);
-                global_index.setDllStorageClass(.dllimport, &o.builder);
+                } else if (zcu.comp.config.dll_export_fns) {
-            } else if (zcu.comp.config.dll_export_fns) {
+                    global_index.setDllStorageClass(.default, &o.builder);
-                global_index.setDllStorageClass(.default, &o.builder);
+                }
-            }
-            if (is_weak_linkage) global_index.setLinkage(.extern_weak, &o.builder);
+                global_index.setLinkage(switch (linkage) {
+                    .internal => unreachable,
+                    .strong => .external,
+                    .weak => .extern_weak,
+                    .link_once => unreachable,
+                }, &o.builder);
+                global_index.setVisibility(visibility, &o.builder);
+            },
+            .link_once => unreachable,
         }
     }
 };
 @@ -5023,7 +5046,7 @@ pub const FuncGen = struct {
                 .vector_store_elem => try self.airVectorStoreElem(inst),
-                .tlv_dllimport_ptr => try self.airTlvDllimportPtr(inst),
+                .runtime_nav_ptr => try self.airRuntimeNavPtr(inst),
                 .inferred_alloc, .inferred_alloc_comptime => unreachable,
 @@ -8122,7 +8145,7 @@ pub const FuncGen = struct {
         return .none;
     }
-    fn airTlvDllimportPtr(fg: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
+    fn airRuntimeNavPtr(fg: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = fg.ng.object;
         const ty_nav = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
         const llvm_ptr_const = try o.lowerNavRefValue(ty_nav.nav);

src/link/Dwarf.zig+52-138

 @@ -785,7 +785,6 @@ const Entry = struct {
     }
     const Index = enum(u32) {
-        //got_proc,
         _,
         const Optional = enum(u32) {
 @@ -1041,7 +1040,7 @@ const Entry = struct {
                 const symbol = zo.symbol(reloc.target_sym);
                 try dwarf.resolveReloc(
                     entry_off + reloc.source_off,
-                    @bitCast(symbol.address(.{}, elf_file) + @as(i64, @intCast(@intFromEnum(reloc.target_off))) -
+                    @bitCast(symbol.address(.{}, elf_file) + @as(i64, @intCast(reloc.target_off)) -
                         if (symbol.flags.is_tls) elf_file.dtpAddress() else 0),
                     @intFromEnum(dwarf.address_size),
                 );
 @@ -1052,7 +1051,7 @@ const Entry = struct {
                 const ref = zo.getSymbolRef(reloc.target_sym, macho_file);
                 try dwarf.resolveReloc(
                     entry_off + reloc.source_off,
-                    ref.getSymbol(macho_file).?.getAddress(.{}, macho_file) + @as(i64, @intCast(@intFromEnum(reloc.target_off))),
+                    ref.getSymbol(macho_file).?.getAddress(.{}, macho_file) + @as(i64, @intCast(reloc.target_off)),
                     @intFromEnum(dwarf.address_size),
                 );
             }
 @@ -1081,27 +1080,12 @@ const CrossSectionReloc = struct {
 const ExternalReloc = struct {
     source_off: u32 = 0,
     target_sym: u32,
-    target_off: enum(u64) {
+    target_off: u64 = 0,
-        none = 0,
-        got = std.math.maxInt(i64) + 1,
-        _,
-        pub fn rel(off: u64) @This() {
-            const res: @This() = @enumFromInt(off);
-            switch (res) {
-                .none => {},
-                _ => {},
-                .got => unreachable, // assertion failure
-            }
-            return res;
-        }
-    } = .none,
 };
 pub const Loc = union(enum) {
     empty,
     addr_reloc: u32,
-    got_reloc: u32,
     deref: *const Loc,
     constu: u64,
     consts: i64,
 @@ -1166,10 +1150,6 @@ pub const Loc = union(enum) {
                 try addr.write(adapter);
                 try writer.writeByte(DW.OP.deref);
             },
-            .got_reloc => |sym_index| {
-                try writer.writeByte(DW.OP.const4s);
-                try adapter.gotSym(sym_index);
-            },
             .constu => |constu| if (std.math.cast(u5, constu)) |lit| {
                 try writer.writeByte(@as(u8, DW.OP.lit0) + lit);
             } else if (std.math.cast(u8, constu)) |const1u| {
 @@ -1766,9 +1746,6 @@ pub const WipNav = struct {
         fn endian(_: ExprLocCounter) std.builtin.Endian {
             return @import("builtin").cpu.arch.endian();
         }
-        fn gotSym(counter: *ExprLocCounter, _: u32) error{}!void {
-            counter.stream.bytes_written += 4;
-        }
         fn addrSym(counter: *ExprLocCounter, _: u32) error{}!void {
             counter.stream.bytes_written += @intFromEnum(counter.address_size);
         }
 @@ -1789,14 +1766,6 @@ pub const WipNav = struct {
             fn endian(ctx: @This()) std.builtin.Endian {
                 return ctx.wip_nav.dwarf.endian;
             }
-            fn gotSym(ctx: @This(), sym_index: u32) UpdateError!void {
-                try ctx.wip_nav.infoExternalReloc(.{
-                    .source_off = @intCast(ctx.wip_nav.debug_info.items.len),
-                    .target_sym = sym_index,
-                    .target_off = .got,
-                });
-                try ctx.wip_nav.debug_info.appendNTimes(ctx.wip_nav.dwarf.gpa, 0, 4);
-            }
             fn addrSym(ctx: @This(), sym_index: u32) UpdateError!void {
                 try ctx.wip_nav.infoAddrSym(sym_index, 0);
             }
 @@ -1812,7 +1781,7 @@ pub const WipNav = struct {
         try wip_nav.infoExternalReloc(.{
             .source_off = @intCast(wip_nav.debug_info.items.len),
             .target_sym = sym_index,
-            .target_off = .rel(sym_off),
+            .target_off = sym_off,
         });
         try wip_nav.debug_info.appendNTimes(wip_nav.dwarf.gpa, 0, @intFromEnum(wip_nav.dwarf.address_size));
     }
 @@ -1829,14 +1798,6 @@ pub const WipNav = struct {
             fn endian(ctx: @This()) std.builtin.Endian {
                 return ctx.wip_nav.dwarf.endian;
             }
-            fn gotSym(ctx: @This(), sym_index: u32) UpdateError!void {
-                try ctx.wip_nav.frameExternalReloc(.{
-                    .source_off = @intCast(ctx.wip_nav.debug_frame.items.len),
-                    .target_sym = sym_index,
-                    .target_off = .got,
-                });
-                try ctx.wip_nav.debug_frame.appendNTimes(ctx.wip_nav.dwarf.gpa, 0, 4);
-            }
             fn addrSym(ctx: @This(), sym_index: u32) UpdateError!void {
                 try ctx.wip_nav.frameAddrSym(sym_index, 0);
             }
 @@ -1852,7 +1813,7 @@ pub const WipNav = struct {
         try wip_nav.frameExternalReloc(.{
             .source_off = @intCast(wip_nav.debug_frame.items.len),
             .target_sym = sym_index,
-            .target_off = .rel(sym_off),
+            .target_off = sym_off,
         });
         try wip_nav.debug_frame.appendNTimes(wip_nav.dwarf.gpa, 0, @intFromEnum(wip_nav.dwarf.address_size));
     }
 @@ -2338,81 +2299,50 @@ fn getUnit(dwarf: *Dwarf, mod: *Module) !Unit.Index {
     const mod_gop = try dwarf.mods.getOrPut(dwarf.gpa, mod);
     const unit: Unit.Index = @enumFromInt(mod_gop.index);
     if (!mod_gop.found_existing) {
-        {
+        errdefer _ = dwarf.mods.pop();
-            errdefer _ = dwarf.mods.pop();
+        mod_gop.value_ptr.* = .{
-            mod_gop.value_ptr.* = .{
+            .root_dir_path = undefined,
-                .root_dir_path = undefined,
+            .dirs = .empty,
-                .dirs = .empty,
+            .files = .empty,
-                .files = .empty,
+        };
-            };
+        errdefer mod_gop.value_ptr.dirs.deinit(dwarf.gpa);
-            errdefer mod_gop.value_ptr.dirs.deinit(dwarf.gpa);
+        try mod_gop.value_ptr.dirs.putNoClobber(dwarf.gpa, unit, {});
-            try mod_gop.value_ptr.dirs.putNoClobber(dwarf.gpa, unit, {});
+        assert(try dwarf.debug_aranges.section.addUnit(
-            assert(try dwarf.debug_aranges.section.addUnit(
+            DebugAranges.headerBytes(dwarf),
-                DebugAranges.headerBytes(dwarf),
+            DebugAranges.trailerBytes(dwarf),
-                DebugAranges.trailerBytes(dwarf),
+            dwarf,
-                dwarf,
+        ) == unit);
-            ) == unit);
+        errdefer dwarf.debug_aranges.section.popUnit(dwarf.gpa);
-            errdefer dwarf.debug_aranges.section.popUnit(dwarf.gpa);
+        assert(try dwarf.debug_frame.section.addUnit(
-            assert(try dwarf.debug_frame.section.addUnit(
+            DebugFrame.headerBytes(dwarf),
-                DebugFrame.headerBytes(dwarf),
+            DebugFrame.trailerBytes(dwarf),
-                DebugFrame.trailerBytes(dwarf),
+            dwarf,
-                dwarf,
+        ) == unit);
-            ) == unit);
+        errdefer dwarf.debug_frame.section.popUnit(dwarf.gpa);
-            errdefer dwarf.debug_frame.section.popUnit(dwarf.gpa);
+        assert(try dwarf.debug_info.section.addUnit(
-            assert(try dwarf.debug_info.section.addUnit(
+            DebugInfo.headerBytes(dwarf),
-                DebugInfo.headerBytes(dwarf),
+            DebugInfo.trailer_bytes,
-                DebugInfo.trailer_bytes,
+            dwarf,
-                dwarf,
+        ) == unit);
-            ) == unit);
+        errdefer dwarf.debug_info.section.popUnit(dwarf.gpa);
-            errdefer dwarf.debug_info.section.popUnit(dwarf.gpa);
+        assert(try dwarf.debug_line.section.addUnit(
-            assert(try dwarf.debug_line.section.addUnit(
+            DebugLine.headerBytes(dwarf, 5, 25),
-                DebugLine.headerBytes(dwarf, 5, 25),
+            DebugLine.trailer_bytes,
-                DebugLine.trailer_bytes,
+            dwarf,
-                dwarf,
+        ) == unit);
-            ) == unit);
+        errdefer dwarf.debug_line.section.popUnit(dwarf.gpa);
-            errdefer dwarf.debug_line.section.popUnit(dwarf.gpa);
+        assert(try dwarf.debug_loclists.section.addUnit(
-            assert(try dwarf.debug_loclists.section.addUnit(
+            DebugLocLists.headerBytes(dwarf),
-                DebugLocLists.headerBytes(dwarf),
+            DebugLocLists.trailer_bytes,
-                DebugLocLists.trailer_bytes,
+            dwarf,
-                dwarf,
+        ) == unit);
-            ) == unit);
+        errdefer dwarf.debug_loclists.section.popUnit(dwarf.gpa);
-            errdefer dwarf.debug_loclists.section.popUnit(dwarf.gpa);
+        assert(try dwarf.debug_rnglists.section.addUnit(
-            assert(try dwarf.debug_rnglists.section.addUnit(
+            DebugRngLists.headerBytes(dwarf),
-                DebugRngLists.headerBytes(dwarf),
+            DebugRngLists.trailer_bytes,
-                DebugRngLists.trailer_bytes,
+            dwarf,
-                dwarf,
+        ) == unit);
-            ) == unit);
+        errdefer dwarf.debug_rnglists.section.popUnit(dwarf.gpa);
-            errdefer dwarf.debug_rnglists.section.popUnit(dwarf.gpa);
-        }
-        //if (dwarf.bin_file.cast(.elf)) |elf_file| {
-        //    if (unit == .main) assert(try dwarf.addCommonEntry(unit) == .got_proc);
-        //    if (mod.pic and dwarf.debug_info.section.getUnit(.main).getEntry(.got_proc).len == 0) {
-        //        var wip_nav: WipNav = .{
-        //            .dwarf = dwarf,
-        //            .pt = undefined,
-        //            .unit = .main,
-        //            .entry = .got_proc,
-        //            .any_children = false,
-        //            .func = .none,
-        //            .func_sym_index = undefined,
-        //            .func_high_pc = undefined,
-        //            .blocks = undefined,
-        //            .cfi = undefined,
-        //            .debug_frame = .empty,
-        //            .debug_info = .empty,
-        //            .debug_line = .empty,
-        //            .debug_loclists = .empty,
-        //            .pending_lazy = .empty,
-        //        };
-        //        defer wip_nav.deinit();
-        //        try wip_nav.abbrevCode(.proc);
-        //        try wip_nav.infoExprLoc(.{ .deref = &.{ .plus = .{
-        //            &.empty,
-        //            &.{ .addr_reloc = try elf_file.zigObjectPtr().?.getGlobalSymbol(elf_file, "_GLOBAL_OFFSET_TABLE_", null) },
-        //        } } });
-        //        try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.items);
-        //    }
-        //}
     }
     return unit;
 }
 @@ -2510,16 +2440,7 @@ fn initWipNavInner(
             try wip_nav.strp(nav.fqn.toSlice(ip));
             const ty: Type = nav_val.typeOf(zcu);
             const addr: Loc = .{ .addr_reloc = sym_index };
-            const loc: Loc = loc: {
+            const loc: Loc = if (decl.is_threadlocal) .{ .form_tls_address = &addr } else addr;
-                if (dwarf.bin_file.cast(.elf)) |elf_file| if (decl.linkage == .@"extern" and mod.pic)
-                    // TODO: lldb doesn't support call :(
-                    //.{ .call = .{ .args = &.{.{ .got_reloc = sym_index }}, .unit = .main, .entry = .got_proc } }
-                    break :loc .{ .deref = &.{ .plus = .{
-                        &.{ .addr_reloc = try elf_file.zigObjectPtr().?.getGlobalSymbol(elf_file, "_GLOBAL_OFFSET_TABLE_", null) },
-                        &.{ .got_reloc = sym_index },
-                    } } };
-                break :loc if (decl.is_threadlocal) .{ .form_tls_address = &addr } else addr;
-            };
             switch (decl.kind) {
                 .unnamed_test, .@"test", .decltest, .@"comptime", .@"usingnamespace" => unreachable,
                 .@"const" => {
 @@ -2605,7 +2526,7 @@ fn initWipNavInner(
             try wip_nav.infoAddrSym(sym_index, 0);
             wip_nav.func_high_pc = @intCast(wip_nav.debug_info.items.len);
             try diw.writeInt(u32, 0, dwarf.endian);
-            const target = file.mod.?.resolved_target.result;
+            const target = mod.resolved_target.result;
             try uleb128(diw, switch (nav.status.fully_resolved.alignment) {
                 .none => target_info.defaultFunctionAlignment(target),
                 else => |a| a.maxStrict(target_info.minFunctionAlignment(target)),
 @@ -2742,7 +2663,7 @@ pub fn finishWipNavFunc(
             .{
                 .source_off = 1 + @intFromEnum(dwarf.address_size),
                 .target_sym = wip_nav.func_sym_index,
-                .target_off = .rel(code_size),
+                .target_off = code_size,
             },
         });
         try dwarf.debug_rnglists.section.replaceEntry(
 @@ -4981,7 +4902,6 @@ const AbbrevCode = enum {
     comptime_value_field_comptime_state,
     comptime_value_elem_runtime_bits,
     comptime_value_elem_comptime_state,
-    //proc,
     const decl_bytes = uleb128Bytes(@intFromEnum(AbbrevCode.decl_instance_func_generic));
     comptime {
 @@ -5851,12 +5771,6 @@ const AbbrevCode = enum {
                 .{ .ZIG_comptime_value, .ref_addr },
             },
         },
-        //.proc = .{
-        //    .tag = .dwarf_procedure,
-        //    .attrs = &.{
-        //        .{ .location, .exprloc },
-        //    },
-        //},
         .null = undefined,
     });
 };

src/link/Elf.zig+25-17

 @@ -959,6 +959,12 @@ fn flushModuleInner(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id) !void {
     self.rela_plt.clearRetainingCapacity();
     if (self.zigObjectPtr()) |zo| {
+        var undefs: std.AutoArrayHashMap(SymbolResolver.Index, std.ArrayList(Ref)) = .init(gpa);
+        defer {
+            for (undefs.values()) |*refs| refs.deinit();
+            undefs.deinit();
+        }
         var has_reloc_errors = false;
         for (zo.atoms_indexes.items) |atom_index| {
             const atom_ptr = zo.atom(atom_index) orelse continue;
 @@ -969,7 +975,10 @@ fn flushModuleInner(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id) !void {
             const code = try zo.codeAlloc(self, atom_index);
             defer gpa.free(code);
             const file_offset = atom_ptr.offset(self);
-            atom_ptr.resolveRelocsAlloc(self, code) catch |err| switch (err) {
+            (if (shdr.sh_flags & elf.SHF_ALLOC == 0)
+                atom_ptr.resolveRelocsNonAlloc(self, code, &undefs)
+            else
+                atom_ptr.resolveRelocsAlloc(self, code)) catch |err| switch (err) {
                 error.RelocFailure, error.RelaxFailure => has_reloc_errors = true,
                 error.UnsupportedCpuArch => {
                     try self.reportUnsupportedCpuArch();
 @@ -980,6 +989,8 @@ fn flushModuleInner(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id) !void {
             try self.pwriteAll(code, file_offset);
         }
+        try self.reportUndefinedSymbols(&undefs);
         if (has_reloc_errors) return error.LinkFailure;
     }
 @@ -1392,11 +1403,9 @@ fn scanRelocs(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
     const shared_objects = self.shared_objects.values();
-    var undefs = std.AutoArrayHashMap(SymbolResolver.Index, std.ArrayList(Ref)).init(gpa);
+    var undefs: std.AutoArrayHashMap(SymbolResolver.Index, std.ArrayList(Ref)) = .init(gpa);
     defer {
-        for (undefs.values()) |*refs| {
+        for (undefs.values()) |*refs| refs.deinit();
-            refs.deinit();
-        }
         undefs.deinit();
     }
 @@ -2702,15 +2711,16 @@ fn initSyntheticSections(self: *Elf) !void {
         });
     }
-    const needs_interp = blk: {
+    const is_exe_or_dyn_lib = switch (comp.config.output_mode) {
-        // On Ubuntu with musl-gcc, we get a weird combo of options looking like this:
+        .Exe => true,
-        // -dynamic-linker=<path> -static
+        .Lib => comp.config.link_mode == .dynamic,
-        // In this case, if we do generate .interp section and segment, we will get
+        .Obj => false,
-        // a segfault in the dynamic linker trying to load a binary that is static
-        // and doesn't contain .dynamic section.
-        if (self.base.isStatic() and !comp.config.pie) break :blk false;
-        break :blk target.dynamic_linker.get() != null;
     };
+    const have_dynamic_linker = comp.config.link_mode == .dynamic and is_exe_or_dyn_lib and !target.dynamic_linker.eql(.none);
+    const needs_interp = have_dynamic_linker and
+        (comp.config.link_libc or comp.root_mod.resolved_target.is_explicit_dynamic_linker);
     if (needs_interp and self.section_indexes.interp == null) {
         self.section_indexes.interp = try self.addSection(.{
             .name = try self.insertShString(".interp"),
 @@ -3707,11 +3717,9 @@ fn allocateSpecialPhdrs(self: *Elf) void {
 fn writeAtoms(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
-    var undefs = std.AutoArrayHashMap(SymbolResolver.Index, std.ArrayList(Ref)).init(gpa);
+    var undefs: std.AutoArrayHashMap(SymbolResolver.Index, std.ArrayList(Ref)) = .init(gpa);
     defer {
-        for (undefs.values()) |*refs| {
+        for (undefs.values()) |*refs| refs.deinit();
-            refs.deinit();
-        }
         undefs.deinit();
     }

src/link/Elf/Atom.zig+3-3

 @@ -497,14 +497,14 @@ fn dynAbsRelocAction(symbol: *const Symbol, elf_file: *Elf) RelocAction {
 }
 fn outputType(elf_file: *Elf) u2 {
-    const comp = elf_file.base.comp;
     assert(!elf_file.base.isRelocatable());
-    return switch (elf_file.base.comp.config.output_mode) {
+    const config = &elf_file.base.comp.config;
+    return switch (config.output_mode) {
         .Obj => unreachable,
         .Lib => 0,
         .Exe => switch (elf_file.getTarget().os.tag) {
             .haiku => 0,
-            else => if (comp.config.pie) 1 else 2,
+            else => if (config.pie) 1 else 2,
         },
     };
 }

src/link/Elf/ZigObject.zig+5-7

...	@@ -463,11 +463,8 @@ pub fn flush(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {	...	@@ -463,11 +463,8 @@ pub fn flush(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {
463	for (entry.external_relocs.items) \|reloc\| {	463	for (entry.external_relocs.items) \|reloc\| {
464	const target_sym = self.symbol(reloc.target_sym);	464	const target_sym = self.symbol(reloc.target_sym);
465	const r_offset = entry_off + reloc.source_off;	465	const r_offset = entry_off + reloc.source_off;
466	const r_addend: i64 = switch (reloc.target_off) {	466	const r_addend: i64 = @intCast(reloc.target_off);
467	.none, .got => 0,	467	const r_type = relocation.dwarf.externalRelocType(target_sym.*, sect_index, dwarf.address_size, cpu_arch);
468	else => \|off\| @intCast(@intFromEnum(off)),
469	};
470	const r_type = relocation.dwarf.externalRelocType(target_sym.*, reloc.target_off == .got, sect_index, dwarf.address_size, cpu_arch);
471	atom_ptr.addRelocAssumeCapacity(.{	468	atom_ptr.addRelocAssumeCapacity(.{
472	.r_offset = r_offset,	469	.r_offset = r_offset,
473	.r_addend = r_addend,	470	.r_addend = r_addend,
...	@@ -660,6 +657,7 @@ pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {	...	@@ -660,6 +657,7 @@ pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {
660	const atom_ptr = self.atom(atom_index) orelse continue;	657	const atom_ptr = self.atom(atom_index) orelse continue;
661	if (!atom_ptr.alive) continue;	658	if (!atom_ptr.alive) continue;
662	const shdr = atom_ptr.inputShdr(elf_file);	659	const shdr = atom_ptr.inputShdr(elf_file);
		660	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
663	if (shdr.sh_type == elf.SHT_NOBITS) continue;	661	if (shdr.sh_type == elf.SHT_NOBITS) continue;
664	if (atom_ptr.scanRelocsRequiresCode(elf_file)) {	662	if (atom_ptr.scanRelocsRequiresCode(elf_file)) {
665	// TODO ideally we don't have to fetch the code here.	663	// TODO ideally we don't have to fetch the code here.
...	@@ -950,7 +948,7 @@ pub fn getNavVAddr(	...	@@ -950,7 +948,7 @@ pub fn getNavVAddr(
950	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{	948	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{
951	.source_off = @intCast(reloc_info.offset),	949	.source_off = @intCast(reloc_info.offset),
952	.target_sym = this_sym_index,	950	.target_sym = this_sym_index,
953	.target_off = .rel(reloc_info.addend),	951	.target_off = reloc_info.addend,
954	}),	952	}),
955	.plan9 => unreachable,	953	.plan9 => unreachable,
956	.none => unreachable,	954	.none => unreachable,
...	@@ -983,7 +981,7 @@ pub fn getUavVAddr(	...	@@ -983,7 +981,7 @@ pub fn getUavVAddr(
983	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{	981	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{
984	.source_off = @intCast(reloc_info.offset),	982	.source_off = @intCast(reloc_info.offset),
985	.target_sym = sym_index,	983	.target_sym = sym_index,
986	.target_off = .rel(reloc_info.addend),	984	.target_off = reloc_info.addend,
987	}),	985	}),
988	.plan9 => unreachable,	986	.plan9 => unreachable,
989	.none => unreachable,	987	.none => unreachable,

src/link/Elf/relocation.zig+1-2

 @@ -108,13 +108,12 @@ pub const dwarf = struct {
     pub fn externalRelocType(
         target: Symbol,
-        is_got: bool,
         source_section: Dwarf.Section.Index,
         address_size: Dwarf.AddressSize,
         cpu_arch: std.Target.Cpu.Arch,
     ) u32 {
         return switch (cpu_arch) {
-            .x86_64 => @intFromEnum(@as(elf.R_X86_64, if (is_got) .GOT32 else switch (source_section) {
+            .x86_64 => @intFromEnum(@as(elf.R_X86_64, switch (source_section) {
                 else => switch (address_size) {
                     .@"32" => if (target.flags.is_tls) .DTPOFF32 else .@"32",
                     .@"64" => if (target.flags.is_tls) .DTPOFF64 else .@"64",

src/link/MachO/ZigObject.zig+2-2

...	@@ -648,7 +648,7 @@ pub fn getNavVAddr(	...	@@ -648,7 +648,7 @@ pub fn getNavVAddr(
648	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{	648	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{
649	.source_off = @intCast(reloc_info.offset),	649	.source_off = @intCast(reloc_info.offset),
650	.target_sym = sym_index,	650	.target_sym = sym_index,
651	.target_off = .rel(reloc_info.addend),	651	.target_off = reloc_info.addend,
652	}),	652	}),
653	.plan9 => unreachable,	653	.plan9 => unreachable,
654	.none => unreachable,	654	.none => unreachable,
...	@@ -688,7 +688,7 @@ pub fn getUavVAddr(	...	@@ -688,7 +688,7 @@ pub fn getUavVAddr(
688	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{	688	.dwarf => \|wip_nav\| try wip_nav.infoExternalReloc(.{
689	.source_off = @intCast(reloc_info.offset),	689	.source_off = @intCast(reloc_info.offset),
690	.target_sym = sym_index,	690	.target_sym = sym_index,
691	.target_off = .rel(reloc_info.addend),	691	.target_off = reloc_info.addend,
692	}),	692	}),
693	.plan9 => unreachable,	693	.plan9 => unreachable,
694	.none => unreachable,	694	.none => unreachable,

src/link/Wasm.zig+1-1

...	@@ -2376,7 +2376,7 @@ pub const FunctionImportId = enum(u32) {	...	@@ -2376,7 +2376,7 @@ pub const FunctionImportId = enum(u32) {
2376	const zcu = wasm.base.comp.zcu.?;	2376	const zcu = wasm.base.comp.zcu.?;
2377	const ip = &zcu.intern_pool;	2377	const ip = &zcu.intern_pool;
2378	const ext = ip.getNav(i.ptr(wasm).*).getResolvedExtern(ip).?;	2378	const ext = ip.getNav(i.ptr(wasm).*).getResolvedExtern(ip).?;
2379	return !ext.is_weak_linkage and ext.lib_name != .none;	2379	return ext.linkage != .weak and ext.lib_name != .none;
2380	},	2380	},
2381	};	2381	};
2382	}	2382	}

src/print_air.zig deleted-1038

...	@@ -1,1038 +0,0 @@
1	const std = @import("std");
2	const Allocator = std.mem.Allocator;
3	const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
4
5	const Zcu = @import("Zcu.zig");
6	const Value = @import("Value.zig");
7	const Type = @import("Type.zig");
8	const Air = @import("Air.zig");
9	const InternPool = @import("InternPool.zig");
10
11	pub fn write(stream: anytype, pt: Zcu.PerThread, air: Air, liveness: ?Air.Liveness) void {
12	const instruction_bytes = air.instructions.len *
13	// Here we don't use @sizeOf(Air.Inst.Data) because it would include
14	// the debug safety tag but we want to measure release size.
15	(@sizeOf(Air.Inst.Tag) + 8);
16	const extra_bytes = air.extra.items.len * @sizeOf(u32);
17	const tomb_bytes = if (liveness) \|l\| l.tomb_bits.len * @sizeOf(usize) else 0;
18	const liveness_extra_bytes = if (liveness) \|l\| l.extra.len * @sizeOf(u32) else 0;
19	const liveness_special_bytes = if (liveness) \|l\| l.special.count() * 8 else 0;
20	const total_bytes = @sizeOf(Air) + instruction_bytes + extra_bytes +
21	@sizeOf(Air.Liveness) + liveness_extra_bytes +
22	liveness_special_bytes + tomb_bytes;
23
24	// zig fmt: off
25	stream.print(
26	\\# Total AIR+Liveness bytes: {}
27	\\# AIR Instructions: {d} ({})
28	\\# AIR Extra Data: {d} ({})
29	\\# Liveness tomb_bits: {}
30	\\# Liveness Extra Data: {d} ({})
31	\\# Liveness special table: {d} ({})
32	\\
33	, .{
34	fmtIntSizeBin(total_bytes),
35	air.instructions.len, fmtIntSizeBin(instruction_bytes),
36	air.extra.items.len, fmtIntSizeBin(extra_bytes),
37	fmtIntSizeBin(tomb_bytes),
38	if (liveness) \|l\| l.extra.len else 0, fmtIntSizeBin(liveness_extra_bytes),
39	if (liveness) \|l\| l.special.count() else 0, fmtIntSizeBin(liveness_special_bytes),
40	}) catch return;
41	// zig fmt: on
42
43	var writer: Writer = .{
44	.pt = pt,
45	.gpa = pt.zcu.gpa,
46	.air = air,
47	.liveness = liveness,
48	.indent = 2,
49	.skip_body = false,
50	};
51	writer.writeBody(stream, air.getMainBody()) catch return;
52	}
53
54	pub fn writeInst(
55	stream: anytype,
56	inst: Air.Inst.Index,
57	pt: Zcu.PerThread,
58	air: Air,
59	liveness: ?Air.Liveness,
60	) void {
61	var writer: Writer = .{
62	.pt = pt,
63	.gpa = pt.zcu.gpa,
64	.air = air,
65	.liveness = liveness,
66	.indent = 2,
67	.skip_body = true,
68	};
69	writer.writeInst(stream, inst) catch return;
70	}
71
72	pub fn dump(pt: Zcu.PerThread, air: Air, liveness: ?Air.Liveness) void {
73	write(std.io.getStdErr().writer(), pt, air, liveness);
74	}
75
76	pub fn dumpInst(inst: Air.Inst.Index, pt: Zcu.PerThread, air: Air, liveness: ?Air.Liveness) void {
77	writeInst(std.io.getStdErr().writer(), inst, pt, air, liveness);
78	}
79
80	const Writer = struct {
81	pt: Zcu.PerThread,
82	gpa: Allocator,
83	air: Air,
84	liveness: ?Air.Liveness,
85	indent: usize,
86	skip_body: bool,
87
88	fn writeBody(w: *Writer, s: anytype, body: []const Air.Inst.Index) @TypeOf(s).Error!void {
89	for (body) \|inst\| {
90	try w.writeInst(s, inst);
91	try s.writeByte('\n');
92	}
93	}
94
95	fn writeInst(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
96	const tag = w.air.instructions.items(.tag)[@intFromEnum(inst)];
97	try s.writeByteNTimes(' ', w.indent);
98	try s.print("{}{c}= {s}(", .{
99	inst,
100	@as(u8, if (if (w.liveness) \|liveness\| liveness.isUnused(inst) else false) '!' else ' '),
101	@tagName(tag),
102	});
103	switch (tag) {
104	.add,
105	.add_optimized,
106	.add_safe,
107	.add_wrap,
108	.add_sat,
109	.sub,
110	.sub_optimized,
111	.sub_safe,
112	.sub_wrap,
113	.sub_sat,
114	.mul,
115	.mul_optimized,
116	.mul_safe,
117	.mul_wrap,
118	.mul_sat,
119	.div_float,
120	.div_trunc,
121	.div_floor,
122	.div_exact,
123	.rem,
124	.mod,
125	.bit_and,
126	.bit_or,
127	.xor,
128	.cmp_lt,
129	.cmp_lte,
130	.cmp_eq,
131	.cmp_gte,
132	.cmp_gt,
133	.cmp_neq,
134	.bool_and,
135	.bool_or,
136	.store,
137	.store_safe,
138	.array_elem_val,
139	.slice_elem_val,
140	.ptr_elem_val,
141	.shl,
142	.shl_exact,
143	.shl_sat,
144	.shr,
145	.shr_exact,
146	.set_union_tag,
147	.min,
148	.max,
149	.div_float_optimized,
150	.div_trunc_optimized,
151	.div_floor_optimized,
152	.div_exact_optimized,
153	.rem_optimized,
154	.mod_optimized,
155	.cmp_lt_optimized,
156	.cmp_lte_optimized,
157	.cmp_eq_optimized,
158	.cmp_gte_optimized,
159	.cmp_gt_optimized,
160	.cmp_neq_optimized,
161	.memcpy,
162	.memmove,
163	.memset,
164	.memset_safe,
165	=> try w.writeBinOp(s, inst),
166
167	.is_null,
168	.is_non_null,
169	.is_null_ptr,
170	.is_non_null_ptr,
171	.is_err,
172	.is_non_err,
173	.is_err_ptr,
174	.is_non_err_ptr,
175	.ret,
176	.ret_safe,
177	.ret_load,
178	.is_named_enum_value,
179	.tag_name,
180	.error_name,
181	.sqrt,
182	.sin,
183	.cos,
184	.tan,
185	.exp,
186	.exp2,
187	.log,
188	.log2,
189	.log10,
190	.floor,
191	.ceil,
192	.round,
193	.trunc_float,
194	.neg,
195	.neg_optimized,
196	.cmp_lt_errors_len,
197	.set_err_return_trace,
198	.c_va_end,
199	=> try w.writeUnOp(s, inst),
200
201	.trap,
202	.breakpoint,
203	.dbg_empty_stmt,
204	.unreach,
205	.ret_addr,
206	.frame_addr,
207	.save_err_return_trace_index,
208	=> try w.writeNoOp(s, inst),
209
210	.alloc,
211	.ret_ptr,
212	.err_return_trace,
213	.c_va_start,
214	=> try w.writeTy(s, inst),
215
216	.arg => try w.writeArg(s, inst),
217
218	.not,
219	.bitcast,
220	.load,
221	.fptrunc,
222	.fpext,
223	.intcast,
224	.intcast_safe,
225	.trunc,
226	.optional_payload,
227	.optional_payload_ptr,
228	.optional_payload_ptr_set,
229	.errunion_payload_ptr_set,
230	.wrap_optional,
231	.unwrap_errunion_payload,
232	.unwrap_errunion_err,
233	.unwrap_errunion_payload_ptr,
234	.unwrap_errunion_err_ptr,
235	.wrap_errunion_payload,
236	.wrap_errunion_err,
237	.slice_ptr,
238	.slice_len,
239	.ptr_slice_len_ptr,
240	.ptr_slice_ptr_ptr,
241	.struct_field_ptr_index_0,
242	.struct_field_ptr_index_1,
243	.struct_field_ptr_index_2,
244	.struct_field_ptr_index_3,
245	.array_to_slice,
246	.float_from_int,
247	.splat,
248	.int_from_float,
249	.int_from_float_optimized,
250	.get_union_tag,
251	.clz,
252	.ctz,
253	.popcount,
254	.byte_swap,
255	.bit_reverse,
256	.abs,
257	.error_set_has_value,
258	.addrspace_cast,
259	.c_va_arg,
260	.c_va_copy,
261	=> try w.writeTyOp(s, inst),
262
263	.block, .dbg_inline_block => try w.writeBlock(s, tag, inst),
264
265	.loop => try w.writeLoop(s, inst),
266
267	.slice,
268	.slice_elem_ptr,
269	.ptr_elem_ptr,
270	.ptr_add,
271	.ptr_sub,
272	.add_with_overflow,
273	.sub_with_overflow,
274	.mul_with_overflow,
275	.shl_with_overflow,
276	=> try w.writeTyPlBin(s, inst),
277
278	.call,
279	.call_always_tail,
280	.call_never_tail,
281	.call_never_inline,
282	=> try w.writeCall(s, inst),
283
284	.dbg_var_ptr,
285	.dbg_var_val,
286	.dbg_arg_inline,
287	=> try w.writeDbgVar(s, inst),
288
289	.struct_field_ptr => try w.writeStructField(s, inst),
290	.struct_field_val => try w.writeStructField(s, inst),
291	.inferred_alloc => @panic("TODO"),
292	.inferred_alloc_comptime => @panic("TODO"),
293	.assembly => try w.writeAssembly(s, inst),
294	.dbg_stmt => try w.writeDbgStmt(s, inst),
295
296	.aggregate_init => try w.writeAggregateInit(s, inst),
297	.union_init => try w.writeUnionInit(s, inst),
298	.br => try w.writeBr(s, inst),
299	.switch_dispatch => try w.writeBr(s, inst),
300	.repeat => try w.writeRepeat(s, inst),
301	.cond_br => try w.writeCondBr(s, inst),
302	.@"try", .try_cold => try w.writeTry(s, inst),
303	.try_ptr, .try_ptr_cold => try w.writeTryPtr(s, inst),
304	.loop_switch_br, .switch_br => try w.writeSwitchBr(s, inst),
305	.cmpxchg_weak, .cmpxchg_strong => try w.writeCmpxchg(s, inst),
306	.atomic_load => try w.writeAtomicLoad(s, inst),
307	.prefetch => try w.writePrefetch(s, inst),
308	.atomic_store_unordered => try w.writeAtomicStore(s, inst, .unordered),
309	.atomic_store_monotonic => try w.writeAtomicStore(s, inst, .monotonic),
310	.atomic_store_release => try w.writeAtomicStore(s, inst, .release),
311	.atomic_store_seq_cst => try w.writeAtomicStore(s, inst, .seq_cst),
312	.atomic_rmw => try w.writeAtomicRmw(s, inst),
313	.field_parent_ptr => try w.writeFieldParentPtr(s, inst),
314	.wasm_memory_size => try w.writeWasmMemorySize(s, inst),
315	.wasm_memory_grow => try w.writeWasmMemoryGrow(s, inst),
316	.mul_add => try w.writeMulAdd(s, inst),
317	.select => try w.writeSelect(s, inst),
318	.shuffle_one => try w.writeShuffleOne(s, inst),
319	.shuffle_two => try w.writeShuffleTwo(s, inst),
320	.reduce, .reduce_optimized => try w.writeReduce(s, inst),
321	.cmp_vector, .cmp_vector_optimized => try w.writeCmpVector(s, inst),
322	.vector_store_elem => try w.writeVectorStoreElem(s, inst),
323	.tlv_dllimport_ptr => try w.writeTlvDllimportPtr(s, inst),
324
325	.work_item_id,
326	.work_group_size,
327	.work_group_id,
328	=> try w.writeWorkDimension(s, inst),
329	}
330	try s.writeByte(')');
331	}
332
333	fn writeBinOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
334	const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
335	try w.writeOperand(s, inst, 0, bin_op.lhs);
336	try s.writeAll(", ");
337	try w.writeOperand(s, inst, 1, bin_op.rhs);
338	}
339
340	fn writeUnOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
341	const un_op = w.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
342	try w.writeOperand(s, inst, 0, un_op);
343	}
344
345	fn writeNoOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
346	_ = w;
347	_ = inst;
348	// no-op, no argument to write
349	}
350
351	fn writeType(w: *Writer, s: anytype, ty: Type) !void {
352	return ty.print(s, w.pt);
353	}
354
355	fn writeTy(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
356	const ty = w.air.instructions.items(.data)[@intFromEnum(inst)].ty;
357	try w.writeType(s, ty);
358	}
359
360	fn writeArg(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
361	const arg = w.air.instructions.items(.data)[@intFromEnum(inst)].arg;
362	try w.writeType(s, arg.ty.toType());
363	switch (arg.name) {
364	.none => {},
365	_ => try s.print(", \"{}\"", .{std.zig.fmtEscapes(arg.name.toSlice(w.air))}),
366	}
367	}
368
369	fn writeTyOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
370	const ty_op = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
371	try w.writeType(s, ty_op.ty.toType());
372	try s.writeAll(", ");
373	try w.writeOperand(s, inst, 0, ty_op.operand);
374	}
375
376	fn writeBlock(w: *Writer, s: anytype, tag: Air.Inst.Tag, inst: Air.Inst.Index) @TypeOf(s).Error!void {
377	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
378	try w.writeType(s, ty_pl.ty.toType());
379	const body: []const Air.Inst.Index = @ptrCast(switch (tag) {
380	inline .block, .dbg_inline_block => \|comptime_tag\| body: {
381	const extra = w.air.extraData(switch (comptime_tag) {
382	.block => Air.Block,
383	.dbg_inline_block => Air.DbgInlineBlock,
384	else => unreachable,
385	}, ty_pl.payload);
386	switch (comptime_tag) {
387	.block => {},
388	.dbg_inline_block => {
389	try s.writeAll(", ");
390	try w.writeInstRef(s, Air.internedToRef(extra.data.func), false);
391	},
392	else => unreachable,
393	}
394	break :body w.air.extra.items[extra.end..][0..extra.data.body_len];
395	},
396	else => unreachable,
397	});
398	if (w.skip_body) return s.writeAll(", ...");
399	const liveness_block: Air.Liveness.BlockSlices = if (w.liveness) \|liveness\|
400	liveness.getBlock(inst)
401	else
402	.{ .deaths = &.{} };
403
404	try s.writeAll(", {\n");
405	const old_indent = w.indent;
406	w.indent += 2;
407	try w.writeBody(s, body);
408	w.indent = old_indent;
409	try s.writeByteNTimes(' ', w.indent);
410	try s.writeAll("}");
411
412	for (liveness_block.deaths) \|operand\| {
413	try s.print(" {}!", .{operand});
414	}
415	}
416
417	fn writeLoop(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
418	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
419	const extra = w.air.extraData(Air.Block, ty_pl.payload);
420	const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
421
422	try w.writeType(s, ty_pl.ty.toType());
423	if (w.skip_body) return s.writeAll(", ...");
424	try s.writeAll(", {\n");
425	const old_indent = w.indent;
426	w.indent += 2;
427	try w.writeBody(s, body);
428	w.indent = old_indent;
429	try s.writeByteNTimes(' ', w.indent);
430	try s.writeAll("}");
431	}
432
433	fn writeAggregateInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
434	const zcu = w.pt.zcu;
435	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
436	const vector_ty = ty_pl.ty.toType();
437	const len = @as(usize, @intCast(vector_ty.arrayLen(zcu)));
438	const elements = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[ty_pl.payload..][0..len]));
439
440	try w.writeType(s, vector_ty);
441	try s.writeAll(", [");
442	for (elements, 0..) \|elem, i\| {
443	if (i != 0) try s.writeAll(", ");
444	try w.writeOperand(s, inst, i, elem);
445	}
446	try s.writeAll("]");
447	}
448
449	fn writeUnionInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
450	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
451	const extra = w.air.extraData(Air.UnionInit, ty_pl.payload).data;
452
453	try s.print("{d}, ", .{extra.field_index});
454	try w.writeOperand(s, inst, 0, extra.init);
455	}
456
457	fn writeStructField(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
458	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
459	const extra = w.air.extraData(Air.StructField, ty_pl.payload).data;
460
461	try w.writeOperand(s, inst, 0, extra.struct_operand);
462	try s.print(", {d}", .{extra.field_index});
463	}
464
465	fn writeTyPlBin(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
466	const data = w.air.instructions.items(.data);
467	const ty_pl = data[@intFromEnum(inst)].ty_pl;
468	const extra = w.air.extraData(Air.Bin, ty_pl.payload).data;
469
470	const inst_ty = data[@intFromEnum(inst)].ty_pl.ty.toType();
471	try w.writeType(s, inst_ty);
472	try s.writeAll(", ");
473	try w.writeOperand(s, inst, 0, extra.lhs);
474	try s.writeAll(", ");
475	try w.writeOperand(s, inst, 1, extra.rhs);
476	}
477
478	fn writeCmpxchg(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
479	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
480	const extra = w.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
481
482	try w.writeOperand(s, inst, 0, extra.ptr);
483	try s.writeAll(", ");
484	try w.writeOperand(s, inst, 1, extra.expected_value);
485	try s.writeAll(", ");
486	try w.writeOperand(s, inst, 2, extra.new_value);
487	try s.print(", {s}, {s}", .{
488	@tagName(extra.successOrder()), @tagName(extra.failureOrder()),
489	});
490	}
491
492	fn writeMulAdd(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
493	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
494	const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
495
496	try w.writeOperand(s, inst, 0, extra.lhs);
497	try s.writeAll(", ");
498	try w.writeOperand(s, inst, 1, extra.rhs);
499	try s.writeAll(", ");
500	try w.writeOperand(s, inst, 2, pl_op.operand);
501	}
502
503	fn writeShuffleOne(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
504	const unwrapped = w.air.unwrapShuffleOne(w.pt.zcu, inst);
505	try w.writeType(s, unwrapped.result_ty);
506	try s.writeAll(", ");
507	try w.writeOperand(s, inst, 0, unwrapped.operand);
508	try s.writeAll(", [");
509	for (unwrapped.mask, 0..) \|mask_elem, mask_idx\| {
510	if (mask_idx > 0) try s.writeAll(", ");
511	switch (mask_elem.unwrap()) {
512	.elem => \|idx\| try s.print("elem {d}", .{idx}),
513	.value => \|val\| try s.print("val {}", .{Value.fromInterned(val).fmtValue(w.pt)}),
514	}
515	}
516	try s.writeByte(']');
517	}
518
519	fn writeShuffleTwo(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
520	const unwrapped = w.air.unwrapShuffleTwo(w.pt.zcu, inst);
521	try w.writeType(s, unwrapped.result_ty);
522	try s.writeAll(", ");
523	try w.writeOperand(s, inst, 0, unwrapped.operand_a);
524	try s.writeAll(", ");
525	try w.writeOperand(s, inst, 1, unwrapped.operand_b);
526	try s.writeAll(", [");
527	for (unwrapped.mask, 0..) \|mask_elem, mask_idx\| {
528	if (mask_idx > 0) try s.writeAll(", ");
529	switch (mask_elem.unwrap()) {
530	.a_elem => \|idx\| try s.print("a_elem {d}", .{idx}),
531	.b_elem => \|idx\| try s.print("b_elem {d}", .{idx}),
532	.undef => try s.writeAll("undef"),
533	}
534	}
535	try s.writeByte(']');
536	}
537
538	fn writeSelect(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
539	const zcu = w.pt.zcu;
540	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
541	const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
542
543	const elem_ty = w.typeOfIndex(inst).childType(zcu);
544	try w.writeType(s, elem_ty);
545	try s.writeAll(", ");
546	try w.writeOperand(s, inst, 0, pl_op.operand);
547	try s.writeAll(", ");
548	try w.writeOperand(s, inst, 1, extra.lhs);
549	try s.writeAll(", ");
550	try w.writeOperand(s, inst, 2, extra.rhs);
551	}
552
553	fn writeReduce(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
554	const reduce = w.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
555
556	try w.writeOperand(s, inst, 0, reduce.operand);
557	try s.print(", {s}", .{@tagName(reduce.operation)});
558	}
559
560	fn writeCmpVector(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
561	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
562	const extra = w.air.extraData(Air.VectorCmp, ty_pl.payload).data;
563
564	try s.print("{s}, ", .{@tagName(extra.compareOperator())});
565	try w.writeOperand(s, inst, 0, extra.lhs);
566	try s.writeAll(", ");
567	try w.writeOperand(s, inst, 1, extra.rhs);
568	}
569
570	fn writeVectorStoreElem(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
571	const data = w.air.instructions.items(.data)[@intFromEnum(inst)].vector_store_elem;
572	const extra = w.air.extraData(Air.VectorCmp, data.payload).data;
573
574	try w.writeOperand(s, inst, 0, data.vector_ptr);
575	try s.writeAll(", ");
576	try w.writeOperand(s, inst, 1, extra.lhs);
577	try s.writeAll(", ");
578	try w.writeOperand(s, inst, 2, extra.rhs);
579	}
580
581	fn writeTlvDllimportPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
582	const ip = &w.pt.zcu.intern_pool;
583	const ty_nav = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav;
584	try w.writeType(s, .fromInterned(ty_nav.ty));
585	try s.print(", '{}'", .{ip.getNav(ty_nav.nav).fqn.fmt(ip)});
586	}
587
588	fn writeAtomicLoad(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
589	const atomic_load = w.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
590
591	try w.writeOperand(s, inst, 0, atomic_load.ptr);
592	try s.print(", {s}", .{@tagName(atomic_load.order)});
593	}
594
595	fn writePrefetch(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
596	const prefetch = w.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
597
598	try w.writeOperand(s, inst, 0, prefetch.ptr);
599	try s.print(", {s}, {d}, {s}", .{
600	@tagName(prefetch.rw), prefetch.locality, @tagName(prefetch.cache),
601	});
602	}
603
604	fn writeAtomicStore(
605	w: *Writer,
606	s: anytype,
607	inst: Air.Inst.Index,
608	order: std.builtin.AtomicOrder,
609	) @TypeOf(s).Error!void {
610	const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
611	try w.writeOperand(s, inst, 0, bin_op.lhs);
612	try s.writeAll(", ");
613	try w.writeOperand(s, inst, 1, bin_op.rhs);
614	try s.print(", {s}", .{@tagName(order)});
615	}
616
617	fn writeAtomicRmw(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
618	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
619	const extra = w.air.extraData(Air.AtomicRmw, pl_op.payload).data;
620
621	try w.writeOperand(s, inst, 0, pl_op.operand);
622	try s.writeAll(", ");
623	try w.writeOperand(s, inst, 1, extra.operand);
624	try s.print(", {s}, {s}", .{ @tagName(extra.op()), @tagName(extra.ordering()) });
625	}
626
627	fn writeFieldParentPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
628	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
629	const extra = w.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
630
631	try w.writeOperand(s, inst, 0, extra.field_ptr);
632	try s.print(", {d}", .{extra.field_index});
633	}
634
635	fn writeAssembly(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
636	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
637	const extra = w.air.extraData(Air.Asm, ty_pl.payload);
638	const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
639	const clobbers_len = @as(u31, @truncate(extra.data.flags));
640	var extra_i: usize = extra.end;
641	var op_index: usize = 0;
642
643	const ret_ty = w.typeOfIndex(inst);
644	try w.writeType(s, ret_ty);
645
646	if (is_volatile) {
647	try s.writeAll(", volatile");
648	}
649
650	const outputs = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra_i..][0..extra.data.outputs_len]));
651	extra_i += outputs.len;
652	const inputs = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra_i..][0..extra.data.inputs_len]));
653	extra_i += inputs.len;
654
655	for (outputs) \|output\| {
656	const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
657	const constraint = std.mem.sliceTo(extra_bytes, 0);
658	const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
659
660	// This equation accounts for the fact that even if we have exactly 4 bytes
661	// for the strings and their null terminators, we still use the next u32
662	// for the null terminator.
663	extra_i += (constraint.len + name.len + (2 + 3)) / 4;
664
665	if (output == .none) {
666	try s.print(", [{s}] -> {s}", .{ name, constraint });
667	} else {
668	try s.print(", [{s}] out {s} = (", .{ name, constraint });
669	try w.writeOperand(s, inst, op_index, output);
670	op_index += 1;
671	try s.writeByte(')');
672	}
673	}
674
675	for (inputs) \|input\| {
676	const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
677	const constraint = std.mem.sliceTo(extra_bytes, 0);
678	const name = std.mem.sliceTo(extra_bytes[constraint.len + 1 ..], 0);
679	// This equation accounts for the fact that even if we have exactly 4 bytes
680	// for the strings and their null terminators, we still use the next u32
681	// for the null terminator.
682	extra_i += (constraint.len + name.len + 1) / 4 + 1;
683
684	try s.print(", [{s}] in {s} = (", .{ name, constraint });
685	try w.writeOperand(s, inst, op_index, input);
686	op_index += 1;
687	try s.writeByte(')');
688	}
689
690	{
691	var clobber_i: u32 = 0;
692	while (clobber_i < clobbers_len) : (clobber_i += 1) {
693	const extra_bytes = std.mem.sliceAsBytes(w.air.extra.items[extra_i..]);
694	const clobber = std.mem.sliceTo(extra_bytes, 0);
695	// This equation accounts for the fact that even if we have exactly 4 bytes
696	// for the string, we still use the next u32 for the null terminator.
697	extra_i += clobber.len / 4 + 1;
698
699	try s.writeAll(", ~{");
700	try s.writeAll(clobber);
701	try s.writeAll("}");
702	}
703	}
704	const asm_source = std.mem.sliceAsBytes(w.air.extra.items[extra_i..])[0..extra.data.source_len];
705	try s.print(", \"{}\"", .{std.zig.fmtEscapes(asm_source)});
706	}
707
708	fn writeDbgStmt(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
709	const dbg_stmt = w.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
710	try s.print("{d}:{d}", .{ dbg_stmt.line + 1, dbg_stmt.column + 1 });
711	}
712
713	fn writeDbgVar(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
714	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
715	try w.writeOperand(s, inst, 0, pl_op.operand);
716	const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
717	try s.print(", \"{}\"", .{std.zig.fmtEscapes(name.toSlice(w.air))});
718	}
719
720	fn writeCall(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
721	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
722	const extra = w.air.extraData(Air.Call, pl_op.payload);
723	const args = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[extra.end..][0..extra.data.args_len]));
724	try w.writeOperand(s, inst, 0, pl_op.operand);
725	try s.writeAll(", [");
726	for (args, 0..) \|arg, i\| {
727	if (i != 0) try s.writeAll(", ");
728	try w.writeOperand(s, inst, 1 + i, arg);
729	}
730	try s.writeAll("]");
731	}
732
733	fn writeBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
734	const br = w.air.instructions.items(.data)[@intFromEnum(inst)].br;
735	try w.writeInstIndex(s, br.block_inst, false);
736	try s.writeAll(", ");
737	try w.writeOperand(s, inst, 0, br.operand);
738	}
739
740	fn writeRepeat(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
741	const repeat = w.air.instructions.items(.data)[@intFromEnum(inst)].repeat;
742	try w.writeInstIndex(s, repeat.loop_inst, false);
743	}
744
745	fn writeTry(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
746	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
747	const extra = w.air.extraData(Air.Try, pl_op.payload);
748	const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
749	const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) \|liveness\|
750	liveness.getCondBr(inst)
751	else
752	.{ .then_deaths = &.{}, .else_deaths = &.{} };
753
754	try w.writeOperand(s, inst, 0, pl_op.operand);
755	if (w.skip_body) return s.writeAll(", ...");
756	try s.writeAll(", {\n");
757	const old_indent = w.indent;
758	w.indent += 2;
759
760	if (liveness_condbr.else_deaths.len != 0) {
761	try s.writeByteNTimes(' ', w.indent);
762	for (liveness_condbr.else_deaths, 0..) \|operand, i\| {
763	if (i != 0) try s.writeAll(" ");
764	try s.print("{}!", .{operand});
765	}
766	try s.writeAll("\n");
767	}
768	try w.writeBody(s, body);
769
770	w.indent = old_indent;
771	try s.writeByteNTimes(' ', w.indent);
772	try s.writeAll("}");
773
774	for (liveness_condbr.then_deaths) \|operand\| {
775	try s.print(" {}!", .{operand});
776	}
777	}
778
779	fn writeTryPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
780	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
781	const extra = w.air.extraData(Air.TryPtr, ty_pl.payload);
782	const body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.body_len]);
783	const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) \|liveness\|
784	liveness.getCondBr(inst)
785	else
786	.{ .then_deaths = &.{}, .else_deaths = &.{} };
787
788	try w.writeOperand(s, inst, 0, extra.data.ptr);
789
790	try s.writeAll(", ");
791	try w.writeType(s, ty_pl.ty.toType());
792	if (w.skip_body) return s.writeAll(", ...");
793	try s.writeAll(", {\n");
794	const old_indent = w.indent;
795	w.indent += 2;
796
797	if (liveness_condbr.else_deaths.len != 0) {
798	try s.writeByteNTimes(' ', w.indent);
799	for (liveness_condbr.else_deaths, 0..) \|operand, i\| {
800	if (i != 0) try s.writeAll(" ");
801	try s.print("{}!", .{operand});
802	}
803	try s.writeAll("\n");
804	}
805	try w.writeBody(s, body);
806
807	w.indent = old_indent;
808	try s.writeByteNTimes(' ', w.indent);
809	try s.writeAll("}");
810
811	for (liveness_condbr.then_deaths) \|operand\| {
812	try s.print(" {}!", .{operand});
813	}
814	}
815
816	fn writeCondBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
817	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
818	const extra = w.air.extraData(Air.CondBr, pl_op.payload);
819	const then_body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end..][0..extra.data.then_body_len]);
820	const else_body: []const Air.Inst.Index = @ptrCast(w.air.extra.items[extra.end + then_body.len ..][0..extra.data.else_body_len]);
821	const liveness_condbr: Air.Liveness.CondBrSlices = if (w.liveness) \|liveness\|
822	liveness.getCondBr(inst)
823	else
824	.{ .then_deaths = &.{}, .else_deaths = &.{} };
825
826	try w.writeOperand(s, inst, 0, pl_op.operand);
827	if (w.skip_body) return s.writeAll(", ...");
828	try s.writeAll(",");
829	if (extra.data.branch_hints.true != .none) {
830	try s.print(" {s}", .{@tagName(extra.data.branch_hints.true)});
831	}
832	if (extra.data.branch_hints.then_cov != .none) {
833	try s.print(" {s}", .{@tagName(extra.data.branch_hints.then_cov)});
834	}
835	try s.writeAll(" {\n");
836	const old_indent = w.indent;
837	w.indent += 2;
838
839	if (liveness_condbr.then_deaths.len != 0) {
840	try s.writeByteNTimes(' ', w.indent);
841	for (liveness_condbr.then_deaths, 0..) \|operand, i\| {
842	if (i != 0) try s.writeAll(" ");
843	try s.print("{}!", .{operand});
844	}
845	try s.writeAll("\n");
846	}
847
848	try w.writeBody(s, then_body);
849	try s.writeByteNTimes(' ', old_indent);
850	try s.writeAll("},");
851	if (extra.data.branch_hints.false != .none) {
852	try s.print(" {s}", .{@tagName(extra.data.branch_hints.false)});
853	}
854	if (extra.data.branch_hints.else_cov != .none) {
855	try s.print(" {s}", .{@tagName(extra.data.branch_hints.else_cov)});
856	}
857	try s.writeAll(" {\n");
858
859	if (liveness_condbr.else_deaths.len != 0) {
860	try s.writeByteNTimes(' ', w.indent);
861	for (liveness_condbr.else_deaths, 0..) \|operand, i\| {
862	if (i != 0) try s.writeAll(" ");
863	try s.print("{}!", .{operand});
864	}
865	try s.writeAll("\n");
866	}
867
868	try w.writeBody(s, else_body);
869	w.indent = old_indent;
870
871	try s.writeByteNTimes(' ', old_indent);
872	try s.writeAll("}");
873	}
874
875	fn writeSwitchBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
876	const switch_br = w.air.unwrapSwitch(inst);
877
878	const liveness: Air.Liveness.SwitchBrTable = if (w.liveness) \|liveness\|
879	liveness.getSwitchBr(w.gpa, inst, switch_br.cases_len + 1) catch
880	@panic("out of memory")
881	else blk: {
882	const slice = w.gpa.alloc([]const Air.Inst.Index, switch_br.cases_len + 1) catch
883	@panic("out of memory");
884	@memset(slice, &.{});
885	break :blk .{ .deaths = slice };
886	};
887	defer w.gpa.free(liveness.deaths);
888
889	try w.writeOperand(s, inst, 0, switch_br.operand);
890	if (w.skip_body) return s.writeAll(", ...");
891	const old_indent = w.indent;
892	w.indent += 2;
893
894	var it = switch_br.iterateCases();
895	while (it.next()) \|case\| {
896	try s.writeAll(", [");
897	for (case.items, 0..) \|item, item_i\| {
898	if (item_i != 0) try s.writeAll(", ");
899	try w.writeInstRef(s, item, false);
900	}
901	for (case.ranges, 0..) \|range, range_i\| {
902	if (range_i != 0 or case.items.len != 0) try s.writeAll(", ");
903	try w.writeInstRef(s, range[0], false);
904	try s.writeAll("...");
905	try w.writeInstRef(s, range[1], false);
906	}
907	try s.writeAll("] ");
908	const hint = switch_br.getHint(case.idx);
909	if (hint != .none) {
910	try s.print(".{s} ", .{@tagName(hint)});
911	}
912	try s.writeAll("=> {\n");
913	w.indent += 2;
914
915	const deaths = liveness.deaths[case.idx];
916	if (deaths.len != 0) {
917	try s.writeByteNTimes(' ', w.indent);
918	for (deaths, 0..) \|operand, i\| {
919	if (i != 0) try s.writeAll(" ");
920	try s.print("{}!", .{operand});
921	}
922	try s.writeAll("\n");
923	}
924
925	try w.writeBody(s, case.body);
926	w.indent -= 2;
927	try s.writeByteNTimes(' ', w.indent);
928	try s.writeAll("}");
929	}
930
931	const else_body = it.elseBody();
932	if (else_body.len != 0) {
933	try s.writeAll(", else ");
934	const hint = switch_br.getElseHint();
935	if (hint != .none) {
936	try s.print(".{s} ", .{@tagName(hint)});
937	}
938	try s.writeAll("=> {\n");
939	w.indent += 2;
940
941	const deaths = liveness.deaths[liveness.deaths.len - 1];
942	if (deaths.len != 0) {
943	try s.writeByteNTimes(' ', w.indent);
944	for (deaths, 0..) \|operand, i\| {
945	if (i != 0) try s.writeAll(" ");
946	try s.print("{}!", .{operand});
947	}
948	try s.writeAll("\n");
949	}
950
951	try w.writeBody(s, else_body);
952	w.indent -= 2;
953	try s.writeByteNTimes(' ', w.indent);
954	try s.writeAll("}");
955	}
956
957	try s.writeAll("\n");
958	try s.writeByteNTimes(' ', old_indent);
959	}
960
961	fn writeWasmMemorySize(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
962	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
963	try s.print("{d}", .{pl_op.payload});
964	}
965
966	fn writeWasmMemoryGrow(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
967	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
968	try s.print("{d}, ", .{pl_op.payload});
969	try w.writeOperand(s, inst, 0, pl_op.operand);
970	}
971
972	fn writeWorkDimension(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
973	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
974	try s.print("{d}", .{pl_op.payload});
975	}
976
977	fn writeOperand(
978	w: *Writer,
979	s: anytype,
980	inst: Air.Inst.Index,
981	op_index: usize,
982	operand: Air.Inst.Ref,
983	) @TypeOf(s).Error!void {
984	const small_tomb_bits = Air.Liveness.bpi - 1;
985	const dies = if (w.liveness) \|liveness\| blk: {
986	if (op_index < small_tomb_bits)
987	break :blk liveness.operandDies(inst, @intCast(op_index));
988	var extra_index = liveness.special.get(inst).?;
989	var tomb_op_index: usize = small_tomb_bits;
990	while (true) {
991	const bits = liveness.extra[extra_index];
992	if (op_index < tomb_op_index + 31) {
993	break :blk @as(u1, @truncate(bits >> @as(u5, @intCast(op_index - tomb_op_index)))) != 0;
994	}
995	if ((bits >> 31) != 0) break :blk false;
996	extra_index += 1;
997	tomb_op_index += 31;
998	}
999	} else false;
1000	return w.writeInstRef(s, operand, dies);
1001	}
1002
1003	fn writeInstRef(
1004	w: *Writer,
1005	s: anytype,
1006	operand: Air.Inst.Ref,
1007	dies: bool,
1008	) @TypeOf(s).Error!void {
1009	if (@intFromEnum(operand) < InternPool.static_len) {
1010	return s.print("@{}", .{operand});
1011	} else if (operand.toInterned()) \|ip_index\| {
1012	const pt = w.pt;
1013	const ty = Type.fromInterned(pt.zcu.intern_pool.indexToKey(ip_index).typeOf());
1014	try s.print("<{}, {}>", .{
1015	ty.fmt(pt),
1016	Value.fromInterned(ip_index).fmtValue(pt),
1017	});
1018	} else {
1019	return w.writeInstIndex(s, operand.toIndex().?, dies);
1020	}
1021	}
1022
1023	fn writeInstIndex(
1024	w: *Writer,
1025	s: anytype,
1026	inst: Air.Inst.Index,
1027	dies: bool,
1028	) @TypeOf(s).Error!void {
1029	_ = w;
1030	try s.print("{}", .{inst});
1031	if (dies) try s.writeByte('!');
1032	}
1033
1034	fn typeOfIndex(w: *Writer, inst: Air.Inst.Index) Type {
1035	const zcu = w.pt.zcu;
1036	return w.air.typeOfIndex(inst, &zcu.intern_pool);
1037	}
1038	};

test/cases/compile_errors/@import_zon_bad_type.zig+3-3

...	@@ -117,9 +117,9 @@ export fn testMutablePointer() void {	...	@@ -117,9 +117,9 @@ export fn testMutablePointer() void {
117	// tmp.zig:37:38: note: imported here	117	// tmp.zig:37:38: note: imported here
118	// neg_inf.zon:1:1: error: expected type '?u8'	118	// neg_inf.zon:1:1: error: expected type '?u8'
119	// tmp.zig:57:28: note: imported here	119	// tmp.zig:57:28: note: imported here
120	// neg_inf.zon:1:1: error: expected type 'tmp.testNonExhaustiveEnum__enum_522'	120	// neg_inf.zon:1:1: error: expected type 'tmp.testNonExhaustiveEnum__enum_525'
121	// tmp.zig:62:39: note: imported here	121	// tmp.zig:62:39: note: imported here
122	// neg_inf.zon:1:1: error: expected type 'tmp.testUntaggedUnion__union_524'	122	// neg_inf.zon:1:1: error: expected type 'tmp.testUntaggedUnion__union_527'
123	// tmp.zig:67:44: note: imported here	123	// tmp.zig:67:44: note: imported here
124	// neg_inf.zon:1:1: error: expected type 'tmp.testTaggedUnionVoid__union_527'	124	// neg_inf.zon:1:1: error: expected type 'tmp.testTaggedUnionVoid__union_530'
125	// tmp.zig:72:50: note: imported here	125	// tmp.zig:72:50: note: imported here

test/cases/compile_errors/anytype_param_requires_comptime.zig+1-1

...	@@ -15,6 +15,6 @@ pub export fn entry() void {	...	@@ -15,6 +15,6 @@ pub export fn entry() void {
15	// error	15	// error
16	//	16	//
17	// :7:25: error: unable to resolve comptime value	17	// :7:25: error: unable to resolve comptime value
18	// :7:25: note: initializer of comptime-only struct 'tmp.S.foo__anon_496.C' must be comptime-known	18	// :7:25: note: initializer of comptime-only struct 'tmp.S.foo__anon_499.C' must be comptime-known
19	// :4:16: note: struct requires comptime because of this field	19	// :4:16: note: struct requires comptime because of this field
20	// :4:16: note: types are not available at runtime	20	// :4:16: note: types are not available at runtime

test/cases/compile_errors/bogus_method_call_on_slice.zig+1-1

...	@@ -16,5 +16,5 @@ pub export fn entry2() void {	...	@@ -16,5 +16,5 @@ pub export fn entry2() void {
16	//	16	//
17	// :3:6: error: no field or member function named 'copy' in '[]const u8'	17	// :3:6: error: no field or member function named 'copy' in '[]const u8'
18	// :9:8: error: no field or member function named 'bar' in '@TypeOf(.{})'	18	// :9:8: error: no field or member function named 'bar' in '@TypeOf(.{})'
19	// :12:18: error: no field or member function named 'bar' in 'tmp.entry2__struct_500'	19	// :12:18: error: no field or member function named 'bar' in 'tmp.entry2__struct_503'
20	// :12:6: note: struct declared here	20	// :12:6: note: struct declared here

test/cases/compile_errors/coerce_anon_struct.zig+1-1

...	@@ -6,6 +6,6 @@ export fn foo() void {	...	@@ -6,6 +6,6 @@ export fn foo() void {
6		6
7	// error	7	// error
8	//	8	//
9	// :4:16: error: expected type 'tmp.T', found 'tmp.foo__struct_489'	9	// :4:16: error: expected type 'tmp.T', found 'tmp.foo__struct_492'
10	// :3:16: note: struct declared here	10	// :3:16: note: struct declared here
11	// :1:11: note: struct declared here	11	// :1:11: note: struct declared here

test/cases/compile_errors/redundant_try.zig+2-2

...	@@ -44,9 +44,9 @@ comptime {	...	@@ -44,9 +44,9 @@ comptime {
44	//	44	//
45	// :5:23: error: expected error union type, found 'comptime_int'	45	// :5:23: error: expected error union type, found 'comptime_int'
46	// :10:23: error: expected error union type, found '@TypeOf(.{})'	46	// :10:23: error: expected error union type, found '@TypeOf(.{})'
47	// :15:23: error: expected error union type, found 'tmp.test2__struct_526'	47	// :15:23: error: expected error union type, found 'tmp.test2__struct_529'
48	// :15:23: note: struct declared here	48	// :15:23: note: struct declared here
49	// :20:27: error: expected error union type, found 'tmp.test3__struct_528'	49	// :20:27: error: expected error union type, found 'tmp.test3__struct_531'
50	// :20:27: note: struct declared here	50	// :20:27: note: struct declared here
51	// :25:23: error: expected error union type, found 'struct { comptime *const [5:0]u8 = "hello" }'	51	// :25:23: error: expected error union type, found 'struct { comptime *const [5:0]u8 = "hello" }'
52	// :31:13: error: expected error union type, found 'u32'	52	// :31:13: error: expected error union type, found 'u32'

test/tests.zig+5-4

...	@@ -1598,7 +1598,9 @@ const c_abi_targets = blk: {	...	@@ -1598,7 +1598,9 @@ const c_abi_targets = blk: {
1598	break :blk [_]CAbiTarget{	1598	break :blk [_]CAbiTarget{
1599	// Native Targets	1599	// Native Targets
1600		1600
1601	.{},	1601	.{
		1602	.use_llvm = true,
		1603	},
1602		1604
1603	// Linux Targets	1605	// Linux Targets
1604		1606
...	@@ -1837,7 +1839,6 @@ const c_abi_targets = blk: {	...	@@ -1837,7 +1839,6 @@ const c_abi_targets = blk: {
1837	.abi = .musl,	1839	.abi = .musl,
1838	},	1840	},
1839	.use_llvm = false,	1841	.use_llvm = false,
1840	.use_lld = false,
1841	.c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},	1842	.c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},
1842	},	1843	},
1843	.{	1844	.{
...	@@ -1848,7 +1849,6 @@ const c_abi_targets = blk: {	...	@@ -1848,7 +1849,6 @@ const c_abi_targets = blk: {
1848	.abi = .musl,	1849	.abi = .musl,
1849	},	1850	},
1850	.use_llvm = false,	1851	.use_llvm = false,
1851	.use_lld = false,
1852	.strip = true,	1852	.strip = true,
1853	.c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},	1853	.c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},
1854	},	1854	},
...	@@ -1860,7 +1860,6 @@ const c_abi_targets = blk: {	...	@@ -1860,7 +1860,6 @@ const c_abi_targets = blk: {
1860	.abi = .musl,	1860	.abi = .musl,
1861	},	1861	},
1862	.use_llvm = false,	1862	.use_llvm = false,
1863	.use_lld = false,
1864	.pic = true,	1863	.pic = true,
1865	.c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},	1864	.c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},
1866	},	1865	},
...	@@ -1870,6 +1869,7 @@ const c_abi_targets = blk: {	...	@@ -1870,6 +1869,7 @@ const c_abi_targets = blk: {
1870	.os_tag = .linux,	1869	.os_tag = .linux,
1871	.abi = .musl,	1870	.abi = .musl,
1872	},	1871	},
		1872	.use_llvm = true,
1873	},	1873	},
1874	.{	1874	.{
1875	.target = .{	1875	.target = .{
...	@@ -1877,6 +1877,7 @@ const c_abi_targets = blk: {	...	@@ -1877,6 +1877,7 @@ const c_abi_targets = blk: {
1877	.os_tag = .linux,	1877	.os_tag = .linux,
1878	.abi = .muslx32,	1878	.abi = .muslx32,
1879	},	1879	},
		1880	.use_llvm = true,
1880	},	1881	},
1881		1882
1882	// WASI Targets	1883	// WASI Targets

author	Jacob Young <jacobly@ziglang.org> 2025-06-04 21:45:31-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-06-06 23:42:14-07:00
log	0bf8617d963dc432ed0204b10285cc414becf2fd
tree	b4a28f10bd66183cd949e6f0fbb4a786bfc1aa04
parent	178ee8aef1b9f765da916f3e1e4cab66437f8e0a

...	@@ -189,12 +189,12 @@ pub fn emitMir(emit: *Emit) Error!void {	...	@@ -189,12 +189,12 @@ pub fn emitMir(emit: *Emit) Error!void {
189	.r_addend = lowered_relocs[0].off,	189	.r_addend = lowered_relocs[0].off,
190	}, zo);	190	}, zo);
191	},	191	},
192	.linker_reloc => \|sym_index\| if (emit.lower.bin_file.cast(.elf)) \|elf_file\| {	192	.linker_reloc, .linker_pcrel => \|sym_index\| if (emit.lower.bin_file.cast(.elf)) \|elf_file\| {
193	const zo = elf_file.zigObjectPtr().?;	193	const zo = elf_file.zigObjectPtr().?;
194	const atom = zo.symbol(emit.atom_index).atom(elf_file).?;	194	const atom = zo.symbol(emit.atom_index).atom(elf_file).?;
195	const sym = zo.symbol(sym_index);	195	const sym = zo.symbol(sym_index);
196	if (emit.lower.pic) {	196	if (emit.lower.pic) {
197	const r_type: u32 = if (sym.flags.is_extern_ptr)	197	const r_type: u32 = if (sym.flags.is_extern_ptr and lowered_relocs[0].target != .linker_pcrel)
198	@intFromEnum(std.elf.R_X86_64.GOTPCREL)	198	@intFromEnum(std.elf.R_X86_64.GOTPCREL)
199	else	199	else
200	@intFromEnum(std.elf.R_X86_64.PC32);	200	@intFromEnum(std.elf.R_X86_64.PC32);
...	@@ -218,7 +218,7 @@ pub fn emitMir(emit: *Emit) Error!void {	...	@@ -218,7 +218,7 @@ pub fn emitMir(emit: *Emit) Error!void {
218	const zo = macho_file.getZigObject().?;	218	const zo = macho_file.getZigObject().?;
219	const atom = zo.symbols.items[emit.atom_index].getAtom(macho_file).?;	219	const atom = zo.symbols.items[emit.atom_index].getAtom(macho_file).?;
220	const sym = &zo.symbols.items[sym_index];	220	const sym = &zo.symbols.items[sym_index];
221	const @"type": link.File.MachO.Relocation.Type = if (sym.flags.is_extern_ptr)	221	const @"type": link.File.MachO.Relocation.Type = if (sym.flags.is_extern_ptr and lowered_relocs[0].target != .linker_pcrel)
222	.got_load	222	.got_load
223	else if (sym.flags.tlv)	223	else if (sym.flags.tlv)
224	.tlv	224	.tlv
...	@@ -438,6 +438,7 @@ pub fn emitMir(emit: *Emit) Error!void {	...	@@ -438,6 +438,7 @@ pub fn emitMir(emit: *Emit) Error!void {
438	.reg => \|reg\| .{ .breg = reg.dwarfNum() },	438	.reg => \|reg\| .{ .breg = reg.dwarfNum() },
439	.frame, .table, .rip_inst => unreachable,	439	.frame, .table, .rip_inst => unreachable,
440	.reloc => \|sym_index\| .{ .addr_reloc = sym_index },	440	.reloc => \|sym_index\| .{ .addr_reloc = sym_index },
		441	.pcrel => unreachable,
441	};	442	};
442	break :base &loc_buf[0];	443	break :base &loc_buf[0];
443	},	444	},

...	@@ -1866,7 +1866,7 @@ pub const Memory = struct {	...	@@ -1866,7 +1866,7 @@ pub const Memory = struct {
1866	.none, .table => undefined,	1866	.none, .table => undefined,
1867	.reg => \|reg\| @intFromEnum(reg),	1867	.reg => \|reg\| @intFromEnum(reg),
1868	.frame => \|frame_index\| @intFromEnum(frame_index),	1868	.frame => \|frame_index\| @intFromEnum(frame_index),
1869	.reloc => \|sym_index\| sym_index,	1869	.reloc, .pcrel => \|sym_index\| sym_index,
1870	.rip_inst => \|inst_index\| inst_index,	1870	.rip_inst => \|inst_index\| inst_index,
1871	},	1871	},
1872	.off = switch (mem.mod) {	1872	.off = switch (mem.mod) {
...	@@ -1895,6 +1895,7 @@ pub const Memory = struct {	...	@@ -1895,6 +1895,7 @@ pub const Memory = struct {
1895	.frame => .{ .frame = @enumFromInt(mem.base) },	1895	.frame => .{ .frame = @enumFromInt(mem.base) },
1896	.table => .table,	1896	.table => .table,
1897	.reloc => .{ .reloc = mem.base },	1897	.reloc => .{ .reloc = mem.base },
		1898	.pcrel => .{ .pcrel = mem.base },
1898	.rip_inst => .{ .rip_inst = mem.base },	1899	.rip_inst => .{ .rip_inst = mem.base },
1899	},	1900	},
1900	.scale_index = switch (mem.info.index) {	1901	.scale_index = switch (mem.info.index) {
...	@@ -1959,7 +1960,7 @@ pub fn resolveFrameAddr(mir: Mir, frame_addr: bits.FrameAddr) bits.RegisterOffse	...	@@ -1959,7 +1960,7 @@ pub fn resolveFrameAddr(mir: Mir, frame_addr: bits.FrameAddr) bits.RegisterOffse
1959		1960
1960	pub fn resolveFrameLoc(mir: Mir, mem: Memory) Memory {	1961	pub fn resolveFrameLoc(mir: Mir, mem: Memory) Memory {
1961	return switch (mem.info.base) {	1962	return switch (mem.info.base) {
1962	.none, .reg, .table, .reloc, .rip_inst => mem,	1963	.none, .reg, .table, .reloc, .pcrel, .rip_inst => mem,
1963	.frame => if (mir.frame_locs.len > 0) .{	1964	.frame => if (mir.frame_locs.len > 0) .{
1964	.info = .{	1965	.info = .{
1965	.base = .reg,	1966	.base = .reg,

...	@@ -138,7 +138,7 @@ pub const Instruction = struct {	...	@@ -138,7 +138,7 @@ pub const Instruction = struct {
138	.moffs => true,	138	.moffs => true,
139	.rip => false,	139	.rip => false,
140	.sib => \|s\| switch (s.base) {	140	.sib => \|s\| switch (s.base) {
141	.none, .frame, .table, .reloc, .rip_inst => false,	141	.none, .frame, .table, .reloc, .pcrel, .rip_inst => false,
142	.reg => \|reg\| reg.isClass(.segment),	142	.reg => \|reg\| reg.isClass(.segment),
143	},	143	},
144	};	144	};
...	@@ -211,7 +211,7 @@ pub const Instruction = struct {	...	@@ -211,7 +211,7 @@ pub const Instruction = struct {
211	.none, .imm => 0b00,	211	.none, .imm => 0b00,
212	.reg => \|reg\| @truncate(reg.enc() >> 3),	212	.reg => \|reg\| @truncate(reg.enc() >> 3),
213	.mem => \|mem\| switch (mem.base()) {	213	.mem => \|mem\| switch (mem.base()) {
214	.none, .frame, .table, .reloc, .rip_inst => 0b00, // rsp, rbp, and rip are not extended	214	.none, .frame, .table, .reloc, .pcrel, .rip_inst => 0b00, // rsp, rbp, and rip are not extended
215	.reg => \|reg\| @truncate(reg.enc() >> 3),	215	.reg => \|reg\| @truncate(reg.enc() >> 3),
216	},	216	},
217	.bytes => unreachable,	217	.bytes => unreachable,
...	@@ -282,6 +282,7 @@ pub const Instruction = struct {	...	@@ -282,6 +282,7 @@ pub const Instruction = struct {
282	.frame => \|frame_index\| try writer.print("{}", .{frame_index}),	282	.frame => \|frame_index\| try writer.print("{}", .{frame_index}),
283	.table => try writer.print("Table", .{}),	283	.table => try writer.print("Table", .{}),
284	.reloc => \|sym_index\| try writer.print("Symbol({d})", .{sym_index}),	284	.reloc => \|sym_index\| try writer.print("Symbol({d})", .{sym_index}),
		285	.pcrel => \|sym_index\| try writer.print("PcRelSymbol({d})", .{sym_index}),
285	.rip_inst => \|inst_index\| try writer.print("RipInst({d})", .{inst_index}),	286	.rip_inst => \|inst_index\| try writer.print("RipInst({d})", .{inst_index}),
286	}	287	}
287	if (mem.scaleIndex()) \|si\| {	288	if (mem.scaleIndex()) \|si\| {
...	@@ -721,7 +722,7 @@ pub const Instruction = struct {	...	@@ -721,7 +722,7 @@ pub const Instruction = struct {
721	try encoder.modRm_indirectDisp32(operand_enc, 0);	722	try encoder.modRm_indirectDisp32(operand_enc, 0);
722	try encoder.disp32(undefined);	723	try encoder.disp32(undefined);
723	} else return error.CannotEncode,	724	} else return error.CannotEncode,
724	.rip_inst => {	725	.pcrel, .rip_inst => {
725	try encoder.modRm_RIPDisp32(operand_enc);	726	try encoder.modRm_RIPDisp32(operand_enc);
726	try encoder.disp32(sib.disp);	727	try encoder.disp32(sib.disp);
727	},	728	},

x86_64: add support for pie executables