Commit 1c6d19b0ff6c816cf9f73507e7e4ff35b19a1e1d | zig

author	Casey Banner <kcbanner@gmail.com> 2026-06-05 01:55:36-04:00
committer	Casey Banner <kcbanner@gmail.com> 2026-06-23 00:27:14-04:00
log	1c6d19b0ff6c816cf9f73507e7e4ff35b19a1e1d
tree	00f0bd41894a6d55f7552960516b94a64c9c2f18
parent	ab46b8235450cd1d8cb1a483859c2265588a1863

tests: more work on the linker snapshot testing framework

build: add the ability to test the output of a Run step against a snapshot
objdump:  add --redact, --omit-element, --snapshot, and --only-symbol

11 files changed, 634 insertions(+), 344 deletions(-)

lib
- compiler
  - Maker
    Step
    Run.zig
  - configurer.zig
  - objdump.zig
- std
  - Build
    Configuration.zig
    Step
    Run.zig
test
- link.zig
- link
  - exports.zig
  - snapshots
    exports-dynamic.lib.dmp
    exports-static.lib.dmp
- src
  - Link.zig
- tests.zig

lib/compiler/Maker/Step/Run.zig+47-2

...	...	@@ -2100,6 +2100,47 @@ fn runCommand(
2100	2100	});
2101	2101	}
2102	2102	}
	2103	const snapshots: []const ?struct {
	2104	path: Cache.Path,
	2105	result: enum { stderr, stdout },
	2106	} = &.{
	2107	if (conf_run.expect_stderr_snapshot.value) \|path\| .{
	2108	.path = try maker.resolveLazyPathIndex(arena, path, run_index),
	2109	.result = .stderr,
	2110	} else null,
	2111	if (conf_run.expect_stdout_snapshot.value) \|path\| .{
	2112	.path = try maker.resolveLazyPathIndex(arena, path, run_index),
	2113	.result = .stdout,
	2114	} else null,
	2115	};
	2116	for (snapshots) \|opt_snapshot\| {
	2117	const snapshot = opt_snapshot orelse continue;
	2118
	2119	const file = snapshot.path.root_dir.handle.openFile(io, snapshot.path.sub_path, .{}) catch \|err\|
	2120	return step.fail(maker, "unable to open snapshot file {f}: {t}", .{ snapshot.path, err });
	2121	defer file.close(io);
	2122
	2123	var file_reader = file.reader(io, &.{});
	2124	const snapshot_contents = file_reader.interface.allocRemaining(gpa, .unlimited) catch \|err\|
	2125	return step.fail(maker, "unable to read snapshot file {f}: {t}", .{ snapshot.path, err });
	2126	defer gpa.free(snapshot_contents);
	2127
	2128	const result = switch (snapshot.result) {
	2129	.stdout => generic_result.stdout.?,
	2130	.stderr => generic_result.stderr.?,
	2131	};
	2132	if (!mem.eql(u8, snapshot_contents, result)) {
	2133	return step.fail(maker,
	2134	\\
	2135	\\========= snapshot file: =========
	2136	\\{f}
	2137	\\========= contained: =============
	2138	\\{s}
	2139	\\========= {t} output was: ========
	2140	\\{s}
	2141	, .{ snapshot.path, snapshot_contents, snapshot.result, result });
	2142	}
	2143	}
