Commit 2dcfa723767d284cef5eb180be7c080583ddbe25 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-10-16 18:48:43-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-10-23 16:27:38-07:00
log	2dcfa723767d284cef5eb180be7c080583ddbe25
tree	43056d154bda710c6478f5a13688e712e636b633
parent	b510c5719f3cfd55ee70da5a1005396d28dd1c1d

link.Elf: untangle parseObject and parseArchive

from link.Elf, so that they can be used earlier in the pipeline

7 files changed, 363 insertions(+), 289 deletions(-)

src
- link
  - Elf.zig
  - Elf
    Archive.zig
    Atom.zig
    Object.zig
    eh_frame.zig
    gc.zig
    relocatable.zig

src/link/Elf.zig+46-67

...	...	@@ -1398,8 +1398,15 @@ fn parseObject(self: *Elf, obj: link.Input.Object) ParseError!void {
1398	1398	defer tracy.end();
1399	1399
1400	1400	const gpa = self.base.comp.gpa;
	1401	const diags = &self.base.comp.link_diags;
	1402	const first_eflags = &self.first_eflags;
	1403	const target = self.base.comp.root_mod.resolved_target.result;
	1404	const debug_fmt_strip = self.base.comp.config.debug_format == .strip;
	1405	const default_sym_version = self.default_sym_version;
	1406	const file_handles = &self.file_handles;
	1407
1401	1408	const handle = obj.file;
1402		const fh = try self.addFileHandle(handle);
	1409	const fh = try addFileHandle(gpa, file_handles, handle);
1403	1410
1404	1411	const index: File.Index = @intCast(try self.files.addOne(gpa));
1405	1412	self.files.set(index, .{ .object = .{
...	...	@@ -1413,7 +1420,7 @@ fn parseObject(self: *Elf, obj: link.Input.Object) ParseError!void {
1413	1420	try self.objects.append(gpa, index);
1414	1421
1415	1422	const object = self.file(index).?.object;
1416		try object.parse(self);
	1423	try object.parse(gpa, diags, obj.path, handle, first_eflags, target, debug_fmt_strip, default_sym_version);
1417	1424	}
1418	1425
1419	1426	pub fn openParseArchiveReportingFailure(self: *Elf, path: Path) void {
...	...	@@ -1427,36 +1434,49 @@ pub fn openParseArchiveReportingFailure(self: *Elf, path: Path) void {
1427	1434	}
1428	1435
1429	1436	pub fn parseArchiveReportingFailure(self: *Elf, obj: link.Input.Object) void {
	1437	const gpa = self.base.comp.gpa;
1430	1438	const diags = &self.base.comp.link_diags;
1431		self.parseArchive(obj) catch \|err\| switch (err) {
	1439	const first_eflags = &self.first_eflags;
	1440	const target = self.base.comp.root_mod.resolved_target.result;
	1441	const debug_fmt_strip = self.base.comp.config.debug_format == .strip;
	1442	const default_sym_version = self.default_sym_version;
	1443	const file_handles = &self.file_handles;
	1444	const files = &self.files;
	1445	const objects = &self.objects;
	1446
	1447	parseArchive(gpa, diags, file_handles, files, first_eflags, target, debug_fmt_strip, default_sym_version, objects, obj) catch \|err\| switch (err) {
1432	1448	error.LinkFailure => return, // already reported
1433	1449	else => \|e\| diags.addParseError(obj.path, "failed to parse archive: {s}", .{@errorName(e)}),
1434	1450	};
1435	1451	}
1436	1452
1437		fn parseArchive(self: *Elf, obj: link.Input.Object) ParseError!void {
	1453	fn parseArchive(
	1454	gpa: Allocator,
	1455	diags: *Diags,
	1456	file_handles: *std.ArrayListUnmanaged(File.Handle),
	1457	files: *std.MultiArrayList(File.Entry),
	1458	first_eflags: *?elf.Word,
	1459	target: std.Target,
	1460	debug_fmt_strip: bool,
	1461	default_sym_version: elf.Versym,
	1462	objects: *std.ArrayListUnmanaged(File.Index),
	1463	obj: link.Input.Object,
	1464	) ParseError!void {
1438	1465	const tracy = trace(@src());
1439	1466	defer tracy.end();
1440	1467
1441		const gpa = self.base.comp.gpa;
1442		const handle = obj.file;
1443		const fh = try self.addFileHandle(handle);
1444
1445		var archive: Archive = .{};
	1468	const fh = try addFileHandle(gpa, file_handles, obj.file);
	1469	var archive = try Archive.parse(gpa, diags, file_handles, obj.path, fh);
1446	1470	defer archive.deinit(gpa);
1447		try archive.parse(self, obj.path, fh);
1448
1449		const objects = try archive.objects.toOwnedSlice(gpa);
1450		defer gpa.free(objects);
1451	1471
1452		for (objects) \|extracted\| {
1453		const index: File.Index = @intCast(try self.files.addOne(gpa));
1454		self.files.set(index, .{ .object = extracted });
1455		const object = &self.files.items(.data)[index].object;
	1472	for (archive.objects) \|extracted\| {
	1473	const index: File.Index = @intCast(try files.addOne(gpa));
	1474	files.set(index, .{ .object = extracted });
	1475	const object = &files.items(.data)[index].object;
1456	1476	object.index = index;
1457	1477	object.alive = obj.must_link;
1458		try object.parse(self);
1459		try self.objects.append(gpa, index);
	1478	try object.parse(gpa, diags, obj.path, obj.file, first_eflags, target, debug_fmt_strip, default_sym_version);
	1479	try objects.append(gpa, index);
1460	1480	}
1461	1481	}
1462	1482
...	...	@@ -1565,46 +1585,6 @@ fn parseDso(
1565	1585	}
1566	1586	}
1567	1587
1568		pub fn validateEFlags(self: *Elf, file_index: File.Index, e_flags: elf.Word) !void {
1569		if (self.first_eflags == null) {
1570		self.first_eflags = e_flags;
1571		return; // there isn't anything to conflict with yet
1572		}
1573		const self_eflags: *elf.Word = &self.first_eflags.?;
1574
1575		switch (self.getTarget().cpu.arch) {
1576		.riscv64 => {
1577		if (e_flags != self_eflags.*) {
1578		const riscv_eflags: riscv.RiscvEflags = @bitCast(e_flags);
1579		const self_riscv_eflags: *riscv.RiscvEflags = @ptrCast(self_eflags);
1580
1581		self_riscv_eflags.rvc = self_riscv_eflags.rvc or riscv_eflags.rvc;
1582		self_riscv_eflags.tso = self_riscv_eflags.tso or riscv_eflags.tso;
1583
1584		var any_errors: bool = false;
1585		if (self_riscv_eflags.fabi != riscv_eflags.fabi) {
1586		any_errors = true;
1587		try self.addFileError(
1588		file_index,
1589		"cannot link object files with different float-point ABIs",
1590		.{},
1591		);
1592		}
1593		if (self_riscv_eflags.rve != riscv_eflags.rve) {
1594		any_errors = true;
1595		try self.addFileError(
1596		file_index,
1597		"cannot link object files with different RVEs",
1598		.{},
1599		);
1600		}
1601		if (any_errors) return error.LinkFailure;
1602		}
1603		},
1604		else => {},
1605		}
1606		}
1607
1608	1588	/// When resolving symbols, we approach the problem similarly to `mold`.
1609	1589	/// 1. Resolve symbols across all objects (including those preemptively extracted archives).
1610	1590	/// 2. Resolve symbols across all shared objects.
...	...	@@ -4704,16 +4684,16 @@ fn fileLookup(files: std.MultiArrayList(File.Entry), index: File.Index) ?File {
4704	4684	};
4705	4685	}
4706	4686
4707		pub fn addFileHandle(self: *Elf, handle: fs.File) !File.HandleIndex {
4708		const gpa = self.base.comp.gpa;
4709		const index: File.HandleIndex = @intCast(self.file_handles.items.len);
4710		const fh = try self.file_handles.addOne(gpa);
4711		fh.* = handle;
4712		return index;
	4687	pub fn addFileHandle(
	4688	gpa: Allocator,
	4689	file_handles: *std.ArrayListUnmanaged(File.Handle),
	4690	handle: fs.File,
	4691	) Allocator.Error!File.HandleIndex {
	4692	try file_handles.append(gpa, handle);
	4693	return @intCast(file_handles.items.len - 1);
4713	4694	}
4714	4695
4715	4696	pub fn fileHandle(self: Elf, index: File.HandleIndex) File.Handle {
4716		assert(index < self.file_handles.items.len);
4717	4697	return self.file_handles.items[index];
4718	4698	}
4719	4699
...	...	@@ -5588,4 +5568,3 @@ const Thunk = @import("Elf/Thunk.zig");
5588	5568	const Value = @import("../Value.zig");
5589	5569	const VerneedSection = synthetic_sections.VerneedSection;
5590	5570	const ZigObject = @import("Elf/ZigObject.zig");
5591		const riscv = @import("riscv.zig");

src/link/Elf/Archive.zig+36-20

...	...	@@ -1,18 +1,29 @@
1		objects: std.ArrayListUnmanaged(Object) = .empty,
2		strtab: std.ArrayListUnmanaged(u8) = .empty,
3
4		pub fn deinit(self: *Archive, allocator: Allocator) void {
5		self.objects.deinit(allocator);
6		self.strtab.deinit(allocator);
	1	objects: []const Object,
	2	/// '\n'-delimited
	3	strtab: []const u8,
	4
	5	pub fn deinit(a: *Archive, gpa: Allocator) void {
	6	gpa.free(a.objects);
	7	gpa.free(a.strtab);
	8	a.* = undefined;
7	9	}
8	10
9		pub fn parse(self: Archive, elf_file: Elf, path: Path, handle_index: File.HandleIndex) !void {
10		const comp = elf_file.base.comp;
11		const gpa = comp.gpa;
12		const diags = &comp.link_diags;
13		const handle = elf_file.fileHandle(handle_index);
	11	pub fn parse(
	12	gpa: Allocator,
	13	diags: *Diags,
	14	file_handles: *const std.ArrayListUnmanaged(File.Handle),
	15	path: Path,
	16	handle_index: File.HandleIndex,
	17	) !Archive {
	18	const handle = file_handles.items[handle_index];
14	19	const size = (try handle.stat()).size;
15	20
	21	var objects: std.ArrayListUnmanaged(Object) = .empty;
	22	defer objects.deinit(gpa);
	23
	24	var strtab: std.ArrayListUnmanaged(u8) = .empty;
	25	defer strtab.deinit(gpa);
	26
16	27	var pos: usize = elf.ARMAG.len;
17	28	while (true) {
18	29	if (pos >= size) break;
...	...	@@ -37,8 +48,8 @@ pub fn parse(self: Archive, elf_file: Elf, path: Path, handle_index: File.Hand
37	48
38	49	if (hdr.isSymtab() or hdr.isSymtab64()) continue;
39	50	if (hdr.isStrtab()) {
40		try self.strtab.resize(gpa, obj_size);
41		const amt = try handle.preadAll(self.strtab.items, pos);
	51	try strtab.resize(gpa, obj_size);
	52	const amt = try handle.preadAll(strtab.items, pos);
42	53	if (amt != obj_size) return error.InputOutput;
43	54	continue;
44	55	}
...	...	@@ -47,7 +58,7 @@ pub fn parse(self: Archive, elf_file: Elf, path: Path, handle_index: File.Hand
47	58	const name = if (hdr.name()) \|name\|
48	59	name
49	60	else if (try hdr.nameOffset()) \|off\|
50		self.getString(off)
	61	stringTableLookup(strtab.items, off)
51	62	else
52	63	unreachable;
53	64
...	...	@@ -70,14 +81,18 @@ pub fn parse(self: Archive, elf_file: Elf, path: Path, handle_index: File.Hand
70	81	@as(Path, object.path), @as(Path, path),
71	82	});
72	83
73		try self.objects.append(gpa, object);
	84	try objects.append(gpa, object);
74	85	}
	86
	87	return .{
	88	.objects = try objects.toOwnedSlice(gpa),
	89	.strtab = try strtab.toOwnedSlice(gpa),
	90	};
75	91	}
76	92
77		fn getString(self: Archive, off: u32) []const u8 {
78		assert(off < self.strtab.items.len);
79		const name = mem.sliceTo(@as([*:'\n']const u8, @ptrCast(self.strtab.items.ptr + off)), 0);
80		return name[0 .. name.len - 1];
	93	pub fn stringTableLookup(strtab: []const u8, off: u32) [:'\n']const u8 {
	94	const slice = strtab[off..];
	95	return slice[0..mem.indexOfScalar(u8, slice, '\n').? :'\n'];
81	96	}
82	97
83	98	pub fn setArHdr(opts: struct {
...	...	@@ -290,8 +305,9 @@ const fs = std.fs;
290	305	const log = std.log.scoped(.link);
291	306	const mem = std.mem;
292	307	const Path = std.Build.Cache.Path;
	308	const Allocator = std.mem.Allocator;
293	309
294		const Allocator = mem.Allocator;
	310	const Diags = @import("../../link.zig").Diags;
295	311	const Archive = @This();
296	312	const Elf = @import("../Elf.zig");
297	313	const File = @import("file.zig").File;

src/link/Elf/Atom.zig+27-24

...	...	@@ -102,9 +102,13 @@ pub fn relocsShndx(self: Atom) ?u32 {
102	102	return self.relocs_section_index;
103	103	}
104	104
105		pub fn priority(self: Atom, elf_file: *Elf) u64 {
106		const index = self.file(elf_file).?.index();
107		return (@as(u64, @intCast(index)) << 32) \| @as(u64, @intCast(self.input_section_index));
	105	pub fn priority(atom: Atom, elf_file: *Elf) u64 {
	106	const index = atom.file(elf_file).?.index();
	107	return priorityLookup(index, atom.input_section_index);
	108	}
	109
	110	pub fn priorityLookup(file_index: File.Index, input_section_index: u32) u64 {
	111	return (@as(u64, @intCast(file_index)) << 32) \| @as(u64, @intCast(input_section_index));
108	112	}
109	113
110	114	/// Returns how much room there is to grow in virtual address space.
...	...	@@ -255,19 +259,13 @@ pub fn writeRelocs(self: Atom, elf_file: Elf, out_relocs: std.ArrayList(elf.El
255	259	}
256	260	}
257	261
258		pub fn fdes(self: Atom, elf_file: *Elf) []Fde {
259		const extras = self.extra(elf_file);
260		return switch (self.file(elf_file).?) {
261		.shared_object => unreachable,
262		.linker_defined, .zig_object => &[0]Fde{},
263		.object => \|x\| x.fdes.items[extras.fde_start..][0..extras.fde_count],
264		};
	262	pub fn fdes(atom: Atom, object: *Object) []Fde {
	263	const extras = object.atomExtra(atom.extra_index);
	264	return object.fdes.items[extras.fde_start..][0..extras.fde_count];
265	265	}
266	266
267		pub fn markFdesDead(self: Atom, elf_file: *Elf) void {
268		for (self.fdes(elf_file)) \|*fde\| {
269		fde.alive = false;
270		}
	267	pub fn markFdesDead(self: Atom, object: *Object) void {
	268	for (self.fdes(object)) \|*fde\| fde.alive = false;
271	269	}
272	270
273	271	pub fn addReloc(self: Atom, alloc: Allocator, reloc: elf.Elf64_Rela, zo: *ZigObject) !void {
...	...	@@ -946,16 +944,21 @@ fn format2(
946	944	atom.output_section_index, atom.alignment.toByteUnits() orelse 0, atom.size,
947	945	atom.prev_atom_ref, atom.next_atom_ref,
948	946	});
949		if (atom.fdes(elf_file).len > 0) {
950		try writer.writeAll(" : fdes{ ");
951		const extras = atom.extra(elf_file);
952		for (atom.fdes(elf_file), extras.fde_start..) \|fde, i\| {
953		try writer.print("{d}", .{i});
954		if (!fde.alive) try writer.writeAll("([*])");
955		if (i - extras.fde_start < extras.fde_count - 1) try writer.writeAll(", ");
956		}
957		try writer.writeAll(" }");
958		}
	947	if (atom.file(elf_file)) \|atom_file\| switch (atom_file) {
	948	.object => \|object\| {
	949	if (atom.fdes(object).len > 0) {
	950	try writer.writeAll(" : fdes{ ");
	951	const extras = atom.extra(elf_file);
	952	for (atom.fdes(object), extras.fde_start..) \|fde, i\| {
	953	try writer.print("{d}", .{i});
	954	if (!fde.alive) try writer.writeAll("([*])");
	955	if (i - extras.fde_start < extras.fde_count - 1) try writer.writeAll(", ");
	956	}
	957	try writer.writeAll(" }");
	958	}
	959	},
	960	else => {},
	961	};
959	962	if (!atom.alive) {
960	963	try writer.writeAll(" : [*]");
961	964	}

src/link/Elf/Object.zig+197-126

...	...	@@ -37,72 +37,87 @@ num_dynrelocs: u32 = 0,
37	37	output_symtab_ctx: Elf.SymtabCtx = .{},
38	38	output_ar_state: Archive.ArState = .{},
39	39
40		pub fn deinit(self: *Object, allocator: Allocator) void {
41		if (self.archive) \|*ar\| allocator.free(ar.path.sub_path);
42		allocator.free(self.path.sub_path);
43		self.shdrs.deinit(allocator);
44		self.symtab.deinit(allocator);
45		self.strtab.deinit(allocator);
46		self.symbols.deinit(allocator);
47		self.symbols_extra.deinit(allocator);
48		self.symbols_resolver.deinit(allocator);
49		self.atoms.deinit(allocator);
50		self.atoms_indexes.deinit(allocator);
51		self.atoms_extra.deinit(allocator);
52		self.comdat_groups.deinit(allocator);
53		self.comdat_group_data.deinit(allocator);
54		self.relocs.deinit(allocator);
55		self.fdes.deinit(allocator);
56		self.cies.deinit(allocator);
57		self.eh_frame_data.deinit(allocator);
	40	pub fn deinit(self: *Object, gpa: Allocator) void {
	41	if (self.archive) \|*ar\| gpa.free(ar.path.sub_path);
	42	gpa.free(self.path.sub_path);
	43	self.shdrs.deinit(gpa);
	44	self.symtab.deinit(gpa);
	45	self.strtab.deinit(gpa);
	46	self.symbols.deinit(gpa);
	47	self.symbols_extra.deinit(gpa);
	48	self.symbols_resolver.deinit(gpa);
	49	self.atoms.deinit(gpa);
	50	self.atoms_indexes.deinit(gpa);
	51	self.atoms_extra.deinit(gpa);
	52	self.comdat_groups.deinit(gpa);
	53	self.comdat_group_data.deinit(gpa);
	54	self.relocs.deinit(gpa);
	55	self.fdes.deinit(gpa);
	56	self.cies.deinit(gpa);
	57	self.eh_frame_data.deinit(gpa);
58	58	for (self.input_merge_sections.items) \|*isec\| {
59		isec.deinit(allocator);
	59	isec.deinit(gpa);
60	60	}
61		self.input_merge_sections.deinit(allocator);
62		self.input_merge_sections_indexes.deinit(allocator);
	61	self.input_merge_sections.deinit(gpa);
	62	self.input_merge_sections_indexes.deinit(gpa);
63	63	}
64	64
65		pub fn parse(self: Object, elf_file: Elf) !void {
66		const gpa = elf_file.base.comp.gpa;
67		const cpu_arch = elf_file.getTarget().cpu.arch;
68		const handle = elf_file.fileHandle(self.file_handle);
69
70		try self.parseCommon(gpa, handle, elf_file);
	65	pub fn parse(
	66	self: *Object,
	67	gpa: Allocator,
	68	diags: *Diags,
	69	/// For error reporting purposes only.
	70	path: Path,
	71	handle: fs.File,
	72	first_eflags: *?elf.Word,
	73	target: std.Target,
	74	debug_fmt_strip: bool,
	75	default_sym_version: elf.Versym,
	76	) !void {
	77	try self.parseCommon(gpa, diags, path, handle, first_eflags, target);
71	78
72	79	// Append null input merge section
73	80	try self.input_merge_sections.append(gpa, .{});
74	81	// Allocate atom index 0 to null atom
75	82	try self.atoms.append(gpa, .{ .extra_index = try self.addAtomExtra(gpa, .{}) });
76	83
77		try self.initAtoms(gpa, handle, elf_file);
78		try self.initSymbols(gpa, elf_file);
	84	try self.initAtoms(gpa, diags, path, handle, debug_fmt_strip, target);
	85	try self.initSymbols(gpa, default_sym_version);
79	86
80	87	for (self.shdrs.items, 0..) \|shdr, i\| {
81	88	const atom_ptr = self.atom(self.atoms_indexes.items[i]) orelse continue;
82	89	if (!atom_ptr.alive) continue;
83		if ((cpu_arch == .x86_64 and shdr.sh_type == elf.SHT_X86_64_UNWIND) or
84		mem.eql(u8, atom_ptr.name(elf_file), ".eh_frame"))
	90	if ((target.cpu.arch == .x86_64 and shdr.sh_type == elf.SHT_X86_64_UNWIND) or
	91	mem.eql(u8, self.getString(atom_ptr.name_offset), ".eh_frame"))
85	92	{
86		try self.parseEhFrame(gpa, handle, @as(u32, @intCast(i)), elf_file);
	93	try self.parseEhFrame(gpa, handle, @intCast(i), target);
87	94	}
88	95	}
89	96	}
90	97
91		fn parseCommon(self: Object, allocator: Allocator, handle: std.fs.File, elf_file: Elf) !void {
	98	fn parseCommon(
	99	self: *Object,
	100	gpa: Allocator,
	101	diags: *Diags,
	102	path: Path,
	103	handle: fs.File,
	104	first_eflags: *?elf.Word,
	105	target: std.Target,
	106	) !void {
92	107	const offset = if (self.archive) \|ar\| ar.offset else 0;
93	108	const file_size = (try handle.stat()).size;
94	109
95		const header_buffer = try Elf.preadAllAlloc(allocator, handle, offset, @sizeOf(elf.Elf64_Ehdr));
96		defer allocator.free(header_buffer);
	110	const header_buffer = try Elf.preadAllAlloc(gpa, handle, offset, @sizeOf(elf.Elf64_Ehdr));
	111	defer gpa.free(header_buffer);
97	112	self.header = @as(align(1) const elf.Elf64_Ehdr, @ptrCast(header_buffer)).;
98	113
99		const em = elf_file.base.comp.root_mod.resolved_target.result.toElfMachine();
	114	const em = target.toElfMachine();
100	115	if (em != self.header.?.e_machine) {
101		return elf_file.failFile(self.index, "invalid ELF machine type: {s}", .{
	116	return diags.failParse(path, "invalid ELF machine type: {s}", .{
102	117	@tagName(self.header.?.e_machine),
103	118	});
104	119	}
105		try elf_file.validateEFlags(self.index, self.header.?.e_flags);
	120	try validateEFlags(diags, path, target, self.header.?.e_flags, first_eflags);
106	121
107	122	if (self.header.?.e_shnum == 0) return;
108	123
...	...	@@ -110,30 +125,30 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
110	125	const shnum = math.cast(usize, self.header.?.e_shnum) orelse return error.Overflow;
111	126	const shsize = shnum * @sizeOf(elf.Elf64_Shdr);
112	127	if (file_size < offset + shoff or file_size < offset + shoff + shsize) {
113		return elf_file.failFile(self.index, "corrupt header: section header table extends past the end of file", .{});
	128	return diags.failParse(path, "corrupt header: section header table extends past the end of file", .{});
114	129	}
115	130
116		const shdrs_buffer = try Elf.preadAllAlloc(allocator, handle, offset + shoff, shsize);
117		defer allocator.free(shdrs_buffer);
	131	const shdrs_buffer = try Elf.preadAllAlloc(gpa, handle, offset + shoff, shsize);
	132	defer gpa.free(shdrs_buffer);
118	133	const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(shdrs_buffer.ptr))[0..shnum];
119		try self.shdrs.appendUnalignedSlice(allocator, shdrs);
	134	try self.shdrs.appendUnalignedSlice(gpa, shdrs);
120	135
121	136	for (self.shdrs.items) \|shdr\| {
122	137	if (shdr.sh_type != elf.SHT_NOBITS) {
123	138	if (file_size < offset + shdr.sh_offset or file_size < offset + shdr.sh_offset + shdr.sh_size) {
124		return elf_file.failFile(self.index, "corrupt section: extends past the end of file", .{});
	139	return diags.failParse(path, "corrupt section: extends past the end of file", .{});
125	140	}
126	141	}
127	142	}
128	143
129		const shstrtab = try self.preadShdrContentsAlloc(allocator, handle, self.header.?.e_shstrndx);
130		defer allocator.free(shstrtab);
	144	const shstrtab = try self.preadShdrContentsAlloc(gpa, handle, self.header.?.e_shstrndx);
	145	defer gpa.free(shstrtab);
131	146	for (self.shdrs.items) \|shdr\| {
132	147	if (shdr.sh_name >= shstrtab.len) {
133		return elf_file.failFile(self.index, "corrupt section name offset", .{});
	148	return diags.failParse(path, "corrupt section name offset", .{});
134	149	}
135	150	}
136		try self.strtab.appendSlice(allocator, shstrtab);
	151	try self.strtab.appendSlice(gpa, shstrtab);
137	152
138	153	const symtab_index = for (self.shdrs.items, 0..) \|shdr, i\| switch (shdr.sh_type) {
139	154	elf.SHT_SYMTAB => break @as(u32, @intCast(i)),
...	...	@@ -144,19 +159,19 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
144	159	const shdr = self.shdrs.items[index];
145	160	self.first_global = shdr.sh_info;
146	161
147		const raw_symtab = try self.preadShdrContentsAlloc(allocator, handle, index);
148		defer allocator.free(raw_symtab);
	162	const raw_symtab = try self.preadShdrContentsAlloc(gpa, handle, index);
	163	defer gpa.free(raw_symtab);
149	164	const nsyms = math.divExact(usize, raw_symtab.len, @sizeOf(elf.Elf64_Sym)) catch {
150		return elf_file.failFile(self.index, "symbol table not evenly divisible", .{});
	165	return diags.failParse(path, "symbol table not evenly divisible", .{});
151	166	};
152	167	const symtab = @as([*]align(1) const elf.Elf64_Sym, @ptrCast(raw_symtab.ptr))[0..nsyms];
153	168
154	169	const strtab_bias = @as(u32, @intCast(self.strtab.items.len));
155		const strtab = try self.preadShdrContentsAlloc(allocator, handle, shdr.sh_link);
156		defer allocator.free(strtab);
157		try self.strtab.appendSlice(allocator, strtab);
	170	const strtab = try self.preadShdrContentsAlloc(gpa, handle, shdr.sh_link);
	171	defer gpa.free(strtab);
	172	try self.strtab.appendSlice(gpa, strtab);
158	173
159		try self.symtab.ensureUnusedCapacity(allocator, symtab.len);
	174	try self.symtab.ensureUnusedCapacity(gpa, symtab.len);
160	175	for (symtab) \|sym\| {
161	176	const out_sym = self.symtab.addOneAssumeCapacity();
162	177	out_sym.* = sym;
...	...	@@ -168,15 +183,56 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
168	183	}
169	184	}
170	185
171		fn initAtoms(self: Object, allocator: Allocator, handle: std.fs.File, elf_file: Elf) !void {
172		const comp = elf_file.base.comp;
173		const debug_fmt_strip = comp.config.debug_format == .strip;
174		const target = comp.root_mod.resolved_target.result;
	186	fn validateEFlags(
	187	diags: *Diags,
	188	path: Path,
	189	target: std.Target,
	190	e_flags: elf.Word,
	191	first_eflags: *?elf.Word,
	192	) error{LinkFailure}!void {
	193	if (first_eflags.) \|self_eflags\| {
	194	switch (target.cpu.arch) {
	195	.riscv64 => {
	196	if (e_flags != self_eflags.*) {
	197	const riscv_eflags: riscv.RiscvEflags = @bitCast(e_flags);
	198	const self_riscv_eflags: *riscv.RiscvEflags = @ptrCast(self_eflags);
	199
	200	self_riscv_eflags.rvc = self_riscv_eflags.rvc or riscv_eflags.rvc;
	201	self_riscv_eflags.tso = self_riscv_eflags.tso or riscv_eflags.tso;
	202
	203	var any_errors: bool = false;
	204	if (self_riscv_eflags.fabi != riscv_eflags.fabi) {
	205	any_errors = true;
	206	diags.addParseError(path, "cannot link object files with different float-point ABIs", .{});
	207	}
	208	if (self_riscv_eflags.rve != riscv_eflags.rve) {
	209	any_errors = true;
	210	diags.addParseError(path, "cannot link object files with different RVEs", .{});
	211	}
	212	if (any_errors) return error.LinkFailure;
	213	}
	214	},
	215	else => {},
	216	}
	217	} else {
	218	first_eflags.* = e_flags;
	219	}
	220	}
	221
	222	fn initAtoms(
	223	self: *Object,
	224	gpa: Allocator,
	225	diags: *Diags,
	226	path: Path,
	227	handle: fs.File,
	228	debug_fmt_strip: bool,
	229	target: std.Target,
	230	) !void {
175	231	const shdrs = self.shdrs.items;
176		try self.atoms.ensureTotalCapacityPrecise(allocator, shdrs.len);
177		try self.atoms_extra.ensureTotalCapacityPrecise(allocator, shdrs.len * @sizeOf(Atom.Extra));
178		try self.atoms_indexes.ensureTotalCapacityPrecise(allocator, shdrs.len);
179		try self.atoms_indexes.resize(allocator, shdrs.len);
	232	try self.atoms.ensureTotalCapacityPrecise(gpa, shdrs.len);
	233	try self.atoms_extra.ensureTotalCapacityPrecise(gpa, shdrs.len * @sizeOf(Atom.Extra));
	234	try self.atoms_indexes.ensureTotalCapacityPrecise(gpa, shdrs.len);
	235	try self.atoms_indexes.resize(gpa, shdrs.len);
180	236	@memset(self.atoms_indexes.items, 0);
181	237
182	238	for (shdrs, 0..) \|shdr, i\| {
...	...	@@ -201,24 +257,24 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
201	257	};
202	258
203	259	const shndx: u32 = @intCast(i);
204		const group_raw_data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
205		defer allocator.free(group_raw_data);
	260	const group_raw_data = try self.preadShdrContentsAlloc(gpa, handle, shndx);
	261	defer gpa.free(group_raw_data);
206	262	const group_nmembers = math.divExact(usize, group_raw_data.len, @sizeOf(u32)) catch {
207		return elf_file.failFile(self.index, "corrupt section group: not evenly divisible ", .{});
	263	return diags.failParse(path, "corrupt section group: not evenly divisible ", .{});
208	264	};
209	265	if (group_nmembers == 0) {
210		return elf_file.failFile(self.index, "corrupt section group: empty section", .{});
	266	return diags.failParse(path, "corrupt section group: empty section", .{});
211	267	}
212	268	const group_members = @as([*]align(1) const u32, @ptrCast(group_raw_data.ptr))[0..group_nmembers];
213	269
214	270	if (group_members[0] != elf.GRP_COMDAT) {
215		return elf_file.failFile(self.index, "corrupt section group: unknown SHT_GROUP format", .{});
	271	return diags.failParse(path, "corrupt section group: unknown SHT_GROUP format", .{});
216	272	}
217	273
218	274	const group_start: u32 = @intCast(self.comdat_group_data.items.len);
219		try self.comdat_group_data.appendUnalignedSlice(allocator, group_members[1..]);
	275	try self.comdat_group_data.appendUnalignedSlice(gpa, group_members[1..]);
220	276
221		const comdat_group_index = try self.addComdatGroup(allocator);
	277	const comdat_group_index = try self.addComdatGroup(gpa);
222	278	const comdat_group = self.comdatGroup(comdat_group_index);
223	279	comdat_group.* = .{
224	280	.signature_off = group_signature,
...	...	@@ -242,8 +298,8 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
242	298	const shndx: u32 = @intCast(i);
243	299	if (self.skipShdr(shndx, debug_fmt_strip)) continue;
244	300	const size, const alignment = if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) blk: {
245		const data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
246		defer allocator.free(data);
	301	const data = try self.preadShdrContentsAlloc(gpa, handle, shndx);
	302	defer gpa.free(data);
247	303	const chdr = @as(align(1) const elf.Elf64_Chdr, @ptrCast(data.ptr)).;
248	304	break :blk .{ chdr.ch_size, Alignment.fromNonzeroByteUnits(chdr.ch_addralign) };
249	305	} else .{ shdr.sh_size, Alignment.fromNonzeroByteUnits(shdr.sh_addralign) };
...	...	@@ -263,13 +319,13 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
263	319	elf.SHT_REL, elf.SHT_RELA => {
264	320	const atom_index = self.atoms_indexes.items[shdr.sh_info];
265	321	if (self.atom(atom_index)) \|atom_ptr\| {
266		const relocs = try self.preadRelocsAlloc(allocator, handle, @intCast(i));
267		defer allocator.free(relocs);
	322	const relocs = try self.preadRelocsAlloc(gpa, handle, @intCast(i));
	323	defer gpa.free(relocs);
268	324	atom_ptr.relocs_section_index = @intCast(i);
269	325	const rel_index: u32 = @intCast(self.relocs.items.len);
270	326	const rel_count: u32 = @intCast(relocs.len);
271	327	self.setAtomFields(atom_ptr, .{ .rel_index = rel_index, .rel_count = rel_count });
272		try self.relocs.appendUnalignedSlice(allocator, relocs);
	328	try self.relocs.appendUnalignedSlice(gpa, relocs);
273	329	if (target.cpu.arch == .riscv64) {
274	330	sortRelocs(self.relocs.items[rel_index..][0..rel_count]);
275	331	}
...	...	@@ -293,14 +349,18 @@ fn skipShdr(self: *Object, index: u32, debug_fmt_strip: bool) bool {
293	349	return ignore;
294	350	}
295	351
296		fn initSymbols(self: Object, allocator: Allocator, elf_file: Elf) !void {
	352	fn initSymbols(
	353	self: *Object,
	354	gpa: Allocator,
	355	default_sym_version: elf.Versym,
	356	) !void {
297	357	const first_global = self.first_global orelse self.symtab.items.len;
298	358	const nglobals = self.symtab.items.len - first_global;
299	359
300		try self.symbols.ensureTotalCapacityPrecise(allocator, self.symtab.items.len);
301		try self.symbols_extra.ensureTotalCapacityPrecise(allocator, self.symtab.items.len * @sizeOf(Symbol.Extra));
302		try self.symbols_resolver.ensureTotalCapacityPrecise(allocator, nglobals);
303		self.symbols_resolver.resize(allocator, nglobals) catch unreachable;
	360	try self.symbols.ensureTotalCapacityPrecise(gpa, self.symtab.items.len);
	361	try self.symbols_extra.ensureTotalCapacityPrecise(gpa, self.symtab.items.len * @sizeOf(Symbol.Extra));
	362	try self.symbols_resolver.ensureTotalCapacityPrecise(gpa, nglobals);
	363	self.symbols_resolver.resize(gpa, nglobals) catch unreachable;
304	364	@memset(self.symbols_resolver.items, 0);
305	365
306	366	for (self.symtab.items, 0..) \|sym, i\| {
...	...	@@ -310,7 +370,7 @@ fn initSymbols(self: Object, allocator: Allocator, elf_file: Elf) !void {
310	370	sym_ptr.name_offset = sym.st_name;
311	371	sym_ptr.esym_index = @intCast(i);
312	372	sym_ptr.extra_index = self.addSymbolExtraAssumeCapacity(.{});
313		sym_ptr.version_index = if (i >= first_global) elf_file.default_sym_version else .LOCAL;
	373	sym_ptr.version_index = if (i >= first_global) default_sym_version else .LOCAL;
314	374	sym_ptr.flags.weak = sym.st_bind() == elf.STB_WEAK;
315	375	if (sym.st_shndx != elf.SHN_ABS and sym.st_shndx != elf.SHN_COMMON) {
316	376	sym_ptr.ref = .{ .index = self.atoms_indexes.items[sym.st_shndx], .file = self.index };
...	...	@@ -318,24 +378,30 @@ fn initSymbols(self: Object, allocator: Allocator, elf_file: Elf) !void {
318	378	}
319	379	}
320	380
321		fn parseEhFrame(self: Object, allocator: Allocator, handle: std.fs.File, shndx: u32, elf_file: Elf) !void {
	381	fn parseEhFrame(
	382	self: *Object,
	383	gpa: Allocator,
	384	handle: fs.File,
	385	shndx: u32,
	386	target: std.Target,
	387	) !void {
322	388	const relocs_shndx = for (self.shdrs.items, 0..) \|shdr, i\| switch (shdr.sh_type) {
323	389	elf.SHT_RELA => if (shdr.sh_info == shndx) break @as(u32, @intCast(i)),
324	390	else => {},
325	391	} else null;
326	392
327		const raw = try self.preadShdrContentsAlloc(allocator, handle, shndx);
328		defer allocator.free(raw);
329		const data_start = @as(u32, @intCast(self.eh_frame_data.items.len));
330		try self.eh_frame_data.appendSlice(allocator, raw);
	393	const raw = try self.preadShdrContentsAlloc(gpa, handle, shndx);
	394	defer gpa.free(raw);
	395	const data_start: u32 = @intCast(self.eh_frame_data.items.len);
	396	try self.eh_frame_data.appendSlice(gpa, raw);
331	397	const relocs = if (relocs_shndx) \|index\|
332		try self.preadRelocsAlloc(allocator, handle, index)
	398	try self.preadRelocsAlloc(gpa, handle, index)
333	399	else
334	400	&[0]elf.Elf64_Rela{};
335		defer allocator.free(relocs);
336		const rel_start = @as(u32, @intCast(self.relocs.items.len));
337		try self.relocs.appendUnalignedSlice(allocator, relocs);
338		if (elf_file.getTarget().cpu.arch == .riscv64) {
	401	defer gpa.free(relocs);
	402	const rel_start: u32 = @intCast(self.relocs.items.len);
	403	try self.relocs.appendUnalignedSlice(gpa, relocs);
	404	if (target.cpu.arch == .riscv64) {
339	405	sortRelocs(self.relocs.items[rel_start..][0..relocs.len]);
340	406	}
341	407	const fdes_start = self.fdes.items.len;
...	...	@@ -345,11 +411,11 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
345	411	while (try it.next()) \|rec\| {
346	412	const rel_range = filterRelocs(self.relocs.items[rel_start..][0..relocs.len], rec.offset, rec.size + 4);
347	413	switch (rec.tag) {
348		.cie => try self.cies.append(allocator, .{
	414	.cie => try self.cies.append(gpa, .{
349	415	.offset = data_start + rec.offset,
350	416	.size = rec.size,
351	417	.rel_index = rel_start + @as(u32, @intCast(rel_range.start)),
352		.rel_num = @as(u32, @intCast(rel_range.len)),
	418	.rel_num = @intCast(rel_range.len),
353	419	.input_section_index = shndx,
354	420	.file_index = self.index,
355	421	}),
...	...	@@ -361,12 +427,12 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
361	427	// this can happen for object files built with -r flag by the linker.
362	428	continue;
363	429	}
364		try self.fdes.append(allocator, .{
	430	try self.fdes.append(gpa, .{
365	431	.offset = data_start + rec.offset,
366	432	.size = rec.size,
367	433	.cie_index = undefined,
368	434	.rel_index = rel_start + @as(u32, @intCast(rel_range.start)),
369		.rel_num = @as(u32, @intCast(rel_range.len)),
	435	.rel_num = @intCast(rel_range.len),
370	436	.input_section_index = shndx,
371	437	.file_index = self.index,
372	438	});
...	...	@@ -376,7 +442,7 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
376	442
377	443	// Tie each FDE to its CIE
378	444	for (self.fdes.items[fdes_start..]) \|*fde\| {
379		const cie_ptr = fde.offset + 4 - fde.ciePointer(elf_file);
	445	const cie_ptr = fde.offset + 4 - fde.ciePointer(self);
380	446	const cie_index = for (self.cies.items[cies_start..], cies_start..) \|cie, cie_index\| {
381	447	if (cie.offset == cie_ptr) break @as(u32, @intCast(cie_index));
382	448	} else {
...	...	@@ -392,26 +458,26 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
392	458
393	459	// Tie each FDE record to its matching atom
394	460	const SortFdes = struct {
395		pub fn lessThan(ctx: *Elf, lhs: Fde, rhs: Fde) bool {
	461	pub fn lessThan(ctx: *Object, lhs: Fde, rhs: Fde) bool {
396	462	const lhs_atom = lhs.atom(ctx);
397	463	const rhs_atom = rhs.atom(ctx);
398		return lhs_atom.priority(ctx) < rhs_atom.priority(ctx);
	464	return Atom.priorityLookup(ctx.index, lhs_atom.input_section_index) < Atom.priorityLookup(ctx.index, rhs_atom.input_section_index);
399	465	}
400	466	};
401		mem.sort(Fde, self.fdes.items[fdes_start..], elf_file, SortFdes.lessThan);
	467	mem.sort(Fde, self.fdes.items[fdes_start..], self, SortFdes.lessThan);
402	468
403	469	// Create a back-link from atom to FDEs
404		var i: u32 = @as(u32, @intCast(fdes_start));
	470	var i: u32 = @intCast(fdes_start);
405	471	while (i < self.fdes.items.len) {
406	472	const fde = self.fdes.items[i];
407		const atom_ptr = fde.atom(elf_file);
	473	const atom_ptr = fde.atom(self);
408	474	const start = i;
409	475	i += 1;
410	476	while (i < self.fdes.items.len) : (i += 1) {
411	477	const next_fde = self.fdes.items[i];
412		if (atom_ptr.atom_index != next_fde.atom(elf_file).atom_index) break;
	478	if (atom_ptr.atom_index != next_fde.atom(self).atom_index) break;
413	479	}
414		atom_ptr.addExtra(.{ .fde_start = start, .fde_count = i - start }, elf_file);
	480	self.setAtomFields(atom_ptr, .{ .fde_start = start, .fde_count = i - start });
415	481	}
416	482	}
417	483
...	...	@@ -904,7 +970,7 @@ pub fn markComdatGroupsDead(self: Object, elf_file: Elf) void {
904	970	const atom_index = self.atoms_indexes.items[shndx];
905	971	if (self.atom(atom_index)) \|atom_ptr\| {
906	972	atom_ptr.alive = false;
907		atom_ptr.markFdesDead(elf_file);
	973	atom_ptr.markFdesDead(self);
908	974	}
909	975	}
910	976	}
...	...	@@ -970,10 +1036,13 @@ pub fn addAtomsToRelaSections(self: Object, elf_file: Elf) !void {
970	1036	}
971	1037	}
972	1038
973		pub fn parseAr(self: Object, elf_file: Elf) !void {
	1039	pub fn parseAr(self: Object, path: Path, elf_file: Elf) !void {
974	1040	const gpa = elf_file.base.comp.gpa;
	1041	const diags = &elf_file.base.comp.link_diags;
975	1042	const handle = elf_file.fileHandle(self.file_handle);
976		try self.parseCommon(gpa, handle, elf_file);
	1043	const first_eflags = &elf_file.first_eflags;
	1044	const target = elf_file.base.comp.root_mod.resolved_target.result;
	1045	try self.parseCommon(gpa, diags, path, handle, first_eflags, target);
977	1046	}
978	1047
979	1048	pub fn updateArSymtab(self: Object, ar_symtab: Archive.ArSymtab, elf_file: Elf) !void {
...	...	@@ -1000,7 +1069,7 @@ pub fn updateArSize(self: Object, elf_file: Elf) !void {
1000	1069	pub fn writeAr(self: Object, elf_file: *Elf, writer: anytype) !void {
1001	1070	const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
1002	1071	const offset: u64 = if (self.archive) \|ar\| ar.offset else 0;
1003		const name = std.fs.path.basename(self.path.sub_path);
	1072	const name = fs.path.basename(self.path.sub_path);
1004	1073	const hdr = Archive.setArHdr(.{
1005	1074	.name = if (name.len <= Archive.max_member_name_len)
1006	1075	.{ .name = name }
...	...	@@ -1136,8 +1205,8 @@ pub fn resolveSymbol(self: Object, index: Symbol.Index, elf_file: *Elf) Elf.Ref
1136	1205	return elf_file.resolver.get(resolv).?;
1137	1206	}
1138	1207
1139		fn addSymbol(self: *Object, allocator: Allocator) !Symbol.Index {
1140		try self.symbols.ensureUnusedCapacity(allocator, 1);
	1208	fn addSymbol(self: *Object, gpa: Allocator) !Symbol.Index {
	1209	try self.symbols.ensureUnusedCapacity(gpa, 1);
1141	1210	return self.addSymbolAssumeCapacity();
1142	1211	}
1143	1212
...	...	@@ -1147,9 +1216,9 @@ fn addSymbolAssumeCapacity(self: *Object) Symbol.Index {
1147	1216	return index;
1148	1217	}
1149	1218
1150		pub fn addSymbolExtra(self: *Object, allocator: Allocator, extra: Symbol.Extra) !u32 {
	1219	pub fn addSymbolExtra(self: *Object, gpa: Allocator, extra: Symbol.Extra) !u32 {
1151	1220	const fields = @typeInfo(Symbol.Extra).@"struct".fields;
1152		try self.symbols_extra.ensureUnusedCapacity(allocator, fields.len);
	1221	try self.symbols_extra.ensureUnusedCapacity(gpa, fields.len);
1153	1222	return self.addSymbolExtraAssumeCapacity(extra);
1154	1223	}
1155	1224
...	...	@@ -1198,27 +1267,27 @@ pub fn getString(self: Object, off: u32) [:0]const u8 {
1198	1267	return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.strtab.items.ptr + off)), 0);
1199	1268	}
1200	1269
1201		fn addString(self: *Object, allocator: Allocator, str: []const u8) !u32 {
	1270	fn addString(self: *Object, gpa: Allocator, str: []const u8) !u32 {
1202	1271	const off: u32 = @intCast(self.strtab.items.len);
1203		try self.strtab.ensureUnusedCapacity(allocator, str.len + 1);
	1272	try self.strtab.ensureUnusedCapacity(gpa, str.len + 1);
1204	1273	self.strtab.appendSliceAssumeCapacity(str);
1205	1274	self.strtab.appendAssumeCapacity(0);
1206	1275	return off;
1207	1276	}
1208	1277
1209	1278	/// Caller owns the memory.
1210		fn preadShdrContentsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, index: u32) ![]u8 {
	1279	fn preadShdrContentsAlloc(self: Object, gpa: Allocator, handle: fs.File, index: u32) ![]u8 {
1211	1280	assert(index < self.shdrs.items.len);
1212	1281	const offset = if (self.archive) \|ar\| ar.offset else 0;
1213	1282	const shdr = self.shdrs.items[index];
1214	1283	const sh_offset = math.cast(u64, shdr.sh_offset) orelse return error.Overflow;
1215	1284	const sh_size = math.cast(u64, shdr.sh_size) orelse return error.Overflow;
1216		return Elf.preadAllAlloc(allocator, handle, offset + sh_offset, sh_size);
	1285	return Elf.preadAllAlloc(gpa, handle, offset + sh_offset, sh_size);
1217	1286	}
1218	1287
1219	1288	/// Caller owns the memory.
1220		fn preadRelocsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, shndx: u32) ![]align(1) const elf.Elf64_Rela {
1221		const raw = try self.preadShdrContentsAlloc(allocator, handle, shndx);
	1289	fn preadRelocsAlloc(self: Object, gpa: Allocator, handle: fs.File, shndx: u32) ![]align(1) const elf.Elf64_Rela {
	1290	const raw = try self.preadShdrContentsAlloc(gpa, handle, shndx);
1222	1291	const num = @divExact(raw.len, @sizeOf(elf.Elf64_Rela));
1223	1292	return @as([*]align(1) const elf.Elf64_Rela, @ptrCast(raw.ptr))[0..num];
1224	1293	}
...	...	@@ -1230,9 +1299,9 @@ const AddAtomArgs = struct {
1230	1299	alignment: Alignment,
1231	1300	};
1232	1301
1233		fn addAtom(self: *Object, allocator: Allocator, args: AddAtomArgs) !Atom.Index {
1234		try self.atoms.ensureUnusedCapacity(allocator, 1);
1235		try self.atoms_extra.ensureUnusedCapacity(allocator, @sizeOf(Atom.Extra));
	1302	fn addAtom(self: *Object, gpa: Allocator, args: AddAtomArgs) !Atom.Index {
	1303	try self.atoms.ensureUnusedCapacity(gpa, 1);
	1304	try self.atoms_extra.ensureUnusedCapacity(gpa, @sizeOf(Atom.Extra));
1236	1305	return self.addAtomAssumeCapacity(args);
1237	1306	}
1238	1307
...	...	@@ -1257,9 +1326,9 @@ pub fn atom(self: Object, atom_index: Atom.Index) ?Atom {
1257	1326	return &self.atoms.items[atom_index];
1258	1327	}
1259	1328
1260		pub fn addAtomExtra(self: *Object, allocator: Allocator, extra: Atom.Extra) !u32 {
	1329	pub fn addAtomExtra(self: *Object, gpa: Allocator, extra: Atom.Extra) !u32 {
1261	1330	const fields = @typeInfo(Atom.Extra).@"struct".fields;
1262		try self.atoms_extra.ensureUnusedCapacity(allocator, fields.len);
	1331	try self.atoms_extra.ensureUnusedCapacity(gpa, fields.len);
1263	1332	return self.addAtomExtraAssumeCapacity(extra);
1264	1333	}
1265	1334
...	...	@@ -1308,9 +1377,9 @@ fn setAtomFields(o: Object, atom_ptr: Atom, opts: Atom.Extra.AsOptionals) void
1308	1377	o.setAtomExtra(atom_ptr.extra_index, extras);
1309	1378	}
1310	1379
1311		fn addInputMergeSection(self: *Object, allocator: Allocator) !Merge.InputSection.Index {
	1380	fn addInputMergeSection(self: *Object, gpa: Allocator) !Merge.InputSection.Index {
1312	1381	const index: Merge.InputSection.Index = @intCast(self.input_merge_sections.items.len);
1313		const msec = try self.input_merge_sections.addOne(allocator);
	1382	const msec = try self.input_merge_sections.addOne(gpa);
1314	1383	msec.* = .{};
1315	1384	return index;
1316	1385	}
...	...	@@ -1320,9 +1389,9 @@ fn inputMergeSection(self: Object, index: Merge.InputSection.Index) ?Merge.Inp
1320	1389	return &self.input_merge_sections.items[index];
1321	1390	}
1322	1391
1323		fn addComdatGroup(self: *Object, allocator: Allocator) !Elf.ComdatGroup.Index {
	1392	fn addComdatGroup(self: *Object, gpa: Allocator) !Elf.ComdatGroup.Index {
1324	1393	const index = @as(Elf.ComdatGroup.Index, @intCast(self.comdat_groups.items.len));
1325		_ = try self.comdat_groups.addOne(allocator);
	1394	_ = try self.comdat_groups.addOne(gpa);
1326	1395	return index;
1327	1396	}
1328	1397
...	...	@@ -1516,8 +1585,9 @@ const log = std.log.scoped(.link);
1516	1585	const math = std.math;
1517	1586	const mem = std.mem;
1518	1587	const Path = std.Build.Cache.Path;
1519		const Allocator = mem.Allocator;
	1588	const Allocator = std.mem.Allocator;
1520	1589
	1590	const Diags = @import("../../link.zig").Diags;
1521	1591	const Archive = @import("Archive.zig");
1522	1592	const Atom = @import("Atom.zig");
1523	1593	const AtomList = @import("AtomList.zig");
...	...	@@ -1528,3 +1598,4 @@ const File = @import("file.zig").File;
1528	1598	const Merge = @import("Merge.zig");
1529	1599	const Symbol = @import("Symbol.zig");
1530	1600	const Alignment = Atom.Alignment;
	1601	const riscv = @import("../riscv.zig");

src/link/Elf/eh_frame.zig+17-20

...	...	@@ -19,18 +19,16 @@ pub const Fde = struct {
19	19	return base + fde.out_offset;
20	20	}
21	21
22		pub fn data(fde: Fde, elf_file: *Elf) []u8 {
23		const object = elf_file.file(fde.file_index).?.object;
	22	pub fn data(fde: Fde, object: *Object) []u8 {
24	23	return object.eh_frame_data.items[fde.offset..][0..fde.calcSize()];
25	24	}
26	25
27		pub fn cie(fde: Fde, elf_file: *Elf) Cie {
28		const object = elf_file.file(fde.file_index).?.object;
	26	pub fn cie(fde: Fde, object: *Object) Cie {
29	27	return object.cies.items[fde.cie_index];
30	28	}
31	29
32		pub fn ciePointer(fde: Fde, elf_file: *Elf) u32 {
33		const fde_data = fde.data(elf_file);
	30	pub fn ciePointer(fde: Fde, object: *Object) u32 {
	31	const fde_data = fde.data(object);
34	32	return std.mem.readInt(u32, fde_data[4..8], .little);
35	33	}
36	34
...	...	@@ -38,16 +36,14 @@ pub const Fde = struct {
38	36	return fde.size + 4;
39	37	}
40	38
41		pub fn atom(fde: Fde, elf_file: Elf) Atom {
42		const object = elf_file.file(fde.file_index).?.object;
43		const rel = fde.relocs(elf_file)[0];
	39	pub fn atom(fde: Fde, object: Object) Atom {
	40	const rel = fde.relocs(object)[0];
44	41	const sym = object.symtab.items[rel.r_sym()];
45	42	const atom_index = object.atoms_indexes.items[sym.st_shndx];
46	43	return object.atom(atom_index).?;
47	44	}
48	45
49		pub fn relocs(fde: Fde, elf_file: *Elf) []align(1) const elf.Elf64_Rela {
50		const object = elf_file.file(fde.file_index).?.object;
	46	pub fn relocs(fde: Fde, object: *Object) []const elf.Elf64_Rela {
51	47	return object.relocs.items[fde.rel_index..][0..fde.rel_num];
52	48	}
53	49
...	...	@@ -87,7 +83,8 @@ pub const Fde = struct {
87	83	const fde = ctx.fde;
88	84	const elf_file = ctx.elf_file;
89	85	const base_addr = fde.address(elf_file);
90		const atom_name = fde.atom(elf_file).name(elf_file);
	86	const object = elf_file.file(fde.file_index).?.object;
	87	const atom_name = fde.atom(object).name(elf_file);
91	88	try writer.print("@{x} : size({x}) : cie({d}) : {s}", .{
92	89	base_addr + fde.out_offset,
93	90	fde.calcSize(),
...	...	@@ -306,7 +303,7 @@ pub fn calcEhFrameRelocs(elf_file: *Elf) usize {
306	303	}
307	304	for (object.fdes.items) \|fde\| {
308	305	if (!fde.alive) continue;
309		count += fde.relocs(elf_file).len;
	306	count += fde.relocs(object).len;
310	307	}
311	308	}
312	309	return count;
...	...	@@ -369,16 +366,16 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
369	366	for (object.fdes.items) \|fde\| {
370	367	if (!fde.alive) continue;
371	368
372		const contents = fde.data(elf_file);
	369	const contents = fde.data(object);
373	370
374	371	std.mem.writeInt(
375	372	i32,
376	373	contents[4..8],
377		@truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset))),
	374	@truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(object).out_offset))),
378	375	.little,
379	376	);
380	377
381		for (fde.relocs(elf_file)) \|rel\| {
	378	for (fde.relocs(object)) \|rel\| {
382	379	const ref = object.resolveSymbol(rel.r_sym(), elf_file);
383	380	const sym = elf_file.symbol(ref).?;
384	381	resolveReloc(fde, sym, rel, elf_file, contents) catch \|err\| switch (err) {
...	...	@@ -412,12 +409,12 @@ pub fn writeEhFrameRelocatable(elf_file: *Elf, writer: anytype) !void {
412	409	for (object.fdes.items) \|fde\| {
413	410	if (!fde.alive) continue;
414	411
415		const contents = fde.data(elf_file);
	412	const contents = fde.data(object);
416	413
417	414	std.mem.writeInt(
418	415	i32,
419	416	contents[4..8],
420		@truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset))),
	417	@truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(object).out_offset))),
421	418	.little,
422	419	);
423	420
...	...	@@ -490,7 +487,7 @@ pub fn writeEhFrameRelocs(elf_file: *Elf, writer: anytype) !void {
490	487
491	488	for (object.fdes.items) \|fde\| {
492	489	if (!fde.alive) continue;
493		for (fde.relocs(elf_file)) \|rel\| {
	490	for (fde.relocs(object)) \|rel\| {
494	491	const ref = object.resolveSymbol(rel.r_sym(), elf_file);
495	492	const sym = elf_file.symbol(ref).?;
496	493	const r_offset = fde.address(elf_file) + rel.r_offset - fde.offset;
...	...	@@ -548,7 +545,7 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
548	545	for (object.fdes.items) \|fde\| {
549	546	if (!fde.alive) continue;
550	547
551		const relocs = fde.relocs(elf_file);
	548	const relocs = fde.relocs(object);
552	549	assert(relocs.len > 0); // Should this be an error? Things are completely broken anyhow if this trips...
553	550	const rel = relocs[0];
554	551	const ref = object.resolveSymbol(rel.r_sym(), elf_file);

src/link/Elf/gc.zig+28-21

...	...	@@ -103,15 +103,20 @@ fn markLive(atom: Atom, elf_file: Elf) void {
103	103	assert(atom.visited);
104	104	const file = atom.file(elf_file).?;
105	105
106		for (atom.fdes(elf_file)) \|fde\| {
107		for (fde.relocs(elf_file)[1..]) \|rel\| {
108		const ref = file.resolveSymbol(rel.r_sym(), elf_file);
109		const target_sym = elf_file.symbol(ref) orelse continue;
110		const target_atom = target_sym.atom(elf_file) orelse continue;
111		target_atom.alive = true;
112		gc_track_live_log.debug("{}marking live atom({d})", .{ track_live_level, target_atom.atom_index });
113		if (markAtom(target_atom)) markLive(target_atom, elf_file);
114		}
	106	switch (file) {
	107	.object => \|object\| {
	108	for (atom.fdes(object)) \|fde\| {
	109	for (fde.relocs(object)[1..]) \|rel\| {
	110	const ref = file.resolveSymbol(rel.r_sym(), elf_file);
	111	const target_sym = elf_file.symbol(ref) orelse continue;
	112	const target_atom = target_sym.atom(elf_file) orelse continue;
	113	target_atom.alive = true;
	114	gc_track_live_log.debug("{}marking live atom({d})", .{ track_live_level, target_atom.atom_index });
	115	if (markAtom(target_atom)) markLive(target_atom, elf_file);
	116	}
	117	}
	118	},
	119	else => {},
115	120	}
116	121
117	122	for (atom.relocs(elf_file)) \|rel\| {
...	...	@@ -135,23 +140,25 @@ fn mark(roots: std.ArrayList(Atom), elf_file: Elf) void {
135	140	}
136	141	}
137	142
138		fn prune(elf_file: *Elf) void {
139		const pruneInFile = struct {
140		fn pruneInFile(file: File, ef: *Elf) void {
141		for (file.atoms()) \|atom_index\| {
142		const atom = file.atom(atom_index) orelse continue;
143		if (atom.alive and !atom.visited) {
144		atom.alive = false;
145		atom.markFdesDead(ef);
146		}
	143	fn pruneInFile(file: File) void {
	144	for (file.atoms()) \|atom_index\| {
	145	const atom = file.atom(atom_index) orelse continue;
	146	if (atom.alive and !atom.visited) {
	147	atom.alive = false;
	148	switch (file) {
	149	.object => \|object\| atom.markFdesDead(object),
	150	else => {},
147	151	}
148	152	}
149		}.pruneInFile;
	153	}
	154	}
	155
	156	fn prune(elf_file: *Elf) void {
150	157	if (elf_file.zigObjectPtr()) \|zo\| {
151		pruneInFile(zo.asFile(), elf_file);
	158	pruneInFile(zo.asFile());
152	159	}
153	160	for (elf_file.objects.items) \|index\| {
154		pruneInFile(elf_file.file(index).?, elf_file);
	161	pruneInFile(elf_file.file(index).?);
155	162	}
156	163	}
157	164

src/link/Elf/relocatable.zig+12-11

...	...	@@ -233,8 +233,10 @@ fn parseArchiveStaticLibReportingFailure(elf_file: *Elf, path: Path) void {
233	233
234	234	fn parseObjectStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
235	235	const gpa = elf_file.base.comp.gpa;
	236	const file_handles = &elf_file.file_handles;
	237
236	238	const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
237		const fh = try elf_file.addFileHandle(handle);
	239	const fh = try Elf.addFileHandle(gpa, file_handles, handle);
238	240
239	241	const index: File.Index = @intCast(try elf_file.files.addOne(gpa));
240	242	elf_file.files.set(index, .{ .object = .{
...	...	@@ -248,27 +250,26 @@ fn parseObjectStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
248	250	try elf_file.objects.append(gpa, index);
249	251
250	252	const object = elf_file.file(index).?.object;
251		try object.parseAr(elf_file);
	253	try object.parseAr(path, elf_file);
252	254	}
253	255
254	256	fn parseArchiveStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
255	257	const gpa = elf_file.base.comp.gpa;
	258	const diags = &elf_file.base.comp.link_diags;
	259	const file_handles = &elf_file.file_handles;
	260
256	261	const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
257		const fh = try elf_file.addFileHandle(handle);
	262	const fh = try Elf.addFileHandle(gpa, file_handles, handle);
258	263
259		var archive = Archive{};
	264	var archive = try Archive.parse(gpa, diags, file_handles, path, fh);
260	265	defer archive.deinit(gpa);
261		try archive.parse(elf_file, path, fh);
262
263		const objects = try archive.objects.toOwnedSlice(gpa);
264		defer gpa.free(objects);
265	266
266		for (objects) \|extracted\| {
267		const index = @as(File.Index, @intCast(try elf_file.files.addOne(gpa)));
	267	for (archive.objects) \|extracted\| {
	268	const index: File.Index = @intCast(try elf_file.files.addOne(gpa));
268	269	elf_file.files.set(index, .{ .object = extracted });
269	270	const object = &elf_file.files.items(.data)[index].object;
270	271	object.index = index;
271		try object.parseAr(elf_file);
	272	try object.parseAr(path, elf_file);
272	273	try elf_file.objects.append(gpa, index);
273	274	}
274	275	}