2103	2144	},
2104	2145	else => {
2105	2146	// On failure, report captured stderr like normal standard error output.
...	...	@@ -2283,11 +2324,15 @@ fn setColorEnvironmentVariables(
2283	2324	}
2284	2325
2285	2326	fn checksContainStdout(conf_run: *const Configuration.Step.Run) bool {
2286		return conf_run.expect_stdout_exact.value != null or conf_run.expect_stdout_match.slice.len != 0;
	2327	return conf_run.expect_stdout_exact.value != null or
	2328	conf_run.expect_stdout_match.slice.len != 0 or
	2329	conf_run.expect_stdout_snapshot.value != null;
2287	2330	}
2288	2331
2289	2332	fn checksContainStderr(conf_run: *const Configuration.Step.Run) bool {
2290		return conf_run.expect_stderr_exact.value != null or conf_run.expect_stderr_match.slice.len != 0;
	2333	return conf_run.expect_stderr_exact.value != null or
	2334	conf_run.expect_stderr_match.slice.len != 0 or
	2335	conf_run.expect_stderr_snapshot.value != null;
2291	2336	}
2292	2337
2293	2338	/// If `path` is cwd-relative, make it relative to the cwd of the child instead.

lib/compiler/configurer.zig+8

...	...	@@ -1006,6 +1006,8 @@ fn serialize(b: std.Build, wc: Configuration.Wip, writer: *Io.Writer) !void {
1006	1006	status: Configuration.Step.Run.ExpectTermStatus,
1007	1007	value: u32,
1008	1008	} = null;
	1009	var expect_stderr_snapshot: ?Configuration.LazyPath.Index = null;
	1010	var expect_stdout_snapshot: ?Configuration.LazyPath.Index = null;
1009	1011	switch (run.stdio) {
1010	1012	.check => \|checks\| for (checks.items) \|check\| switch (check) {
1011	1013	.expect_stderr_exact => \|bytes\| expect_stderr_exact = try wc.addBytes(bytes),
...	...	@@ -1022,6 +1024,8 @@ fn serialize(b: std.Build, wc: Configuration.Wip, writer: *Io.Writer) !void {
1022	1024	.stopped => \|x\| .{ .status = .stopped, .value = @intFromEnum(x) },
1023	1025	.unknown => \|x\| .{ .status = .unknown, .value = x },
1024	1026	},
	1027	.expect_stderr_snapshot => \|path\| expect_stderr_snapshot = try s.addLazyPath(path),
	1028	.expect_stdout_snapshot => \|path\| expect_stdout_snapshot = try s.addLazyPath(path),
1025	1029	},
1026	1030	else => {},
1027	1031	}
...	...	@@ -1061,6 +1065,8 @@ fn serialize(b: std.Build, wc: Configuration.Wip, writer: *Io.Writer) !void {
1061	1065	.expect_stdout_match = expect_stdout_match.items.len != 0,
1062	1066	.expect_term = expect_term != null,
1063	1067	.expect_term_status = if (expect_term) \|t\| t.status else .exited,
	1068	.expect_stderr_snapshot = expect_stderr_snapshot != null,
	1069	.expect_stdout_snapshot = expect_stdout_snapshot != null,
1064	1070	},
1065	1071	.file_inputs = .{ .slice = try s.initLazyPathList(run.file_inputs.items) },
1066	1072	.args = .{ .slice = try s.initArgsList(run.argv.items) },
...	...	@@ -1081,6 +1087,8 @@ fn serialize(b: std.Build, wc: Configuration.Wip, writer: *Io.Writer) !void {
1081	1087	.expect_stdout_exact = .{ .value = if (expect_stdout_exact) \|bytes\| bytes else null },
1082	1088	.expect_stderr_match = .{ .slice = expect_stderr_match.items },
1083	1089	.expect_stdout_match = .{ .slice = expect_stdout_match.items },
	1090	.expect_stderr_snapshot = .{ .value = expect_stderr_snapshot orelse null },
	1091	.expect_stdout_snapshot = .{ .value = expect_stdout_snapshot orelse null },
1084	1092	.stdin = .{ .u = switch (run.stdin) {
1085	1093	.none => .none,
1086	1094	.bytes => \|bytes\| .{ .bytes = try wc.addBytes(bytes) },

lib/compiler/objdump.zig+448-297

...	...	@@ -16,9 +16,12 @@ const Options = struct {
16	16	input_path: []const u8,
17	17	member_filters: []const []const u8 = &.{},
18	18	member_headers: bool,
	19	omit_elements: std.enums.EnumArray(Element, bool),
	20	redact: std.enums.EnumArray(FieldKind, bool),
19	21	relocs: bool,
20	22	section_filters: []const []const u8 = &.{},
21	23	section_headers: bool,
	24	symbol_filters: []const []const u8 = &.{},
22	25	strings: bool,
23	26	symbols: bool,
24	27	tls: bool,
...	...	@@ -27,6 +30,20 @@ const Options = struct {
27	30	linker_member: ?std.coff.ArchiveMemberHeader.Kind,
28	31	};
29	32
	33	const FieldKind = enum {
	34	va,
	35	rva,
	36	ord,
	37	size,
	38	};
	39
	40	const Element = enum {
	41	@"file-type",
	42	@"table-header",
	43	@"header-names",
	44	newlines,
	45	};
	46
30	47	pub fn main(init: std.process.Init) !void {
31	48	const io = init.io;
32	49	const args = try init.minimal.args.toSlice(init.arena.allocator());
...	...	@@ -40,12 +57,15 @@ pub fn main(init: std.process.Init) !void {
40	57	var opt_input_path: ?[]const u8 = null;
41	58	var opt_linker_member: ?std.coff.ArchiveMemberHeader.Kind = null;
42	59	var opt_member_headers: ?bool = null;
	60	var omit_elements: @FieldType(Options, "omit_elements") = .initFill(false);
	61	var redact: @FieldType(Options, "redact") = .initFill(false);
43	62	var opt_relocs: ?bool = null;
44	63	var opt_section_headers: ?bool = null;
45	64	var opt_strings: ?bool = null;
46	65	var opt_symbols: ?bool = null;
47	66	var opt_tls: ?bool = null;
48	67	var section_filters: std.ArrayList([]const u8) = .empty;
	68	var symbol_filters: std.ArrayList([]const u8) = .empty;
49	69	var member_filters: std.ArrayList([]const u8) = .empty;
50	70	while (i < args.len) : (i += 1) {
51	71	const arg = args[i];
...	...	@@ -73,14 +93,37 @@ pub fn main(init: std.process.Init) !void {
73	93	opt_linker_member = .second_linker;
74	94	} else if (mem.eql(u8, arg, "--member-headers")) {
75	95	opt_member_headers = true;
76		} else if (mem.startsWith(u8, arg, "--only-section=")) {
77		(try section_filters.addOne(arena)).* = try arena.dupe(u8, arg["--only-section=".len..]);
	96	} else if (mem.startsWith(u8, arg, "--omit-element=")) {
	97	const kind = arg["--omit-element=".len..];
	98	if (std.meta.stringToEnum(Element, kind)) \|format_kind\| {
	99	omit_elements.set(format_kind, true);
	100	} else if (std.mem.eql(u8, kind, "all")) {
	101	omit_elements = .initFill(true);
	102	} else {
	103	fatal("unrecognized element: {s}", .{kind});
	104	}
78	105	} else if (mem.startsWith(u8, arg, "--only-member=")) {
79	106	(try member_filters.addOne(arena)).* = try arena.dupe(u8, arg["--only-member=".len..]);
	107	} else if (mem.startsWith(u8, arg, "--only-section=")) {
	108	(try section_filters.addOne(arena)).* = try arena.dupe(u8, arg["--only-section=".len..]);
	109	} else if (mem.startsWith(u8, arg, "--only-symbol=")) {
	110	(try symbol_filters.addOne(arena)).* = try arena.dupe(u8, arg["--only-symbol=".len..]);
	111	} else if (mem.startsWith(u8, arg, "--redact=")) {
	112	const kind = arg["--redact=".len..];
	113	if (std.meta.stringToEnum(FieldKind, kind)) \|field_kind\| {
	114	redact.set(field_kind, true);
	115	} else if (std.mem.eql(u8, kind, "all")) {
	116	redact = .initFill(true);
	117	} else {
	118	fatal("unrecognized redaction kind: {s}", .{kind});
	119	}
80	120	} else if (mem.eql(u8, arg, "--relocs")) {
81	121	opt_relocs = true;
82	122	} else if (mem.eql(u8, arg, "--section-headers")) {
83	123	opt_section_headers = true;
	124	} else if (mem.eql(u8, arg, "-s") or mem.eql(u8, arg, "--snapshot")) {
	125	omit_elements = .initFill(true);
	126	redact = .initFill(true);
84	127	} else if (mem.eql(u8, arg, "--strings")) {
85	128	opt_strings = true;
86	129	} else if (mem.eql(u8, arg, "--symbols")) {
...	...	@@ -105,10 +148,13 @@ pub fn main(init: std.process.Init) !void {
105	148	.linker_member = opt_linker_member,
106	149	.member_filters = member_filters.items,
107	150	.member_headers = opt_member_headers orelse false,
	151	.omit_elements = omit_elements,
	152	.redact = redact,
	153	.relocs = opt_relocs orelse false,
108	154	.section_filters = section_filters.items,
109	155	.section_headers = opt_section_headers orelse false,
110		.relocs = opt_relocs orelse false,
111	156	.strings = opt_strings orelse false,
	157	.symbol_filters = symbol_filters.items,
112	158	.symbols = opt_symbols orelse false,
113	159	.tls = opt_tls orelse false,
114	160	};
...	...	@@ -120,7 +166,15 @@ pub fn main(init: std.process.Init) !void {
120	166	var buffer: [4096]u8 = undefined;
121	167	var file_reader = file.reader(io, &buffer);
122	168	var stdout_writer = std.Io.File.stdout().writerStreaming(io, &stdout_buffer);
123		dump(init.gpa, &opts, &file_reader, &stdout_writer.interface) catch \|err\| switch (err) {
	169
	170	const ctx: DumpContext = .{
	171	.gpa = init.gpa,
	172	.opts = &opts,
	173	.fr = &file_reader,
	174	.w = &stdout_writer.interface,
	175	};
	176
	177	dump(&ctx) catch \|err\| switch (err) {
124	178	error.ReadFailed => return file_reader.err.?,
125	179	error.WriteFailed => return stdout_writer.err.?,
126	180	error.UnknownFile => fatal("unrecognized file: {s}", .{opts.input_path}),
...	...	@@ -130,60 +184,82 @@ pub fn main(init: std.process.Init) !void {
130	184	try stdout_writer.flush();
131	185	}
132	186
133		fn dump(gpa: std.mem.Allocator, opts: const Options, fr: Io.File.Reader, w: *Io.Writer) !void {
134		const r = &fr.interface;
	187	fn dump(d: *const DumpContext) !void {
	188	const r = &d.fr.interface;
135	189	try r.fill(4);
136	190	elf: {
137	191	if (!mem.eql(u8, r.buffered()[0..4], std.elf.MAGIC)) break :elf;
138		return elf.dump(r, w);
	192	return elf.dump(r, d.w);
139	193	}
140	194	macho: {
141	195	if (mem.readInt(u32, r.buffered()[0..4], .little) != std.macho.MH_MAGIC_64) break :macho;
142		return macho.dump(r, w);
	196	return macho.dump(r, d.w);
143	197	}
144	198	wasm: {
145	199	comptime assert(std.wasm.magic.len == 4);
146	200	if (!mem.eql(u8, r.buffered()[0..4], &std.wasm.magic)) break :wasm;
147		return wasm.dump(r, w);
	201	return wasm.dump(r, d.w);
148	202	}
149	203	coff: {
150		const ext = std.fs.path.extension(opts.input_path);
151		const basename = std.fs.path.basename(opts.input_path);
	204	const ext = std.fs.path.extension(d.opts.input_path);
	205	const basename = std.fs.path.basename(d.opts.input_path);
152	206	if (std.mem.eql(u8, ext, ".exe") or std.mem.eql(u8, ext, ".dll")) {
153	207	if (!mem.eql(u8, r.buffered()[0..2], "MZ")) break :coff;
154	208	try r.discardAll(std.coff.pe_pointer_offset);
155	209	const sig_offset = try r.takeInt(u32, .little);
156		try fr.seekTo(sig_offset);
	210	try d.fr.seekTo(sig_offset);
157	211	const sig = try r.take(4);
158	212
159	213	if (!std.mem.eql(u8, sig, std.coff.pe_signature)) {
160		try w.print("invalid PE signature: {x}", .{sig});
	214	try d.w.print("invalid PE signature: {x}", .{sig});
161	215	return error.ParseFailure;
162	216	}
163	217
164		try w.print("{s}: PE/COFF image\n\n", .{basename});
165		return coff.dumpObject(gpa, opts, true, basename, fr, w);
	218	if (d.element(.@"file-type"))
	219	try d.w.print("{s}: PE/COFF image\n\n", .{basename});
	220
	221	return coff.dumpObject(d, true, basename);
166	222	} else if (std.mem.eql(u8, ext, ".lib")) {
167	223	r.fill(std.coff.archive_signature.len) catch break :coff;
168	224	if (!mem.eql(u8, r.buffered()[0..std.coff.archive_signature.len], std.coff.archive_signature)) break :coff;
169		try w.print("{s}: COFF archive\n\n", .{basename});
170		return coff.dumpArchive(gpa, opts, fr, w);
	225	if (d.element(.@"file-type"))
	226	try d.w.print("{s}: COFF archive\n\n", .{basename});
	227
	228	return coff.dumpArchive(d);
171	229	} else if (std.mem.eql(u8, ext, ".obj")) {
172		try w.print("{s}: COFF object\n\n", .{basename});
173		return coff.dumpObject(gpa, opts, false, basename, fr, w);
	230	if (d.element(.@"file-type"))
	231	try d.w.print("{s}: COFF object\n\n", .{basename});
	232
	233	return coff.dumpObject(d, false, basename);
174	234	}
175	235	}
176	236	return error.UnknownFile;
177	237	}
178	238
179		fn failParse(
	239	const DumpContext = struct {
	240	gpa: std.mem.Allocator,
180	241	opts: *const Options,
181		comptime fmt: []const u8,
182		args: anytype,
183		) noreturn {
184		std.log.err("error parsing '{s}'", .{std.fs.path.basename(opts.input_path)});
185		fatal(fmt, args);
186		}
	242	fr: *Io.File.Reader,
	243	w: *Io.Writer,
	244
	245	fn element(self: *const DumpContext, e: Element) bool {
	246	return !self.opts.omit_elements.get(e);
	247	}
	248
	249	fn redacted(self: *const DumpContext, opt_kind: ?FieldKind) bool {
	250	const kind = opt_kind orelse return false;
	251	return self.opts.redact.get(kind);
	252	}
	253
	254	fn failParse(
	255	ctx: *const DumpContext,
	256	comptime fmt: []const u8,
	257	args: anytype,
	258	) noreturn {
	259	std.log.err("error parsing '{s}'", .{std.fs.path.basename(ctx.opts.input_path)});
	260	fatal(fmt, args);
	261	}
	262	};
187	263
188	264	const elf = struct {
189	265	fn dump(r: Io.Reader, w: Io.Writer) !void {
...	...	@@ -230,29 +306,33 @@ const coff = struct {
230	306	file_mode: u24,
231	307	size: u34,
232	308
233		pub fn fromRaw(opts: const Options, raw_header: const std.coff.ArchiveMemberHeader, opt_longnames: ?[]const u8) @This() {
	309	pub fn fromRaw(d: const DumpContext, raw_header: const std.coff.ArchiveMemberHeader, opt_longnames: ?[]const u8) @This() {
234	310	const name = raw_header.parseName(opt_longnames) catch \|err\| switch (err) {
235		error.BadName => failParse(opts, "malformed member name: '{s}'", .{&raw_header.name}),
236		error.NoLongNames => failParse(opts, "member uses a long name, but there was no longnames member", .{}),
	311	error.BadName => d.failParse("malformed member name: '{s}'", .{&raw_header.name}),
	312	error.NoLongNames => d.failParse("member uses a long name, but there was no longnames member", .{}),
237	313	};
238	314
239	315	return .{
240	316	.name = name,
241	317	.date = raw_header.parseDate() catch \|err\|
242		failParse(opts, "unable to parse date '{s}' in member '{s}': {t}", .{ raw_header.date, name, err }),
	318	d.failParse("unable to parse date '{s}' in member '{s}': {t}", .{ raw_header.date, name, err }),
243	319	.user_id = raw_header.parseUserId() catch \|err\|
244		failParse(opts, "unable to parse user_id '{s}' in member '{s}': {t}", .{ raw_header.user_id, name, err }),
	320	d.failParse("unable to parse user_id '{s}' in member '{s}': {t}", .{ raw_header.user_id, name, err }),
245	321	.group_id = raw_header.parseGroupId() catch \|err\|
246		failParse(opts, "unable to parse group_id '{s}' in member '{s}': {t}", .{ raw_header.group_id, name, err }),
	322	d.failParse("unable to parse group_id '{s}' in member '{s}': {t}", .{ raw_header.group_id, name, err }),
247	323	.file_mode = raw_header.parseFileMode() catch \|err\|
248		failParse(opts, "unable to parse file_mode '{s}' in member '{s}': {t}", .{ raw_header.file_mode, name, err }),
	324	d.failParse("unable to parse file_mode '{s}' in member '{s}': {t}", .{ raw_header.file_mode, name, err }),
249	325	.size = raw_header.parseSize() catch \|err\|
250		failParse(opts, "unable to parse size '{s}' in member '{s}': {t}", .{ raw_header.size, name, err }),
	326	d.failParse("unable to parse size '{s}' in member '{s}': {t}", .{ raw_header.size, name, err }),
251	327	};
252	328	}
253	329	};
254	330
255		fn dumpArchive(gpa: std.mem.Allocator, opts: const Options, fr: Io.File.Reader, w: *Io.Writer) !void {
	331	fn dumpArchive(d: *const DumpContext) !void {
	332	const gpa = d.gpa;
	333	const fr = d.fr;
	334	const w = d.w;
	335
256	336	const r = &fr.interface;
257	337	r.toss(std.coff.archive_signature.len);
258	338
...	...	@@ -272,26 +352,26 @@ const coff = struct {
272	352	while (pos < size) : (pos = fr.logicalPos()) {
273	353	if ((pos & 1) != 0) try r.discardAll(1);
274	354	const raw_header = try r.takeStruct(std.coff.ArchiveMemberHeader, .little);
275		const header: ArchiveHeader = .fromRaw(opts, &raw_header, opt_longnames);
	355	const header: ArchiveHeader = .fromRaw(d, &raw_header, opt_longnames);
276	356
277	357	if (!std.mem.eql(u8, &raw_header.end_of_header, std.coff.archive_end_of_header))
278		return failParse(opts, "malformed end-of-header field in member '{s}': {x}", .{ header.name, raw_header.end_of_header });
	358	return d.failParse("malformed end-of-header field in member '{s}': {x}", .{ header.name, raw_header.end_of_header });
279	359
280	360	const dump_header =
281		(opts.member_headers and filterMatches(opts.member_filters, header.name)) or
282		(opts.linker_member == opt_expected_kind);
	361	(d.opts.member_headers and filterMatches(d.opts.member_filters, header.name)) or
	362	(d.opts.linker_member == opt_expected_kind);
283	363
284	364	if (dump_header)
285		try dumpArchiveHeader(w, &header, @intCast(pos));
	365	try dumpArchiveHeader(d, &header, @intCast(pos));
286	366
287	367	const member_end = fr.logicalPos() + header.size;
288	368	if (member_end > size)
289		return failParse(opts, "out-of-bounds length 0x{x} in member '{s}'", .{ header.size, header.name });
	369	return d.failParse("out-of-bounds length 0x{x} in member '{s}'", .{ header.size, header.name });
290	370
291	371	if (opt_expected_kind) \|expected_kind\| switch (expected_kind) {
292	372	.first_linker => {
293	373	if (!std.mem.eql(u8, header.name, "/"))
294		return failParse(opts, "expected first linker member, found '{s}'", .{header.name});
	374	return d.failParse("expected first linker member, found '{s}'", .{header.name});
295	375
296	376	const num_symbols = try r.takeInt(u32, .big);
297	377	if (dump_header)
...	...	@@ -301,7 +381,7 @@ const coff = struct {
301	381	\\
302	382	, .{ expected_kind, num_symbols });
303	383
304		if (opts.linker_member == .first_linker) {
	384	if (d.opts.linker_member == .first_linker) {
305	385	try w.writeAll(
306	386	\\
307	387	\\Archive symbols:
...	...	@@ -314,11 +394,15 @@ const coff = struct {
314	394
315	395	for (0..num_symbols) \|symbol_i\| {
316	396	const symbol = r.takeDelimiter(0) catch \|err\|
317		return failParse(opts, "unable to read first linker member string table: {t}", .{err});
318		try w.print("{x: >8} {s}\n", .{ std.mem.readInt(u32, offsets[symbol_i * 4 ..][0..4], .big), symbol.? });
	397	return d.failParse("unable to read first linker member string table: {t}", .{err});
	398	const offset = std.mem.readInt(u32, offsets[symbol_i * 4 ..][0..4], .big);
	399	try w.print("{f} {s}\n", .{
	400	fmtIntField(d, offset, .{ .kind = .va }),
	401	symbol.?,
	402	});
319	403	}
320	404	}
321		if (dump_header) try w.writeByte('\n');
	405	if (dump_header and d.element(.newlines)) try w.writeByte('\n');
322	406
323	407	try fr.seekTo(member_end);
324	408	opt_expected_kind = .second_linker;
...	...	@@ -326,12 +410,12 @@ const coff = struct {
326	410	},
327	411	.second_linker => {
328	412	if (!std.mem.eql(u8, header.name, "/"))
329		return failParse(opts, "expected second linker member, found '{s}'", .{header.name});
	413	return d.failParse("expected second linker member, found '{s}'", .{header.name});
330	414
331	415	const num_members = try r.takeInt(u32, .little);
332	416	pos = fr.logicalPos();
333	417	if (pos + num_members * @sizeOf(u32) > member_end)
334		return failParse(opts, "invalid member count 0x{x} in second linker member", .{num_members});
	418	return d.failParse("invalid member count 0x{x} in second linker member", .{num_members});
335	419
336	420	try members.ensureTotalCapacity(gpa, num_members);
337	421	for (0..num_members) \|_\|
...	...	@@ -342,7 +426,7 @@ const coff = struct {
342	426	const num_symbols = try r.takeInt(u32, .little);
343	427	pos = fr.logicalPos();
344	428	if (pos + num_symbols * @sizeOf(u16) > member_end)
345		return failParse(opts, "invalid symbol count 0x{x} in second linker member", .{num_symbols});
	429	return d.failParse("invalid symbol count 0x{x} in second linker member", .{num_symbols});
346	430
347	431	if (dump_header)
348	432	try w.print(
...	...	@@ -356,13 +440,14 @@ const coff = struct {
356	440	for (0..num_symbols) \|_\|
357	441	symbol_member_indices.addOneAssumeCapacity().* = (try r.takeInt(u16, .little)) - 1;
358	442
359		if (opts.linker_member == .second_linker) {
360		try w.writeAll(
361		\\
362		\\Archive Symbols:
363		\\& Member Symbol
364		\\
365		);
	443	if (d.opts.linker_member == .second_linker) {
	444	if (d.element(.@"table-header"))
	445	try w.writeAll(
	446	\\
	447	\\Archive Symbols:
	448	\\& Member Symbol
	449	\\
	450	);
366	451
367	452	pos = fr.logicalPos();
368	453	var symbol_i: u32 = 0;
...	...	@@ -373,23 +458,26 @@ const coff = struct {
373	458	const symbol_name = if (r.takeDelimiter(0) catch \|err\| switch (err) {
374	459	error.StreamTooLong => null,
375	460	else => \|e\| return e,
376		}) \|n\| n else return failParse(opts, "unterminated string found in second linker member", .{});
377
378		try w.print("{x: >8} {s}\n", .{
379		members.items[symbol_member_indices.items[symbol_i]].offset,
	461	}) \|n\| n else return d.failParse("unterminated string found in second linker member", .{});
	462
	463	try w.print("{f} {s}\n", .{
	464	fmtIntField(
	465	d,
	466	members.items[symbol_member_indices.items[symbol_i]].offset,
	467	.{ .kind = .va },
	468	),
380	469	symbol_name,
381	470	});
382	471	}
383	472
384	473	if (symbol_i != num_symbols)
385		return failParse(
386		opts,
	474	return d.failParse(
387	475	" expected {d} entries in second linker member string table, but found {d}",
388	476	.{ num_symbols, symbol_i },
389	477	);
390	478	}
391	479
392		try w.writeByte('\n');
	480	if (d.element(.newlines)) try w.writeByte('\n');
393	481	try fr.seekTo(member_end);
394	482	opt_expected_kind = .longnames;
395	483	continue;
...	...	@@ -401,12 +489,13 @@ const coff = struct {
401	489	if (dump_header)
402	490	try w.print("{t: >16} type\n", .{expected_kind});
403	491
404		if (opts.linker_member == .longnames) {
405		try w.print(
406		\\
407		\\Longnames (0x{x} bytes):
408		\\
409		, .{opt_longnames.?.len});
	492	if (d.opts.linker_member == .longnames) {
	493	if (d.element(.@"table-header"))
	494	try w.print(
	495	\\
	496	\\Longnames (0x{x} bytes):
	497	\\
	498	, .{opt_longnames.?.len});
410	499
411	500	var lr = Io.Reader.fixed(opt_longnames.?);
412	501	while (try lr.takeDelimiter(0)) \|str\| {
...	...	@@ -415,7 +504,7 @@ const coff = struct {
415	504	}
416	505	}
417	506
418		try w.writeByte('\n');
	507	if (d.element(.newlines)) try w.writeByte('\n');
419	508	}
420	509
421	510	opt_expected_kind = null;
...	...	@@ -426,18 +515,18 @@ const coff = struct {
426	515	}
427	516
428	517	if (opt_expected_kind) \|expected_kind\| switch (expected_kind) {
429		.first_linker => failParse(opts, "missing first linker member", .{}),
430		.second_linker => failParse(opts, "missing second linker member", .{}),
	518	.first_linker => d.failParse("missing first linker member", .{}),
	519	.second_linker => d.failParse("missing second linker member", .{}),
431	520	else => {},
432	521	};
433	522
434	523	for (members.items, 0..) \|member, member_i\| {
435	524	fr.seekTo(member.offset) catch \|err\|
436		failParse(opts, "unable to read member {d} at offset 0x{x}: {t}", .{ member_i, member.offset, err });
	525	d.failParse("unable to read member {d} at offset 0x{x}: {t}", .{ member_i, member.offset, err });
437	526
438	527	const raw_header = try r.takeStruct(std.coff.ArchiveMemberHeader, .little);
439		const header: ArchiveHeader = .fromRaw(opts, &raw_header, opt_longnames);
440		if (!filterMatches(opts.member_filters, header.name)) continue;
	528	const header: ArchiveHeader = .fromRaw(d, &raw_header, opt_longnames);
	529	if (!filterMatches(d.opts.member_filters, header.name)) continue;
441	530
442	531	const member_sig = try r.peek(4);
443	532	const machine: std.coff.IMAGE.FILE.MACHINE =
...	...	@@ -445,17 +534,17 @@ const coff = struct {
445	534	const sig = std.mem.readInt(u16, member_sig[2..4], .little);
446	535
447	536	const is_imp_lib = machine == std.coff.IMAGE.FILE.MACHINE.UNKNOWN and sig == 0xffff;
448		if (opts.member_headers or (opts.exports and is_imp_lib)) {
449		try dumpArchiveHeader(w, &header, member.offset);
	537	if (d.opts.member_headers or (d.opts.exports and is_imp_lib)) {
	538	try dumpArchiveHeader(d, &header, member.offset);
450	539	if (is_imp_lib) {
451	540	try w.writeAll("\nImport header:\n");
452	541
453	542	const imp_header = try r.takeStruct(std.coff.ImportHeader, .little);
454		try dumpHeader(w, std.coff.ImportHeader, &imp_header, struct {
455		pub fn sig1(_: const std.coff.ImportHeader, _: Io.Writer) !void {}
456		pub fn sig2(_: const std.coff.ImportHeader, _: Io.Writer) !void {}
457		pub fn types(h: const std.coff.ImportHeader, cw: Io.Writer) !void {
458		try cw.print(
	543	try dumpHeader(d, std.coff.ImportHeader, &imp_header, struct {
	544	pub fn sig1(_: const DumpContext, _: const std.coff.ImportHeader) !void {}
	545	pub fn sig2(_: const DumpContext, _: const std.coff.ImportHeader) !void {}
	546	pub fn types(id: const DumpContext, h: const std.coff.ImportHeader) !void {
	547	try id.w.print(
459	548	\\{t: >16} import_type
460	549	\\{t: >16} name_type
461	550	\\
...	...	@@ -490,51 +579,53 @@ const coff = struct {
490	579	} else {
491	580	try w.writeAll(" COFF object type\n");
492	581	}
493		try w.writeByte('\n');
	582	if (d.element(.newlines)) try w.writeByte('\n');
494	583	}
495	584
496	585	if (is_imp_lib) continue;
497		if (opts.section_headers or
498		opts.file_headers or
499		opts.relocs or
500		opts.strings or
501		opts.symbols)
	586	if (d.opts.section_headers or
	587	d.opts.file_headers or
	588	d.opts.relocs or
	589	d.opts.strings or
	590	d.opts.symbols)
502	591	{
503		try w.print("{s}({s}): COFF object\n\n", .{ std.fs.path.basename(opts.input_path), header.name });
504		try dumpObject(gpa, opts, false, header.name, fr, w);
	592	if (d.element(.@"file-type"))
	593	try w.print("{s}({s}): COFF object\n\n", .{ std.fs.path.basename(d.opts.input_path), header.name });
	594	try dumpObject(d, false, header.name);
505	595	}
506	596	}
507	597	}
508	598
509	599	fn dumpObject(
510		gpa: std.mem.Allocator,
511		opts: *const Options,
	600	d: *const DumpContext,
512	601	is_image: bool,
513	602	obj_name: []const u8,
514		fr: *Io.File.Reader,
515		w: *Io.Writer,
516	603	) !void {
	604	const gpa = d.gpa;
	605	const fr = d.fr;
	606	const w = d.w;
	607
517	608	const file_location = fr.logicalPos();
518	609	const r = &fr.interface;
519	610	const header = r.takeStruct(std.coff.Header, .little) catch \|err\|
520		return failParse(opts, "unable to read COFF header: {t}", .{err});
	611	return d.failParse("unable to read COFF header: {t}", .{err});
521	612
522		if (opts.file_headers) {
523		try w.writeAll("COFF Header:\n");
524		try dumpHeader(w, std.coff.Header, &header, struct {});
525		try w.writeByte('\n');
	613	if (d.opts.file_headers) {
	614	if (d.element(.@"header-names")) try w.writeAll("COFF Header:\n");
	615	try dumpHeader(d, std.coff.Header, &header, struct {});
	616	if (d.element(.newlines)) try w.writeByte('\n');
526	617	}
527	618
528	619	switch (header.machine) {
529		_ => return failParse(opts, "unknown machine type: {x}", .{header.machine}),
	620	_ => return d.failParse("unknown machine type: {x}", .{header.machine}),
530	621	else => {},
531	622	}
532	623
533	624	var known_dirs: [DIRECTORY_ENTRY.len]std.coff.ImageDataDirectory = undefined;
534	625	const needs_data_dirs =
535		opts.exports or
536		opts.imports or
537		opts.tls;
	626	d.opts.exports or
	627	d.opts.imports or
	628	d.opts.tls;
538	629
539	630	const ImageInfo = struct {
540	631	data_dirs: []const std.coff.ImageDataDirectory,
...	...	@@ -543,12 +634,14 @@ const coff = struct {
543	634	};
544	635
545	636	const image_info: ?ImageInfo = if (header.size_of_optional_header > 0) image_info: {
546		if (!opts.file_headers and !needs_data_dirs) {
	637	if (!d.opts.file_headers and !needs_data_dirs) {
547	638	try fr.seekBy(header.size_of_optional_header);
548	639	break :image_info null;
549	640	}
550	641
551		if (opts.file_headers) try w.writeAll("COFF Optional Header:\n");
	642	if (d.opts.file_headers and d.element(.@"header-names"))
	643	try w.writeAll("COFF Optional Header:\n");
	644
552	645	const magic: std.coff.OptionalHeader.Magic = @enumFromInt(try r.peekInt(u16, .little));
553	646	const num_directory_entries, const image_base = switch (magic) {
554	647	inline .PE32, .@"PE32+" => \|v\| num_data_dirs: {
...	...	@@ -558,46 +651,46 @@ const coff = struct {
558	651	std.coff.OptionalHeader.@"PE32+";
559	652
560	653	const optional_header = r.takeStruct(OptionalHeader, .little) catch \|err\|
561		return failParse(opts, "unable to read optional header: {t}", .{err});
	654	return d.failParse("unable to read optional header: {t}", .{err});
562	655
563		if (opts.file_headers) {
564		try dumpHeader(w, OptionalHeader, &optional_header, struct {
565		pub fn base_of_code(h: const std.coff.OptionalHeader, cw: Io.Writer) !void {
	656	if (d.opts.file_headers) {
	657	try dumpHeader(d, OptionalHeader, &optional_header, struct {
	658	pub fn base_of_code(id: const DumpContext, h: const std.coff.OptionalHeader) !void {
566	659	const base = @as(*const OptionalHeader, @ptrCast(@alignCast(h))).image_base;
567		try dumpRvaField(cw, @src().fn_name, h.base_of_code, base);
	660	try dumpRvaField(id, @src().fn_name, h.base_of_code, base);
568	661	}
569	662
570		pub fn address_of_entry_point(h: const std.coff.OptionalHeader, cw: Io.Writer) !void {
	663	pub fn address_of_entry_point(id: const DumpContext, h: const std.coff.OptionalHeader) !void {
571	664	const base = @as(*const OptionalHeader, @ptrCast(@alignCast(h))).image_base;
572		try dumpRvaField(cw, @src().fn_name, h.base_of_code, base);
	665	try dumpRvaField(id, @src().fn_name, h.base_of_code, base);
573	666	}
574	667
575		pub fn major_linker_version(h: const std.coff.OptionalHeader, cw: Io.Writer) !void {
576		try dumpVersionField(cw, "linker_version", h.major_linker_version, h.minor_linker_version);
	668	pub fn major_linker_version(id: const DumpContext, h: const std.coff.OptionalHeader) !void {
	669	try dumpVersionField(id.w, "linker_version", h.major_linker_version, h.minor_linker_version);
577	670	}
578		pub fn minor_linker_version(_: const std.coff.OptionalHeader, _: Io.Writer) !void {}
	671	pub fn minor_linker_version(_: const DumpContext, _: const std.coff.OptionalHeader) !void {}
579	672
580		pub fn major_operating_system_version(h: const OptionalHeader, cw: Io.Writer) !void {
	673	pub fn major_operating_system_version(id: const DumpContext, h: const OptionalHeader) !void {
581	674	try dumpVersionField(
582		cw,
	675	id.w,
583	676	"operating_system_version",
584	677	h.major_operating_system_version,
585	678	h.minor_operating_system_version,
586	679	);
587	680	}
588		pub fn minor_operating_system_version(_: const OptionalHeader, _: Io.Writer) !void {}
	681	pub fn minor_operating_system_version(_: const DumpContext, _: const OptionalHeader) !void {}
589	682
590		pub fn major_image_version(h: const OptionalHeader, cw: Io.Writer) !void {
591		try dumpVersionField(cw, "image_version", h.major_image_version, h.minor_image_version);
	683	pub fn major_image_version(id: const DumpContext, h: const OptionalHeader) !void {
	684	try dumpVersionField(id.w, "image_version", h.major_image_version, h.minor_image_version);
592	685	}
593		pub fn minor_image_version(_: const OptionalHeader, _: Io.Writer) !void {}
	686	pub fn minor_image_version(_: const DumpContext, _: const OptionalHeader) !void {}
594	687
595		pub fn major_subsystem_version(h: const OptionalHeader, cw: Io.Writer) !void {
596		try dumpVersionField(cw, "subsystem_version", h.major_subsystem_version, h.minor_subsystem_version);
	688	pub fn major_subsystem_version(id: const DumpContext, h: const OptionalHeader) !void {
	689	try dumpVersionField(id.w, "subsystem_version", h.major_subsystem_version, h.minor_subsystem_version);
597	690	}
598		pub fn minor_subsystem_version(_: const OptionalHeader, _: Io.Writer) !void {}
	691	pub fn minor_subsystem_version(_: const DumpContext, _: const OptionalHeader) !void {}
599	692	});
600		try w.writeByte('\n');
	693	if (d.element(.newlines)) try w.writeByte('\n');
601	694	}
602	695
603	696	break :num_data_dirs .{
...	...	@@ -605,24 +698,26 @@ const coff = struct {
605	698	optional_header.image_base,
606	699	};
607	700	},
608		else => return failParse(opts, "invalid optional header magic number: {x}", .{magic}),
	701	else => return d.failParse("invalid optional header magic number: {x}", .{magic}),
609	702	};
610	703
611		if (opts.file_headers) try w.writeAll("Data Directories:\n");
	704	if (d.opts.file_headers and d.element(.@"header-names"))
	705	try w.writeAll("Data Directories:\n");
	706
612	707	for (0..num_directory_entries) \|dir_i\| {
613	708	const dir = r.takeStruct(std.coff.ImageDataDirectory, .little) catch \|err\|
614		return failParse(opts, "unable to read data directory {x}: {t}", .{ dir_i, err });
	709	return d.failParse("unable to read data directory {x}: {t}", .{ dir_i, err });
615	710
616	711	if (dir_i < known_dirs.len)
617	712	known_dirs[dir_i] = dir;
618	713
619		if (opts.file_headers)
	714	if (d.opts.file_headers)
620	715	try w.print(
621	716	"{x: >16} {x: >8} {t}\n",
622	717	.{ dir.virtual_address, dir.size, @as(DIRECTORY_ENTRY, @enumFromInt(dir_i)) },
623	718	);
624	719	}
625		if (opts.file_headers) try w.writeByte('\n');
	720	if (d.opts.file_headers and d.element(.newlines)) try w.writeByte('\n');
626	721
627	722	break :image_info .{
628	723	.data_dirs = known_dirs[0..@min(known_dirs.len, num_directory_entries)],
...	...	@@ -630,32 +725,33 @@ const coff = struct {
630	725	.image_base = image_base,
631	726	};
632	727	} else if (is_image) {
633		return failParse(opts, "image did not contain an optional header", .{});
	728	return d.failParse("image did not contain an optional header", .{});
634	729	} else null;
635	730
636	731	// Section names in images don't use the string table, as they must fit inline in the header
637		const load_string_table = (opts.strings or !is_image) and header.pointer_to_symbol_table > 0;
	732	const load_string_table = (d.opts.strings or !is_image) and header.pointer_to_symbol_table > 0;
638	733	const string_table = if (load_string_table) string_table: {
639	734	const pos = fr.logicalPos();
640	735	fr.seekTo(file_location + header.pointer_to_symbol_table + header.number_of_symbols * std.coff.Symbol.sizeOf()) catch \|err\|
641		return failParse(opts, "unable to seek to string table: {t}", .{err});
	736	return d.failParse("unable to seek to string table: {t}", .{err});
642	737
643	738	const string_table_len = r.peekInt(u32, .little) catch \|err\|
644		return failParse(opts, "unable to read string table length: {t}", .{err});
	739	return d.failParse("unable to read string table length: {t}", .{err});
645	740
646	741	const table = r.readAlloc(gpa, string_table_len) catch \|err\|
647		return failParse(opts, "unable to read string table: {t}", .{err});
	742	return d.failParse("unable to read string table: {t}", .{err});
648	743
649	744	try fr.seekTo(pos);
650	745	break :string_table table;
651	746	} else &.{};
652	747	defer gpa.free(string_table);
653	748
654		if (opts.strings) {
655		try w.print(
656		\\String Table (0x{x} bytes):
657		\\
658		, .{string_table.len});
	749	if (d.opts.strings) {
	750	if (d.element(.@"table-header"))
	751	try w.print(
	752	\\String Table (0x{x} bytes):
	753	\\
	754	, .{string_table.len});
659	755
660	756	var sr = Io.Reader.fixed(string_table[4..]);
661	757	while (try sr.takeDelimiter(0)) \|str\| {
...	...	@@ -663,7 +759,7 @@ const coff = struct {
663	759	try w.writeByte('\n');
664	760	}
665	761
666		try w.writeByte('\n');
	762	if (d.element(.newlines)) try w.writeByte('\n');
667	763	}
668	764
669	765	var sections: std.ArrayList(Section) = .empty;
...	...	@@ -671,13 +767,13 @@ const coff = struct {
671	767	var sections_with_data: u16 = 0;
672	768
673	769	const load_sections =
674		opts.section_headers or
675		opts.symbols or
676		opts.relocs or
	770	d.opts.section_headers or
	771	d.opts.symbols or
	772	d.opts.relocs or
677	773	needs_data_dirs;
678	774
679	775	if (load_sections) {
680		if (opts.section_headers)
	776	if (d.opts.section_headers and d.element(.@"table-header"))
681	777	try w.print(
682	778	\\Sections in '{s}':
683	779	\\Num Name RVA Virt Size Data Size & Data & Relocs & Lines # Relocs # Lines Flags
...	...	@@ -687,37 +783,37 @@ const coff = struct {
687	783	try sections.resize(gpa, header.number_of_sections);
688	784	for (sections.items, 0..) \|*section, section_i\| {
689	785	section.header = r.takeStruct(std.coff.SectionHeader, .little) catch \|err\|
690		return failParse(opts, "unable to read section header {x}: {t}", .{ section_i, err });
	786	return d.failParse("unable to read section header {x}: {t}", .{ section_i, err });
691	787	section.name = headerName(&section.header.name, string_table) catch \|err\| switch (err) {
692	788	error.Overflow,
693	789	error.InvalidCharacter,
694		=> return failParse(opts, "unable to parse section name offset '{s}': {t}", .{
	790	=> return d.failParse("unable to parse section name offset '{s}': {t}", .{
695	791	section.name,
696	792	err,
697	793	}),
698		error.OutOfBounds => return failParse(opts, "section name offset '{s}' was out of bounds (>= {x})", .{
	794	error.OutOfBounds => return d.failParse("section name offset '{s}' was out of bounds (>= {x})", .{
699	795	section.name,
700	796	string_table.len,
701	797	}),
702	798	};
703	799
704	800	sections_with_data += @intFromBool(section.header.size_of_raw_data > 0);
705		if (opts.section_headers) {
706		if (!filterMatches(opts.section_filters, section.name)) continue;
	801	if (d.opts.section_headers) {
	802	if (!filterMatches(d.opts.section_filters, section.name)) continue;
707	803	const raw_name = std.mem.sliceTo(&section.header.name, 0);
708	804	try w.print(
709		"{x: >3} {s: <8} {x: >8} {x: >9} {x: >9} {x: >8} {x: >8} {x: >8} {x: >8} {x: >8} {x:0>8} \|",
	805	"{x: >3} {s: <8} {f} {f} {f} {f} {f} {f} {f} {f} {x:0>8} \|",
710	806	.{
711	807	section_i + 1,
712	808	raw_name,
713		section.header.virtual_address,
714		section.header.virtual_size,
715		section.header.size_of_raw_data,
716		section.header.pointer_to_raw_data,
717		section.header.pointer_to_relocations,
718		section.header.pointer_to_linenumbers,
719		section.header.number_of_relocations,
720		section.header.number_of_linenumbers,
	809	fmtIntField(d, section.header.virtual_address, .{ .kind = .va }),
	810	fmtIntField(d, section.header.virtual_size, .{ .kind = .size, .width = 9 }),
	811	fmtIntField(d, section.header.size_of_raw_data, .{ .kind = .size, .width = 9 }),
	812	fmtIntField(d, section.header.pointer_to_raw_data, .{ .kind = .va }),
	813	fmtIntField(d, section.header.pointer_to_relocations, .{ .kind = .va }),
	814	fmtIntField(d, section.header.pointer_to_linenumbers, .{ .kind = .va }),
	815	fmtIntField(d, section.header.number_of_relocations, .{ .kind = .va }),
	816	fmtIntField(d, section.header.number_of_linenumbers, .{ .kind = .va }),
721	817	@as(u32, @bitCast(section.header.flags)),
722	818	},
723	819	);
...	...	@@ -730,7 +826,7 @@ const coff = struct {
730	826	}
731	827	}
732	828
733		if (opts.section_headers) try w.writeByte('\n');
	829	if (d.opts.section_headers and d.element(.newlines)) try w.writeByte('\n');
734	830	}
735	831
736	832	var symbols: std.ArrayList(struct {
...	...	@@ -738,15 +834,15 @@ const coff = struct {
738	834	section_number: std.coff.SectionNumber,
739	835	}) = .empty;
740	836	defer symbols.deinit(gpa);
741		if (opts.relocs)
	837	if (d.opts.relocs)
742	838	try symbols.ensureUnusedCapacity(gpa, header.number_of_symbols);
743	839
744		if (opts.symbols or opts.relocs) {
	840	if (d.opts.symbols or d.opts.relocs) {
745	841	if (header.pointer_to_symbol_table > 0) {
746	842	fr.seekTo(file_location + header.pointer_to_symbol_table) catch \|err\|
747		return failParse(opts, "unable to seek to symbol table: {t}", .{err});
	843	return d.failParse("unable to seek to symbol table: {t}", .{err});
748	844
749		if (opts.symbols)
	845	if (d.opts.symbols and d.element(.@"table-header"))
750	846	try w.print(
751	847	\\Symbols in '{s}':
752	848	\\ Ord Value Sect Type Storage Name
...	...	@@ -758,7 +854,7 @@ const coff = struct {
758	854	while (symbol_i < header.number_of_symbols) {
759	855	var symbol: std.coff.Symbol = undefined;
760	856	const symbol_bytes = r.take(symbol_size) catch \|err\|
761		return failParse(opts, "unable to read symbol {x}: {t}", .{ symbol_i, err });
	857	return d.failParse("unable to read symbol {x}: {t}", .{ symbol_i, err });
762	858
763	859	@memcpy(std.mem.asBytes(&symbol)[0..symbol_size], symbol_bytes);
764	860	if (native_endian != .little)
...	...	@@ -773,7 +869,7 @@ const coff = struct {
773	869	const name = std.mem.sliceTo(if (std.mem.eql(u8, symbol.name[0..4], "\x00\x00\x00\x00")) name: {
774	870	const index = std.mem.readInt(u32, symbol.name[4..], .little);
775	871	if (index >= string_table.len)
776		return failParse(opts, "invalid name offset for symbol {x} ({x} >= {x})", .{
	872	return d.failParse("invalid name offset for symbol {x} ({x} >= {x})", .{
777	873	symbol_i,
778	874	index,
779	875	string_table.len,
...	...	@@ -781,16 +877,19 @@ const coff = struct {
781	877	break :name string_table[index..];
782	878	} else &symbol.name, 0);
783	879
784		if (opts.relocs)
	880	if (d.opts.relocs)
785	881	symbols.appendNTimesAssumeCapacity(.{
786	882	.name = name,
787	883	.section_number = symbol.section_number,
788	884	}, 1 + symbol.number_of_aux_symbols);
789	885
790		if (!opts.symbols)
	886	if (!d.opts.symbols or !filterMatches(d.opts.symbol_filters, name))
791	887	continue;
792	888
793		try w.print("{x: >4} {x:0>8} ", .{ symbol_i, symbol.value });
	889	try w.print("{f} {x:0>8} ", .{
	890	fmtIntField(d, @as(u16, @intCast(symbol_i)), .{ .kind = .ord }),
	891	symbol.value,
	892	});
794	893	try switch (symbol.section_number) {
795	894	.UNDEFINED => w.writeAll("UNDEF"),
796	895	.ABSOLUTE => w.writeAll(" ABS"),
...	...	@@ -814,8 +913,7 @@ const coff = struct {
814	913	else => null,
815	914	}) \|suffix\| try w.writeAll(suffix) else try w.print("{x}", .{symbol.type.complex_type});
816	915
817		try w.print("{t: >16} \| {s}", .{ symbol.storage_class, name });
818		try w.writeByte('\n');
	916	try w.print("{t: >16} \| {s}\n", .{ symbol.storage_class, name });
819	917
820	918	for (0..symbol.number_of_aux_symbols) \|aux_i\| {
821	919	_ = aux_i;
...	...	@@ -838,8 +936,7 @@ const coff = struct {
838	936	try w.writeAll("TODO bf / ef aux symbol");
839	937	} else if (symbol.storage_class == .WEAK_EXTERNAL and symbol.section_number == .UNDEFINED) {
840	938	if (symbol.value != 0)
841		return failParse(
842		opts,
	939	return d.failParse(
843	940	"invalid value 0x{x} for weak external symbol 0x{x}",
844	941	.{ symbol.value, symbol_i },
845	942	);
...	...	@@ -850,14 +947,11 @@ const coff = struct {
850	947	std.mem.byteSwapAllFields(std.coff.SectionDefinition, &weak_external);
851	948
852	949	if (weak_external.tag_index >= header.number_of_symbols)
853		return failParse(
854		opts,
	950	return d.failParse(
855	951	"invalid tag_index 0x{x} for weak external symbol 0x{x}",
856	952	.{ weak_external.tag_index, symbol_i },
857	953	);
858	954
859		// TODO
860
861	955	try w.print(" Weak External [falls back to {x:0>8} via {t}]", .{
862	956	weak_external.tag_index,
863	957	weak_external.flag,
...	...	@@ -914,8 +1008,8 @@ const coff = struct {
914	1008	continue;
915	1009	}
916	1010
917		try w.print(" [size {x:0>8} chksum {x:0>8} relocs {x:0>4} lines {x:0>4}]", .{
918		section_def.length,
	1011	try w.print(" [size {f} chksum {x:0>8} relocs {x:0>4} lines {x:0>4}]", .{
	1012	fmtIntField(d, section_def.length, .{ .kind = .size, .zero_fill = true }),
919	1013	section_def.checksum,
920	1014	section_def.number_of_relocations,
921	1015	section_def.number_of_linenumbers,
...	...	@@ -930,19 +1024,19 @@ const coff = struct {
930	1024	try w.writeAll(")");
931	1025	},
932	1026	}
933		} else {}
	1027	}
934	1028
935	1029	try w.writeByte('\n');
936	1030	}
937	1031	}
938	1032
939		if (opts.symbols) try w.writeByte('\n');
940		} else if (opts.symbols) {
	1033	if (d.opts.symbols and d.element(.newlines)) try w.writeByte('\n');
	1034	} else if (d.opts.symbols) {
941	1035	try w.writeAll("No symbol table found\n");
942	1036	}
943	1037	}
944	1038
945		if (opts.relocs) {
	1039	if (d.opts.relocs) {
946	1040	const relocation_size = std.coff.Relocation.sizeOf();
947	1041
948	1042	for (sections.items, 0..) \|section, section_i\| {
...	...	@@ -955,7 +1049,7 @@ const coff = struct {
955	1049	, .{ section_i + 1, section.name, obj_name });
956	1050
957	1051	fr.seekTo(file_location + section.header.pointer_to_relocations) catch \|err\|
958		return failParse(opts, "unable to seek to section {x} relocation table: {t}", .{ section_i + 1, err });
	1052	return d.failParse("unable to seek to section {x} relocation table: {t}", .{ section_i + 1, err });
959	1053
960	1054	for (0..section.header.number_of_relocations) \|reloc_i\| {
961	1055	var reloc: std.coff.Relocation = undefined;
...	...	@@ -963,7 +1057,13 @@ const coff = struct {
963	1057	if (native_endian != .little)
964	1058	std.mem.byteSwapAllFields(std.coff.Relocation, &reloc);
965	1059
966		try w.print("{x:0>8} ", .{reloc.virtual_address});
	1060	const sym = &symbols.items[reloc.symbol_table_index];
	1061	if (!filterMatches(d.opts.symbol_filters, sym.name))
	1062	continue;
	1063
	1064	try w.print("{f} ", .{
	1065	fmtIntField(d, reloc.virtual_address, .{ .kind = .va, .zero_fill = true }),
	1066	});
967	1067	switch (header.machine) {
968	1068	_ => unreachable,
969	1069	inline else => \|m\| switch (m.RelocationType()) {
...	...	@@ -976,20 +1076,18 @@ const coff = struct {
976	1076	}
977	1077
978	1078	if (reloc.symbol_table_index >= symbols.items.len)
979		return failParse(
980		opts,
	1079	return d.failParse(
981	1080	"reloc {x} in section {x} has out-of-bounds symbol index {x}",
982	1081	.{ reloc_i, section_i + 1, reloc.symbol_table_index },
983	1082	);
984	1083
985		const sym = &symbols.items[reloc.symbol_table_index];
986		try w.print("{x: >8} {f} \| {s}\n", .{
987		reloc.symbol_table_index,
	1084	try w.print("{f} {f} \| {s}\n", .{
	1085	fmtIntField(d, reloc.symbol_table_index, .{ .kind = .ord }),
988	1086	fmtSectionNumber(sym.section_number),
989	1087	sym.name,
990	1088	});
991	1089	}
992		try w.writeByte('\n');
	1090	if (d.element(.newlines)) try w.writeByte('\n');
993	1091	}
994	1092	}
995	1093
...	...	@@ -1026,44 +1124,40 @@ const coff = struct {
1026	1124	} else &.{};
1027	1125	defer gpa.free(rva_index);
1028	1126
1029		if (opts.exports) {
1030		if (try seekToDataDirectory(opts, fr, w, rva_index, sections.items, image_info.?.data_dirs, .EXPORT)) \|section_index\| {
	1127	if (d.opts.exports) {
	1128	if (try seekToDataDirectory(d, rva_index, sections.items, image_info.?.data_dirs, .EXPORT)) \|section_index\| {
1031	1129	const export_dir = r.takeStruct(std.coff.ExportDirectoryTable, .little) catch \|err\|
1032		return failParse(opts, "unable to read export directory: {t}", .{err});
	1130	return d.failParse("unable to read export directory: {t}", .{err});
1033	1131
1034	1132	try w.print("Export directory:\n", .{});
1035		try dumpHeader(w, std.coff.ExportDirectoryTable, &export_dir, struct {
1036		pub fn major_version(h: const std.coff.ExportDirectoryTable, cw: Io.Writer) !void {
1037		try dumpVersionField(cw, "version", h.major_version, h.minor_version);
	1133	try dumpHeader(d, std.coff.ExportDirectoryTable, &export_dir, struct {
	1134	pub fn major_version(id: const DumpContext, h: const std.coff.ExportDirectoryTable) !void {
	1135	try dumpVersionField(id.w, "version", h.major_version, h.minor_version);
1038	1136	}
1039		pub fn minor_version(_: const std.coff.ExportDirectoryTable, _: Io.Writer) !void {}
	1137	pub fn minor_version(_: const DumpContext, _: const std.coff.ExportDirectoryTable) !void {}
1040	1138	});
1041	1139
1042	1140	const section = sections.items[section_index];
1043	1141	const name_loc = section.rvaFileOffset(export_dir.name_rva) catch
1044		return failParse(
1045		opts,
	1142	return d.failParse(
1046	1143	"export name rva 0x{x} was not within the export section",
1047	1144	.{export_dir.name_rva},
1048	1145	);
1049	1146
1050	1147	const eat_loc = section.rvaFileOffset(export_dir.export_address_table_rva) catch
1051		return failParse(
1052		opts,
	1148	return d.failParse(
1053	1149	"export address table rva 0x{x} was not within the export section",
1054	1150	.{export_dir.export_address_table_rva},
1055	1151	);
1056	1152
1057	1153	const name_pointer_loc = section.rvaFileOffset(export_dir.name_pointer_table_rva) catch
1058		return failParse(
1059		opts,
	1154	return d.failParse(
1060	1155	"export name pointer table rva 0x{x} was not within the export section",
1061	1156	.{export_dir.name_pointer_table_rva},
1062	1157	);
1063	1158
1064	1159	const ord_loc = section.rvaFileOffset(export_dir.ordinal_table_rva) catch
1065		return failParse(
1066		opts,
	1160	return d.failParse(
1067	1161	"export ordinal table rva 0x{x} was not within the export section",
1068	1162	.{export_dir.ordinal_table_rva},
1069	1163	);
...	...	@@ -1077,12 +1171,13 @@ const coff = struct {
1077	1171	defer gpa.free(dir_slice);
1078	1172
1079	1173	const dll_name = std.mem.sliceTo(dir_slice[name_loc - dir_loc ..], 0);
1080		try w.print(
1081		\\
1082		\\Exports from {s}:
1083		\\ Ord Hint RVA Name
1084		\\
1085		, .{dll_name});
	1174	if (d.element(.@"table-header"))
	1175	try w.print(
	1176	\\
	1177	\\Exports from {s}:
	1178	\\ Ord Hint RVA Name
	1179	\\
	1180	, .{dll_name});
1086	1181
1087	1182	const name_pointers = dir_slice[name_pointer_loc - dir_loc ..][0 .. export_dir.number_of_names * @sizeOf(u32)];
1088	1183	const ords = dir_slice[ord_loc - dir_loc ..][0 .. export_dir.number_of_names * @sizeOf(u16)];
...	...	@@ -1090,18 +1185,24 @@ const coff = struct {
1090	1185	const name_rva_to_offset = dir.virtual_address + @sizeOf(std.coff.ExportDirectoryTable);
1091	1186	for (0..export_dir.number_of_names) \|name_i\| {
1092	1187	const name_rva = std.mem.readInt(u32, name_pointers[name_i * @sizeOf(u32) ..][0..@sizeOf(u32)], .little);
	1188	const name = std.mem.sliceTo(dir_slice[name_rva - name_rva_to_offset ..], 0);
	1189	if (!filterMatches(d.opts.symbol_filters, name))
	1190	continue;
	1191
1093	1192	const ord = std.mem.readInt(u16, ords[name_i * @sizeOf(u16) ..][0..@sizeOf(u16)], .little);
1094	1193	const addr = std.mem.readInt(u32, addrs[@as(u32, ord) * @sizeOf(u32) ..][0..@sizeOf(u32)], .little);
1095	1194
1096		try w.print("{x: >4} {x: >4} ", .{ export_dir.ordinal_base + ord, name_i });
	1195	try w.print("{f} {f} ", .{
	1196	fmtIntField(d, @as(u16, @intCast(export_dir.ordinal_base + ord)), .{ .kind = .ord }),
	1197	fmtIntField(d, @as(u16, @intCast(name_i)), .{ .kind = .ord }),
	1198	});
1097	1199	const is_forwarder = addr >= dir.virtual_address and addr < dir_end_rva;
1098	1200	if (is_forwarder) {
1099	1201	try w.writeAll("forwards");
1100	1202	} else {
1101		try w.print("{x: >8}", .{addr});
	1203	try w.print("{f}", .{fmtIntField(d, addr, .{ .kind = .rva })});
1102	1204	}
1103	1205
1104		const name = std.mem.sliceTo(dir_slice[name_rva - name_rva_to_offset ..], 0);
1105	1206	try w.print(" \| {s}", .{name});
1106	1207	if (is_forwarder)
1107	1208	try w.print(" -> {s}", .{std.mem.sliceTo(dir_slice[addr - name_rva_to_offset ..], 0)});
...	...	@@ -1110,11 +1211,9 @@ const coff = struct {
1110	1211	}
1111	1212	}
1112	1213
1113		if (opts.imports) {
	1214	if (d.opts.imports) {
1114	1215	if (try seekToDataDirectory(
1115		opts,
1116		fr,
1117		w,
	1216	d,
1118	1217	rva_index,
1119	1218	sections.items,
1120	1219	image_info.?.data_dirs,
...	...	@@ -1125,8 +1224,7 @@ const coff = struct {
1125	1224	defer directory_entries.deinit(gpa);
1126	1225	while (true) {
1127	1226	const entry = r.takeStruct(Entry, .little) catch \|err\|
1128		return failParse(
1129		opts,
	1227	return d.failParse(
1130	1228	"unable to read import directory entry {x}: {t}",
1131	1229	.{ directory_entries.items.len, err },
1132	1230	);
...	...	@@ -1141,8 +1239,7 @@ const coff = struct {
1141	1239	sections.items,
1142	1240	entry.name_rva,
1143	1241	) orelse
1144		return failParse(
1145		opts,
	1242	return d.failParse(
1146	1243	"import directory entry name rva 0x{x} was not found in any section",
1147	1244	.{entry.name_rva},
1148	1245	);
...	...	@@ -1151,8 +1248,7 @@ const coff = struct {
1151	1248	entry.name_rva,
1152	1249	) catch unreachable;
1153	1250	fr.seekTo(name_loc) catch \|err\|
1154		return failParse(
1155		opts,
	1251	return d.failParse(
1156	1252	"unable to seek to import directory entry name at 0x{x}: {t}",
1157	1253	.{ name_loc, err },
1158	1254	);
...	...	@@ -1160,7 +1256,7 @@ const coff = struct {
1160	1256	const dll_name = (try r.takeDelimiter(0)).?;
1161	1257
1162	1258	try w.print("Import table entry for {s}:\n", .{dll_name});
1163		try dumpHeader(w, Entry, &entry, struct {});
	1259	try dumpHeader(d, Entry, &entry, struct {});
1164	1260
1165	1261	try w.print(
1166	1262	\\
...	...	@@ -1173,8 +1269,7 @@ const coff = struct {
1173	1269	sections.items,
1174	1270	entry.import_lookup_table_rva,
1175	1271	) orelse
1176		return failParse(
1177		opts,
	1272	return d.failParse(
1178	1273	"import directory entry ilt rva 0x{x} was not found in any section",
1179	1274	.{entry.import_lookup_table_rva},
1180	1275	);
...	...	@@ -1183,8 +1278,7 @@ const coff = struct {
1183	1278	entry.import_lookup_table_rva,
1184	1279	) catch unreachable;
1185	1280	fr.seekTo(ilt_loc) catch \|err\|
1186		return failParse(
1187		opts,
	1281	return d.failParse(
1188	1282	"unable to seek to import directory ilt at 0x{x}: {t}",
1189	1283	.{ ilt_loc, err },
1190	1284	);
...	...	@@ -1199,8 +1293,7 @@ const coff = struct {
1199	1293	defer ilt_entries.deinit(gpa);
1200	1294	while (true) {
1201	1295	const table_entry = r.takeStruct(TableEntry, .little) catch \|err\|
1202		return failParse(
1203		opts,
	1296	return d.failParse(
1204	1297	"unable to read ilt entry {s}:{x}: {t}",
1205	1298	.{ dll_name, ilt_entries.items.len, err },
1206	1299	);
...	...	@@ -1217,8 +1310,7 @@ const coff = struct {
1217	1310	sections.items,
1218	1311	ilt_entry.payload.hint_name_rva,
1219	1312	) orelse
1220		return failParse(
1221		opts,
	1313	return d.failParse(
1222	1314	"import directory ilt entry 0x{x}'s hint rva 0x{x} was not found in any section",
1223	1315	.{ ilt_entry_i, ilt_entry.payload.hint_name_rva },
1224	1316	);
...	...	@@ -1227,22 +1319,19 @@ const coff = struct {
1227	1319	ilt_entry.payload.hint_name_rva,
1228	1320	) catch unreachable;
1229	1321	fr.seekTo(hint_loc) catch \|err\|
1230		return failParse(
1231		opts,
	1322	return d.failParse(
1232	1323	"unable to seek to ilt entry 0x{x}'s hint at 0x{x}: {t}",
1233	1324	.{ ilt_entry_i, hint_loc, err },
1234	1325	);
1235	1326
1236	1327	const hint = r.takeInt(u16, .little) catch \|err\|
1237		return failParse(
1238		opts,
	1328	return d.failParse(
1239	1329	"unable to read import directory ilt entry 0x{x}'s hint: {t}",
1240	1330	.{ ilt_entry_i, err },
1241	1331	);
1242	1332
1243	1333	const name = r.takeDelimiter(0) catch \|err\|
1244		return failParse(
1245		opts,
	1334	return d.failParse(
1246	1335	"unable to read import directory ilt entry 0x{x}'s name: {t}",
1247	1336	.{ ilt_entry_i, err },
1248	1337	);
...	...	@@ -1250,18 +1339,16 @@ const coff = struct {
1250	1339	try w.print(" {x: >4} \| {s}\n", .{ hint, name.? });
1251	1340	}
1252	1341	}
1253		try w.writeByte('\n');
	1342	if (d.element(.newlines)) try w.writeByte('\n');
1254	1343	},
1255	1344	}
1256	1345	}
1257	1346	}
1258	1347	}
1259	1348
1260		if (opts.tls) {
	1349	if (d.opts.tls) {
1261	1350	if (try seekToDataDirectory(
1262		opts,
1263		fr,
1264		w,
	1351	d,
1265	1352	rva_index,
1266	1353	sections.items,
1267	1354	image_info.?.data_dirs,
...	...	@@ -1272,10 +1359,10 @@ const coff = struct {
1272	1359	inline else => \|m\| {
1273	1360	const TlsDirectoryEntry = std.coff.TlsDirectoryEntry(m);
1274	1361	const tls_entry = r.takeStruct(TlsDirectoryEntry, .little) catch \|err\|
1275		return failParse(opts, "unable to read tls directory: {t}", .{err});
	1362	return d.failParse("unable to read tls directory: {t}", .{err});
1276	1363
1277	1364	try w.writeAll("TLS Directory:\n");
1278		try dumpHeader(w, TlsDirectoryEntry, &tls_entry, struct {});
	1365	try dumpHeader(d, TlsDirectoryEntry, &tls_entry, struct {});
1279	1366
1280	1367	try w.writeAll(" \| ");
1281	1368	if (tls_entry.characteristics.alignment == .NONE) {
...	...	@@ -1301,8 +1388,7 @@ const coff = struct {
1301	1388	sections.items,
1302	1389	callbacks_rva,
1303	1390	) orelse
1304		return failParse(
1305		opts,
	1391	return d.failParse(
1306	1392	"tls callbacks rva 0x{x} was not found in any section",
1307	1393	.{callbacks_rva},
1308	1394	);
...	...	@@ -1311,24 +1397,22 @@ const coff = struct {
1311	1397	.rvaFileOffset(callbacks_rva) catch unreachable;
1312	1398
1313	1399	fr.seekTo(callbacks_loc) catch \|err\|
1314		return failParse(
1315		opts,
	1400	return d.failParse(
1316	1401	"unable to seek to tls callbacks array at offset 0x{x}: {t}",
1317	1402	.{ callbacks_loc, err },
1318	1403	);
1319	1404
1320	1405	while (true) {
1321	1406	const callback_va = r.takeInt(@FieldType(TlsDirectoryEntry, "callbacks_va"), .little) catch \|err\|
1322		return failParse(
1323		opts,
	1407	return d.failParse(
1324	1408	"unable to read tls callbacks array: {t}",
1325	1409	.{err},
1326	1410	);
1327	1411
1328		try w.print("{x: >16} \n", .{callback_va});
	1412	try w.print("{f}\n", .{fmtIntField(d, callback_va, .{ .kind = .va })});
1329	1413	if (callback_va == 0) break;
1330	1414	}
1331		try w.writeByte('\n');
	1415	if (d.element(.newlines)) try w.writeByte('\n');
1332	1416	},
1333	1417	}
1334	1418	}
...	...	@@ -1336,9 +1420,7 @@ const coff = struct {
1336	1420	}
1337	1421
1338	1422	fn seekToDataDirectory(
1339		opts: *const Options,
1340		fr: *Io.File.Reader,
1341		w: *Io.Writer,
	1423	d: *const DumpContext,
1342	1424	rva_index: []const u16,
1343	1425	sections: []const Section,
1344	1426	data_dirs: []const std.coff.ImageDataDirectory,
...	...	@@ -1349,16 +1431,14 @@ const coff = struct {
1349	1431	if (rva == 0) break :blk;
1350	1432
1351	1433	const section_index = sectionContainingRva(rva_index, sections, rva) orelse
1352		return failParse(
1353		opts,
	1434	return d.failParse(
1354	1435	"{t} directory rva 0x{x} was not found in any section",
1355	1436	.{ entry, rva },
1356	1437	);
1357	1438
1358	1439	const file_offset = sections[section_index].rvaFileOffset(rva) catch unreachable;
1359		fr.seekTo(file_offset) catch \|err\|
1360		return failParse(
1361		opts,
	1440	d.fr.seekTo(file_offset) catch \|err\|
	1441	return d.failParse(
1362	1442	"unable to seek to {t} directory at offset 0x{x}: {t}",
1363	1443	.{ entry, file_offset, err },
1364	1444	);
...	...	@@ -1366,7 +1446,7 @@ const coff = struct {
1366	1446	return section_index;
1367	1447	}
1368	1448
1369		try w.print("{t} directory was not present in optional header\n", .{entry});
	1449	try d.w.print("{t} directory was not present in optional header\n", .{entry});
1370	1450	return null;
1371	1451	}
1372	1452
...	...	@@ -1382,19 +1462,18 @@ const coff = struct {
1382	1462
1383	1463	fn order(ctx: @This(), section_index: u16) std.math.Order {
1384	1464	const h = &ctx.sections[section_index].header;
1385		const start = h.virtual_address;
1386		if (ctx.rva < start) return .lt;
	1465	if (ctx.rva < h.virtual_address) return .lt;
1387	1466	const end = h.virtual_address + h.size_of_raw_data;
1388	1467	if (ctx.rva >= end) return .gt;
1389	1468	return .eq;
1390	1469	}
1391	1470	};
1392	1471
1393		const index = std.sort.binarySearch(u16, indices, Context{
	1472	const indices_index = std.sort.binarySearch(u16, indices, Context{
1394	1473	.rva = rva,
1395	1474	.sections = sections,
1396	1475	}, Context.order) orelse return null;
1397		return @intCast(index);
	1476	return @intCast(indices[indices_index]);
1398	1477	}
1399	1478
1400	1479	fn headerName(raw: *const [8]u8, string_table: []const u8) ![]const u8 {
...	...	@@ -1427,6 +1506,40 @@ const coff = struct {
1427	1506	};
1428	1507	}
1429	1508
	1509	const FormatIntField = struct {
	1510	val: ?u64,
	1511	width: usize,
	1512	zero_fill: bool,
	1513	};
	1514
	1515	fn fmtIntField(
	1516	d: *const DumpContext,
	1517	val: anytype,
	1518	params: struct {
	1519	kind: ?FieldKind = null,
	1520	width: ?usize = null,
	1521	zero_fill: bool = false,
	1522	},
	1523	) std.fmt.Alt(FormatIntField, intFieldString) {
	1524	return .{
	1525	.data = .{
	1526	.val = if (d.redacted(params.kind)) null else val,
	1527	.width = params.width orelse @typeInfo(@TypeOf(val)).int.bits / 4,
	1528	.zero_fill = params.zero_fill,
	1529	},
	1530	};
	1531	}
	1532
	1533	fn intFieldString(field: FormatIntField, w: *std.Io.Writer) std.Io.Writer.Error!void {
	1534	if (field.val) \|val\| {
	1535	try w.printInt(val, 16, .lower, .{
	1536	.width = field.width,
	1537	.alignment = .right,
	1538	.fill = if (field.zero_fill) '0' else ' ',
	1539	});
	1540	} else try w.splatByteAll('x', field.width);
	1541	}
	1542
1430	1543	fn dumpFlags(w: Io.Writer, comptime fmt: []const u8, comptime T: type, flags: const T, cols: u32) !void {
1431	1544	const s = @typeInfo(T).@"struct";
1432	1545	inline for (s.fields) \|flag_field\| {
...	...	@@ -1437,33 +1550,53 @@ const coff = struct {
1437	1550	}
1438	1551	}
1439	1552
1440		fn dumpArchiveHeader(w: Io.Writer, header: const ArchiveHeader, pos: u32) !void {
1441		try w.print("Archive member at offset 0x{x}: '{s}'\n", .{ pos, header.name });
1442		try dumpHeader(w, ArchiveHeader, header, struct {
1443		pub fn name(_: const ArchiveHeader, _: Io.Writer) !void {}
1444		pub fn file_mode(h: const ArchiveHeader, cw: Io.Writer) !void {
1445		try cw.print("{o: >16} file_mode\n", .{h.file_mode});
	1553	fn dumpArchiveHeader(d: const DumpContext, header: const ArchiveHeader, pos: u32) !void {
	1554	try d.w.print("Archive member at offset 0x{x}: '{s}'\n", .{ pos, header.name });
	1555	try dumpHeader(d, ArchiveHeader, header, struct {
	1556	pub fn name(_: const DumpContext, _: const ArchiveHeader) !void {}
	1557	pub fn file_mode(id: const DumpContext, h: const ArchiveHeader) !void {
	1558	try id.w.print("{o: >16} file_mode\n", .{h.file_mode});
1446	1559	}
1447	1560	});
1448	1561	}
1449	1562
1450		fn dumpHeader(w: Io.Writer, comptime T: type, header: const T, Custom: type) !void {
	1563	fn fieldKind(name: []const u8) ?FieldKind {
	1564	if (std.mem.endsWith(u8, name, "_rva"))
	1565	return .rva;
	1566	if (std.mem.endsWith(u8, name, "_va") or
	1567	std.mem.endsWith(u8, name, "_address") or
	1568	std.mem.startsWith(u8, name, "pointer_"))
	1569	return .va;
	1570	if (std.mem.startsWith(u8, name, "number_"))
	1571	return .size;
	1572	return null;
	1573	}
	1574
	1575	fn dumpHeader(
	1576	d: *const DumpContext,
	1577	comptime T: type,
	1578	header: *const T,
	1579	Custom: type,
	1580	) !void {
1451	1581	inline for (@typeInfo(T).@"struct".fields) \|field\| {
1452	1582	const val = &@field(header, field.name);
1453	1583	if (@hasDecl(Custom, field.name)) {
1454		try @field(Custom, field.name)(header, w);
	1584	try @field(Custom, field.name)(d, header);
1455	1585	} else {
1456	1586	switch (@typeInfo(field.type)) {
1457		.int => try w.print("{x: >16} {s}\n", .{ val.*, field.name }),
1458		.@"enum" => try w.print("{x: >16} {s} ({t})\n", .{ val., field.name, val. }),
	1587	.int => try d.w.print("{f} {s}\n", .{ fmtIntField(d, val.*, .{
	1588	.kind = comptime fieldKind(field.name),
	1589	.width = 16,
	1590	}), field.name }),
	1591	.@"enum" => try d.w.print("{x: >16} {s} ({t})\n", .{ val., field.name, val. }),
1459	1592	.@"struct" => \|s\| {
1460	1593	switch (s.layout) {
1461	1594	.auto,
1462	1595	.@"extern",
1463		=> try dumpHeader(w, field.type, val, Custom),
	1596	=> try dumpHeader(d, field.type, val, Custom),
1464	1597	.@"packed" => {
1465		try w.print("{x: >16} {s}\n", .{ @as(s.backing_integer.?, @bitCast(val.*)), field.name });
1466		try dumpFlags(w, "\| {s}\n", field.type, val, 15);
	1598	try d.w.print("{x: >16} {s}\n", .{ @as(s.backing_integer.?, @bitCast(val.*)), field.name });
	1599	try dumpFlags(d.w, "\| {s}\n", field.type, val, 15);
1467	1600	},
1468	1601	}
1469	1602	},
...	...	@@ -1477,8 +1610,12 @@ const coff = struct {
1477	1610	try w.print("{d: >13}.{x:0<2} {s}\n", .{ major, minor, name });
1478	1611	}
1479	1612
1480		fn dumpRvaField(w: *Io.Writer, name: []const u8, rva: u64, base: u64) !void {
1481		try w.print("{x: >16} {s} ({x})\n", .{ rva, name, base + rva });
	1613	fn dumpRvaField(d: *const DumpContext, name: []const u8, rva: u64, base: u64) !void {
	1614	try d.w.print("{f} {s} ({f})\n", .{
	1615	fmtIntField(d, rva, .{ .kind = .rva }),
	1616	name,
	1617	fmtIntField(d, base + rva, .{ .kind = .va }),
	1618	});
1482	1619	}
1483	1620	};
1484	1621
...	...	@@ -1492,18 +1629,32 @@ const usage =
1492	1629	\\Usage: zig objdump [options] file
1493	1630	\\
1494	1631	\\Options:
1495		\\ -h, --help Print this help and exit
1496		\\ --all-headers Alias for --file-headers --member-headers --section-headers --relocs --symbols
1497		\\ --file-headers Display file-format specific headers
1498		\\ --imports Display imported symbols
1499		\\ --exports Display exported symbols
1500		\\ --linker-member[=1\|2\|longnames] (Coff) Display contents of the specified linker member (default 2)
1501		\\ --member-headers Display archive member headers
1502		\\ --only-member=[name] Only consider archive members names that contain [name]. Can be specified multiple times.
1503		\\ --only-section=[name] Only consider section names that contain [name]. Can be specified multiple times.
1504		\\ --relocs Display relocations
1505		\\ --section-headers Display section headers
1506		\\ --strings Display string tables
1507		\\ --symbols Display symbol tables
1508		\\ --tls Display TLS information
	1632	\\ -h, --help Print this help and exit
	1633	\\ --all-headers Alias for --file-headers --member-headers --section-headers --relocs --symbols
	1634	\\ --file-headers Display file-format specific headers
	1635	\\ --imports Display imported symbols
	1636	\\ --exports Display exported symbols
	1637	\\ --linker-member[=1\|2\|longnames] (Coff) Display contents of the specified archive linker member (default 2)
	1638	\\ --member-headers Display archive member headers
	1639	\\ --redact=[kind] Redact the specified field kind. Intended for snapshot testing.
	1640	\\ rva Relative virtual addresses
	1641	\\ va Virtual addresses and file offsets
	1642	\\ ord Symbol ordinals / hints
	1643	\\ size Sizes and lengths
	1644	\\ all All of the above
	1645	\\ --omit-element=[kind] Omit specific parts of the output. Intended for snapshot testing.
	1646	\\ file-type File type summary
	1647	\\ table-headers Table headers with column names
	1648	\\ header-names Name that precedes a header block
	1649	\\ newlines Newlines between output sections
	1650	\\ all All of the above
	1651	\\ --only-member=[name] Only consider archive members names that contain [name]. Can be specified multiple times.
	1652	\\ --only-section=[name] Only consider section names that contain [name]. Can be specified multiple times.
	1653	\\ --only-symbol=[name] Only consider symbol names that contain [name]. Can be specified multiple times.
	1654	\\ --relocs Display relocations
	1655	\\ -s, --snapshot Alias for --redact=all --omit-format=all
	1656	\\ --section-headers Display section headers
	1657	\\ --strings Display string tables
	1658	\\ --symbols Display symbol tables
	1659	\\ --tls Display TLS information
1509	1660	;

lib/std/Build/Configuration.zig+5-1

...	...	@@ -585,6 +585,8 @@ pub const Step = extern struct {
585	585	expect_stderr_match: Storage.FlagLengthPrefixedList(.flags2, .expect_stderr_match, Bytes),
586	586	expect_stdout_match: Storage.FlagLengthPrefixedList(.flags2, .expect_stdout_match, Bytes),
587	587	expect_term_value: Storage.FlagOptional(.flags2, .expect_term, u32),
	588	expect_stdout_snapshot: Storage.FlagOptional(.flags2, .expect_stdout_snapshot, LazyPath.Index),
	589	expect_stderr_snapshot: Storage.FlagOptional(.flags2, .expect_stderr_snapshot, LazyPath.Index),
588	590
589	591	pub const CapturedStream = extern struct {
590	592	generated_file: GeneratedFileIndex,
...	...	@@ -683,7 +685,9 @@ pub const Step = extern struct {
683	685	expect_stdout_match: bool,
684	686	expect_term: bool,
685	687	expect_term_status: ExpectTermStatus,
686		_: u25 = 0,
	688	expect_stdout_snapshot: bool,
	689	expect_stderr_snapshot: bool,
	690	_: u23 = 0,
687	691	};
688	692	};
689	693

lib/std/Build/Step/Run.zig+9

...	...	@@ -129,6 +129,8 @@ pub const StdIo = union(enum) {
129	129	expect_stdout_exact: []const u8,
130	130	expect_stdout_match: []const u8,
131	131	expect_term: process.Child.Term,
	132	expect_stderr_snapshot: std.Build.LazyPath,
	133	expect_stdout_snapshot: std.Build.LazyPath,
132	134	};
133	135	};
134	136
...	...	@@ -632,6 +634,13 @@ pub fn addCheck(run: *Run, new_check: StdIo.Check) void {
632	634	.check => \|*checks\| checks.append(b.allocator, new_check) catch @panic("OOM"),
633	635	else => @panic("illegal call to addCheck: conflicting helper method calls. Suggest to directly set stdio field of Run instead"),
634	636	}
	637
	638	switch (new_check) {
	639	.expect_stderr_snapshot,
	640	.expect_stdout_snapshot,
	641	=> \|file\| run.addFileInput(file),
	642	else => {},
	643	}
635	644	}
636	645
637	646	pub fn captureStdErr(run: *Run, options: CapturedStdIo.Options) std.Build.LazyPath {

test/link.zig+24-11

...	...	@@ -1,17 +1,30 @@
1		pub fn addCases(cases: @import("tests.zig").LinkContext) void {
2		if (cases.addTestStep("static-lib-exports")) \|name\| {
3		const lib = cases.addStaticLibrary(.{
	1	pub fn addCases(ctx: *@import("tests.zig").LinkContext) void {
	2	if (ctx.includeTest("exports-static")) \|prefix\| {
	3	const lib = ctx.addLibrary(.static, .{
4	4	.name = "lib",
5		.zig_source_bytes =
6		\\export fn foo() void {}
7		\\var bar: u32 = 1234;
8		\\comptime { @export(&bar, .{ .name = "bar", .linkage = .strong }); }
9		\\const baz: u64 = 5678;
10		\\comptime { @export(&baz, .{ .name = "baz", .linkage = .strong }); }
11		,
	5	.zig_source_file = ctx.sourcePath("exports.zig"),
12	6	});
13		cases.verifyObjdump(name, lib, &.{"--symbols"}, .{ .os = true });
	7	ctx.verifyObjdump(prefix, lib, &.{
	8	"-s",
	9	"--symbols",
	10	"--only-symbol=foo",
	11	}, .{});
14	12	}
	13
	14	if (ctx.includeTest("exports-dynamic")) \|prefix\| {
	15	const lib = ctx.addLibrary(.dynamic, .{
	16	.name = "lib",
	17	.zig_source_file = ctx.sourcePath("exports.zig"),
	18	});
	19	ctx.verifyObjdump(prefix, lib, &.{
	20	"-s",
	21	"--exports",
	22	"--only-symbol=foo",
	23	}, .{});
	24	}
	25
	26
	27
15	28	}
16	29
17	30	const std = @import("std");

test/link/exports.zig created+9

...	...	@@ -0,0 +1,9 @@
	1	export fn foo_fn() void {}
	2	var foo_var: u32 = 1234;
	3	comptime {
	4	@export(&foo_var, .{ .name = "foo_var", .linkage = .strong });
	5	}
	6	const foo_const: u64 = 5678;
	7	comptime {
	8	@export(&foo_const, .{ .name = "foo_const", .linkage = .strong });
	9	}

test/link/snapshots/exports-dynamic.lib.dmp created+14

...	...	@@ -0,0 +1,14 @@
	1	Export directory:
	2	0 flags
	3	0 time_date_stamp
	4	0.00 version
	5	xxxxxxxxxxxxxxxx name_rva
	6	1 ordinal_base
	7	xxxxxxxxxxxxxxxx number_of_entries
	8	xxxxxxxxxxxxxxxx number_of_names
	9	xxxxxxxxxxxxxxxx export_address_table_rva
	10	xxxxxxxxxxxxxxxx name_pointer_table_rva
	11	xxxxxxxxxxxxxxxx ordinal_table_rva
	12	xxxx xxxx xxxxxxxx \| foo_const
	13	xxxx xxxx xxxxxxxx \| foo_fn
	14	xxxx xxxx xxxxxxxx \| foo_var

test/link/snapshots/exports-static.lib.dmp created+3

...	...	@@ -0,0 +1,3 @@
	1	xxxx 00000000 4 NULL() EXTERNAL \| foo_fn
	2	xxxx 00000000 2 NULL EXTERNAL \| foo_var
	3	xxxx 00000008 3 NULL EXTERNAL \| foo_const

test/src/Link.zig+43-24

...	...	@@ -5,21 +5,29 @@ target: std.Build.ResolvedTarget,
5	5	use_llvm: bool,
6	6	use_lld: bool,
7	7	link_libc: bool,
8		suffix: []const u8,
9	8	test_filters: []const []const u8,
	9	update_step: ?*Step.UpdateSourceFiles,
	10	updated_snapshots: std.StringArrayHashMapUnmanaged(void),
10	11	max_rss: usize,
11	12
12		pub fn addTestStep(self: *const Link, prefix: []const u8) ?[]const u8 {
	13	pub fn includeTest(self: *const Link, prefix: []const u8) ?[]const u8 {
13	14	if (for (self.test_filters) \|filter\| {
14	15	if (std.mem.containsAtLeast(u8, prefix, 1, filter)) break false;
15	16	} else self.test_filters.len > 0) return null;
	17	return prefix;
	18	}
16	19
17		return std.fmt.allocPrint(self.b.allocator, "test-{s}", .{prefix}) catch @panic("OOM");
	20	pub fn sourcePath(self: *const Link, sub_path: []const u8) std.Build.LazyPath {
	21	return self.b.path(self.b.pathJoin(&.{ "test/link", sub_path }));
18	22	}
19	23
20		pub fn addStaticLibrary(self: const Link, overlay: OverlayOptions) Step.Compile {
	24	pub fn addLibrary(
	25	self: *const Link,
	26	linkage: std.builtin.LinkMode,
	27	overlay: OverlayOptions,
	28	) *Step.Compile {
21	29	return self.b.addLibrary(.{
22		.linkage = .static,
	30	.linkage = linkage,
23	31	.name = overlay.name,
24	32	.root_module = self.createModule(overlay),
25	33	.use_llvm = self.use_llvm,
...	...	@@ -27,7 +35,6 @@ pub fn addStaticLibrary(self: const Link, overlay: OverlayOptions) Step.Compil
27	35	});
28	36	}
29	37
30		// TODO: Use std.meta.FieldEnum on TargetQuery?
31	38	const SnapshotScope = packed struct {
32	39	arch: bool = false,
33	40	os: bool = false,
...	...	@@ -38,33 +45,44 @@ const SnapshotScope = packed struct {
38	45	link_libc: bool = false,
39	46	};
40	47
	48	/// Verify the results of a `zig objdump` call against a snapshot, which
	49	/// contains the expected output. Snapshots alias between all build
	50	/// configurations by default, but by specifying fields in `scope`,
	51	/// unique snapshot names are generated for each value of that field.
41	52	pub fn verifyObjdump(
42		self: *const Link,
43		name: []const u8,
	53	self: *Link,
	54	prefix: []const u8,
44	55	compile: *Step.Compile,
45	56	args: []const []const u8,
46	57	scope: SnapshotScope,
47	58	) void {
48		const snapshot_name = self.snapshotName(name, compile.name, scope) catch @panic("OOM");
	59	const snapshot_name = self.snapshotName(prefix, compile.name, scope) catch @panic("OOM");
	60	const snapshot_sub_path = self.b.pathJoin(&.{ "test/link/snapshots/", snapshot_name });
	61
	62	// Many tests may read the same snapshot, so only use the first one to update.
	63	// If there are differences in output, they will show up on the next test run.
	64	if (self.update_step != null) {
	65	const gop = self.updated_snapshots.getOrPut(self.b.allocator, snapshot_sub_path) catch @panic("OOM");
	66	if (gop.found_existing) return;
	67	}
	68
49	69	const run_step = Step.Run.create(self.b, self.b.fmt("objdump {s}", .{snapshot_name}));
50	70	run_step.addArgs(&.{ self.b.graph.zig_exe, "objdump" });
51	71	run_step.addArtifactArg(compile);
52	72	run_step.addArgs(args);
53	73	run_step.addCheck(.{ .expect_term = .{ .exited = 0 } });
54	74
55		const actual_path = run_step.captureStdOut(.{ .trim_whitespace = .none });
56		const expected_path = self.b.path(self.b.pathJoin(&.{ "test/link/snapshots/", snapshot_name }));
	75	if (self.update_step) \|update_step\| {
	76	// Workaround for the build system not realizing objdump itself has changed
	77	run_step.has_side_effects = true;
57	78
58		const check_step = self.b.addCheckFile(actual_path, .{
59		.expected_file = .{
60		.file = expected_path,
61		.if_missing = .fail,
62		// TODO: Option to do UpdateSourceFiles if not matching / missing?
63		// TODO: Option to output to <name>-<self.suffix>.actual.dmp file?
64		},
65		});
	79	const snapshot_update_path = run_step.captureStdOut(.{});
	80	update_step.addCopyFileToSource(snapshot_update_path, snapshot_sub_path);
	81	} else {
	82	run_step.addCheck(.{ .snapshot = .{ .file = self.b.path(snapshot_sub_path) } });
	83	}
66	84
67		self.step.dependOn(&check_step.step);
	85	self.step.dependOn(&run_step.step);
68	86	}
69	87
70	88	fn snapshotName(
...	...	@@ -81,9 +99,9 @@ fn snapshotName(
81	99	if (scope.os) try w.print("-{t}", .{self.target.result.os.tag});
82	100	if (scope.abi) try w.print("-{t}", .{self.target.result.abi});
83	101	if (scope.optimize) try w.print("-{t}", .{self.optimize});
84		if (scope.use_llvm and self.use_llvm) try w.writeAll("-llvm");
85		if (scope.use_lld and self.use_lld) try w.writeAll("-lld");
86		if (scope.link_libc and self.link_libc) try w.writeAll("-libc");
	102	if (scope.use_llvm) try w.writeAll(if (self.use_llvm) "-llvm" else "-no-llvm");
	103	if (scope.use_lld) try w.writeAll(if (self.use_lld) "-lld" else "-no-lld");
	104	if (scope.link_libc) try w.writeAll(if (self.link_libc) "-libc" else "-no-libc");
87	105	try w.writeAll(".dmp");
88	106
89	107	return try snapshot_name.toOwnedSlice();
...	...	@@ -95,7 +113,7 @@ fn createModule(self: const Link, overlay: OverlayOptions) Build.Module {
95	113	const mod = self.b.createModule(.{
96	114	.target = self.target,
97	115	.optimize = self.optimize,
98		.root_source_file = rsf: {
	116	.root_source_file = overlay.zig_source_file orelse rsf: {
99	117	const bytes = overlay.zig_source_bytes orelse break :rsf null;
100	118	const name = self.b.fmt("{s}.zig", .{overlay.name});
101	119	break :rsf write_files.add(name, bytes);
...	...	@@ -148,6 +166,7 @@ const OverlayOptions = struct {
148	166	objcpp_source_bytes: ?[]const u8 = null,
149	167	objcpp_source_flags: []const []const u8 = &.{},
150	168	zig_source_bytes: ?[]const u8 = null,
	169	zig_source_file: ?std.Build.LazyPath = null,
151	170	pic: ?bool = null,
152	171	strip: ?bool = null,
153	172	};

test/tests.zig+24-9

...	...	@@ -3148,6 +3148,11 @@ const LinkTestOptions = struct {
3148	3148
3149	3149	pub fn addLinkTests(b: std.Build, options: LinkTestOptions) Step {
3150	3150	const step = b.step("test-link", "Run the linker tests");
	3151	const update_snapshots = b.option(
	3152	bool,
	3153	"link-snapshot-update",
	3154	"Update linker test snapshots in-place instead of testing against them",
	3155	) orelse false;
3151	3156
3152	3157	for (link_targets) \|link_target\| {
3153	3158	if (options.skip_non_native and !link_target.target.isNative()) continue;
...	...	@@ -3168,24 +3173,34 @@ pub fn addLinkTests(b: std.Build, options: LinkTestOptions) Step {
3168	3173	if (options.skip_llvm and would_use_llvm) continue;
3169	3174	if (link_target.link_libc and target.abi == .msvc and b.graph.host.result.os.tag != .windows) continue;
3170	3175
3171		link.addCases(.{
	3176	const opt_update_step = if (update_snapshots) update: {
	3177	const update_step = Step.UpdateSourceFiles.create(b);
	3178	step.dependOn(&update_step.step);
	3179	break :update update_step;
	3180	} else null;
	3181
	3182	var context: LinkContext = .{
3172	3183	.b = b,
3173	3184	.step = step,
3174	3185	.optimize = optimize_mode,
3175	3186	.target = resolved_target,
3176		.suffix = std.fmt.allocPrint(b.allocator, "{s}-{t}{s}{s}{s}", .{
3177		target.zigTriple(b.allocator) catch @panic("OOM"),
3178		optimize_mode,
3179		if (link_target.use_llvm) "-llvm" else "",
3180		if (link_target.use_lld) "-lld" else "",
3181		if (link_target.link_libc) "-libc" else "",
3182		}) catch @panic("OOM"),
	3187	// .suffix = std.fmt.allocPrint(b.allocator, "{s}-{t}{s}{s}{s}", .{
	3188	// target.zigTriple(b.allocator) catch @panic("OOM"),
	3189	// optimize_mode,
	3190	// if (link_target.use_llvm) "-llvm" else "",
	3191	// if (link_target.use_lld) "-lld" else "",
	3192	// if (link_target.link_libc) "-libc" else "",
	3193	// }) catch @panic("OOM"),
3183	3194	.use_llvm = link_target.use_llvm,
3184	3195	.use_lld = link_target.use_lld,
3185	3196	.link_libc = link_target.link_libc,
3186	3197	.test_filters = options.test_filters,
	3198	.update_step = opt_update_step,
	3199	.updated_snapshots = .empty,
3187	3200	.max_rss = options.max_rss,
3188		});
	3201	};
	3202
	3203	link.addCases(&context);
3189	3204	}
3190	3205	}
3191	3206	return step;