Commit 669f28594393e90e4d1aacd0d28f67ebe015b922 | zig

author	Jakub Konka <kubkon@jakubkonka.com> 2024-07-24 16:03:29+02:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2024-07-30 10:00:50+02:00
log	669f28594393e90e4d1aacd0d28f67ebe015b922
tree	08f6d4e19a0b8dfc431171214fffdb6e6d956883
parent	f1fedb3a51d4d9a37e4568ce1a80149bb5a610f7

elf: move ownership of atoms into objects

15 files changed, 464 insertions(+), 353 deletions(-)

src
- link

src/link/Elf.zig+39-99

 @@ -54,7 +54,7 @@ phdr_to_shdr_table: std.AutoHashMapUnmanaged(u32, u32) = .{},
 shdr_table_offset: ?u64 = null,
 /// Table of lists of atoms per output section.
 /// This table is not used to track incrementally generated atoms.
-output_sections: std.AutoArrayHashMapUnmanaged(u32, std.ArrayListUnmanaged(Atom.Index)) = .{},
+output_sections: std.AutoArrayHashMapUnmanaged(u32, std.ArrayListUnmanaged(Ref)) = .{},
 output_rela_sections: std.AutoArrayHashMapUnmanaged(u32, RelaSection) = .{},
 /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
 @@ -203,10 +203,6 @@ resolver: std.AutoArrayHashMapUnmanaged(u32, Symbol.Index) = .{},
 has_text_reloc: bool = false,
 num_ifunc_dynrelocs: usize = 0,
-/// List of atoms that are owned directly by the linker.
-atoms: std.ArrayListUnmanaged(Atom) = .{},
-atoms_extra: std.ArrayListUnmanaged(u32) = .{},
 /// List of range extension thunks.
 thunks: std.ArrayListUnmanaged(Thunk) = .{},
 @@ -375,9 +371,6 @@ pub fn createEmpty(
     try self.symbols.append(gpa, .{});
     // Index 0 is always a null symbol.
     try self.symbols_extra.append(gpa, 0);
-    // Allocate atom index 0 to null atom
-    try self.atoms.append(gpa, .{});
-    try self.atoms_extra.append(gpa, 0);
     // Append null file at index 0
     try self.files.append(gpa, .null);
     // Append null byte to string tables
 @@ -499,8 +492,6 @@ pub fn deinit(self: *Elf) void {
     self.resolver.deinit(gpa);
     self.start_stop_indexes.deinit(gpa);
-    self.atoms.deinit(gpa);
-    self.atoms_extra.deinit(gpa);
     for (self.thunks.items) |*th| {
         th.deinit(gpa);
     }
 @@ -1305,6 +1296,8 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
         const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
         self.files.set(index, .{ .linker_defined = .{ .index = index } });
         self.linker_defined_index = index;
+        const object = self.file(index).?.linker_defined;
+        try object.init(gpa);
     }
     // Now, we are ready to resolve the symbols across all input files.
 @@ -1379,15 +1372,15 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     // Beyond this point, everything has been allocated a virtual address and we can resolve
     // the relocations, and commit objects to file.
-    if (self.zigObjectPtr()) |zig_object| {
+    if (self.zigObjectPtr()) |zo| {
         var has_reloc_errors = false;
-        for (zig_object.atoms.items) |atom_index| {
+        for (zo.atoms_indexes.items) |atom_index| {
-            const atom_ptr = self.atom(atom_index) orelse continue;
+            const atom_ptr = zo.atom(atom_index) orelse continue;
             if (!atom_ptr.flags.alive) continue;
             const out_shndx = atom_ptr.outputShndx() orelse continue;
             const shdr = &self.shdrs.items[out_shndx];
             if (shdr.sh_type == elf.SHT_NOBITS) continue;
-            const code = try zig_object.codeAlloc(self, atom_index);
+            const code = try zo.codeAlloc(self, atom_index);
             defer gpa.free(code);
             const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));
             atom_ptr.resolveRelocsAlloc(self, code) catch |err| switch (err) {
 @@ -2012,8 +2005,8 @@ pub fn resolveSymbols(self: *Elf) void {
             const cg_owner = self.comdatGroupOwner(cg.owner);
             if (cg_owner.file != index) {
                 for (cg.comdatGroupMembers(self)) |shndx| {
-                    const atom_index = object.atoms.items[shndx];
+                    const atom_index = object.atoms_indexes.items[shndx];
-                    if (self.atom(atom_index)) |atom_ptr| {
+                    if (object.atom(atom_index)) |atom_ptr| {
                         atom_ptr.flags.alive = false;
                         atom_ptr.markFdesDead(self);
                     }
 @@ -2117,7 +2110,7 @@ fn claimUnresolved(self: *Elf) void {
 fn scanRelocs(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
-    var undefs = std.AutoHashMap(Symbol.Index, std.ArrayList(Atom.Index)).init(gpa);
+    var undefs = std.AutoHashMap(Symbol.Index, std.ArrayList(Ref)).init(gpa);
     defer {
         var it = undefs.iterator();
         while (it.next()) |entry| {
 @@ -3721,11 +3714,11 @@ fn sortInitFini(self: *Elf) !void {
     const Entry = struct {
         priority: i32,
-        atom_index: Atom.Index,
+        atom_ref: Ref,
         pub fn lessThan(ctx: *Elf, lhs: @This(), rhs: @This()) bool {
             if (lhs.priority == rhs.priority) {
-                return ctx.atom(lhs.atom_index).?.priority(ctx) < ctx.atom(rhs.atom_index).?.priority(ctx);
+                return ctx.atom(lhs.atom_ref).?.priority(ctx) < ctx.atom(rhs.atom_ref).?.priority(ctx);
             }
             return lhs.priority < rhs.priority;
         }
 @@ -3756,8 +3749,8 @@ fn sortInitFini(self: *Elf) !void {
         try entries.ensureTotalCapacityPrecise(atom_list.items.len);
         defer entries.deinit();
-        for (atom_list.items) |atom_index| {
+        for (atom_list.items) |ref| {
-            const atom_ptr = self.atom(atom_index).?;
+            const atom_ptr = self.atom(ref).?;
             const object = atom_ptr.file(self).?.object;
             const priority = blk: {
                 if (is_ctor_dtor) {
 @@ -3770,14 +3763,14 @@ fn sortInitFini(self: *Elf) !void {
                 const priority = std.fmt.parseUnsigned(u16, it.first(), 10) catch default;
                 break :blk priority;
             };
-            entries.appendAssumeCapacity(.{ .priority = priority, .atom_index = atom_index });
+            entries.appendAssumeCapacity(.{ .priority = priority, .atom_ref = ref });
         }
         mem.sort(Entry, entries.items, self, Entry.lessThan);
         atom_list.clearRetainingCapacity();
         for (entries.items) |entry| {
-            atom_list.appendAssumeCapacity(entry.atom_index);
+            atom_list.appendAssumeCapacity(entry.atom_ref);
         }
     }
 }
 @@ -4143,23 +4136,23 @@ fn resetShdrIndexes(self: *Elf, backlinks: []const u32) !void {
         }
     }
-    if (self.zigObjectPtr()) |zig_object| {
+    if (self.zigObjectPtr()) |zo| {
-        for (zig_object.atoms.items) |atom_index| {
+        for (zo.atoms_indexes.items) |atom_index| {
-            const atom_ptr = self.atom(atom_index) orelse continue;
+            const atom_ptr = zo.atom(atom_index) orelse continue;
             atom_ptr.output_section_index = backlinks[atom_ptr.output_section_index];
         }
-        for (zig_object.locals()) |local_index| {
+        for (zo.locals()) |local_index| {
             const local = self.symbol(local_index);
             local.output_section_index = backlinks[local.output_section_index];
         }
-        for (zig_object.globals()) |global_index| {
+        for (zo.globals()) |global_index| {
             const global = self.symbol(global_index);
             const atom_ptr = global.atom(self) orelse continue;
             if (!atom_ptr.flags.alive) continue;
             // TODO claim unresolved for objects
-            if (global.file(self).?.index() != zig_object.index) continue;
+            if (global.file(self).?.index() != zo.index) continue;
             const out_shndx = global.outputShndx() orelse continue;
             global.output_section_index = backlinks[out_shndx];
         }
 @@ -4182,8 +4175,8 @@ fn updateSectionSizes(self: *Elf) !void {
         const shdr = &self.shdrs.items[shndx];
         if (atom_list.items.len == 0) continue;
         if (self.requiresThunks() and shdr.sh_flags & elf.SHF_EXECINSTR != 0) continue;
-        for (atom_list.items) |atom_index| {
+        for (atom_list.items) |ref| {
-            const atom_ptr = self.atom(atom_index) orelse continue;
+            const atom_ptr = self.atom(ref) orelse continue;
             if (!atom_ptr.flags.alive) continue;
             const offset = atom_ptr.alignment.forward(shdr.sh_size);
             const padding = offset - shdr.sh_size;
 @@ -4618,7 +4611,7 @@ fn allocateSpecialPhdrs(self: *Elf) void {
 fn writeAtoms(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
-    var undefs = std.AutoHashMap(Symbol.Index, std.ArrayList(Atom.Index)).init(gpa);
+    var undefs = std.AutoHashMap(Symbol.Index, std.ArrayList(Ref)).init(gpa);
     defer {
         var it = undefs.iterator();
         while (it.next()) |entry| {
 @@ -4666,21 +4659,21 @@ fn writeAtoms(self: *Elf) !void {
             0;
         @memset(buffer, padding_byte);
-        for (atom_list.items) |atom_index| {
+        for (atom_list.items) |ref| {
-            const atom_ptr = self.atom(atom_index).?;
+            const atom_ptr = self.atom(ref).?;
             assert(atom_ptr.flags.alive);
             const offset = math.cast(usize, atom_ptr.value - @as(i64, @intCast(base_offset))) orelse
                 return error.Overflow;
             const size = math.cast(usize, atom_ptr.size) orelse return error.Overflow;
-            log.debug("writing atom({d}) at 0x{x}", .{ atom_index, sh_offset + offset });
+            log.debug("writing atom({}) at 0x{x}", .{ ref, sh_offset + offset });
             // TODO decompress directly into provided buffer
             const out_code = buffer[offset..][0..size];
             const in_code = switch (atom_ptr.file(self).?) {
-                .object => |x| try x.codeDecompressAlloc(self, atom_index),
+                .object => |x| try x.codeDecompressAlloc(self, ref.index),
-                .zig_object => |x| try x.codeAlloc(self, atom_index),
+                .zig_object => |x| try x.codeAlloc(self, ref.index),
                 else => unreachable,
             };
             defer gpa.free(in_code);
 @@ -5598,64 +5591,6 @@ fn getStartStopBasename(self: *Elf, shdr: elf.Elf64_Shdr) ?[]const u8 {
     return null;
 }
-pub fn atom(self: *Elf, atom_index: Atom.Index) ?*Atom {
-    if (atom_index == 0) return null;
-    assert(atom_index < self.atoms.items.len);
-    return &self.atoms.items[atom_index];
-}
-pub fn addAtom(self: *Elf) !Atom.Index {
-    const gpa = self.base.comp.gpa;
-    const index = @as(Atom.Index, @intCast(self.atoms.items.len));
-    const atom_ptr = try self.atoms.addOne(gpa);
-    atom_ptr.* = .{ .atom_index = index };
-    return index;
-}
-pub fn addAtomExtra(self: *Elf, extra: Atom.Extra) !u32 {
-    const fields = @typeInfo(Atom.Extra).Struct.fields;
-    try self.atoms_extra.ensureUnusedCapacity(self.base.comp.gpa, fields.len);
-    return self.addAtomExtraAssumeCapacity(extra);
-}
-pub fn addAtomExtraAssumeCapacity(self: *Elf, extra: Atom.Extra) u32 {
-    const index = @as(u32, @intCast(self.atoms_extra.items.len));
-    const fields = @typeInfo(Atom.Extra).Struct.fields;
-    inline for (fields) |field| {
-        self.atoms_extra.appendAssumeCapacity(switch (field.type) {
-            u32 => @field(extra, field.name),
-            else => @compileError("bad field type"),
-        });
-    }
-    return index;
-}
-pub fn atomExtra(self: *Elf, index: u32) ?Atom.Extra {
-    if (index == 0) return null;
-    const fields = @typeInfo(Atom.Extra).Struct.fields;
-    var i: usize = index;
-    var result: Atom.Extra = undefined;
-    inline for (fields) |field| {
-        @field(result, field.name) = switch (field.type) {
-            u32 => self.atoms_extra.items[i],
-            else => @compileError("bad field type"),
-        };
-        i += 1;
-    }
-    return result;
-}
-pub fn setAtomExtra(self: *Elf, index: u32, extra: Atom.Extra) void {
-    assert(index > 0);
-    const fields = @typeInfo(Atom.Extra).Struct.fields;
-    inline for (fields, 0..) |field, i| {
-        self.atoms_extra.items[index + i] = switch (field.type) {
-            u32 => @field(extra, field.name),
-            else => @compileError("bad field type"),
-        };
-    }
-}
 pub fn addThunk(self: *Elf) !Thunk.Index {
     const index = @as(Thunk.Index, @intCast(self.thunks.items.len));
     const th = try self.thunks.addOne(self.base.comp.gpa);
 @@ -5692,6 +5627,11 @@ pub fn fileHandle(self: Elf, index: File.HandleIndex) File.Handle {
     return self.file_handles.items[index];
 }
+pub fn atom(self: *Elf, ref: Ref) ?*Atom {
+    const file_ptr = self.file(ref.file) orelse return null;
+    return file_ptr.atom(ref.index);
+}
 /// Returns pointer-to-symbol described at sym_index.
 pub fn symbol(self: *Elf, sym_index: Symbol.Index) *Symbol {
     return &self.symbols.items[sym_index];
 @@ -5938,9 +5878,9 @@ fn reportUndefinedSymbols(self: *Elf, undefs: anytype) !void {
         var err = try self.base.addErrorWithNotesAssumeCapacity(nnotes);
         try err.addMsg("undefined symbol: {s}", .{self.symbol(undef_index).name(self)});
-        for (atoms[0..natoms]) |atom_index| {
+        for (atoms[0..natoms]) |ref| {
-            const atom_ptr = self.atom(atom_index).?;
+            const atom_ptr = self.atom(ref).?;
-            const file_ptr = self.file(atom_ptr.file_index).?;
+            const file_ptr = self.file(ref.file).?;
             try err.addNote("referenced by {s}:{s}", .{ file_ptr.fmtPath(), atom_ptr.name(self) });
         }
 @@ -6401,7 +6341,7 @@ const LastAtomAndFreeListTable = std.AutoArrayHashMapUnmanaged(u32, LastAtomAndF
 const RelaSection = struct {
     shndx: u32,
-    atom_list: std.ArrayListUnmanaged(Atom.Index) = .{},
+    atom_list: std.ArrayListUnmanaged(Ref) = .{},
 };
 const RelaSectionTable = std.AutoArrayHashMapUnmanaged(u32, RelaSection);

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

src/link/Elf/LinkerDefined.zig+8-1

src/link/Elf/Object.zig+199-123

...	@@ -10,9 +10,12 @@ symtab: std.ArrayListUnmanaged(elf.Elf64_Sym) = .{},	...	@@ -10,9 +10,12 @@ symtab: std.ArrayListUnmanaged(elf.Elf64_Sym) = .{},
10	strtab: std.ArrayListUnmanaged(u8) = .{},	10	strtab: std.ArrayListUnmanaged(u8) = .{},
11	first_global: ?Symbol.Index = null,	11	first_global: ?Symbol.Index = null,
12	symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},	12	symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},
13	atoms: std.ArrayListUnmanaged(Atom.Index) = .{},
14	relocs: std.ArrayListUnmanaged(elf.Elf64_Rela) = .{},	13	relocs: std.ArrayListUnmanaged(elf.Elf64_Rela) = .{},
15		14
		15	atoms: std.ArrayListUnmanaged(Atom) = .{},
		16	atoms_indexes: std.ArrayListUnmanaged(Atom.Index) = .{},
		17	atoms_extra: std.ArrayListUnmanaged(u32) = .{},
		18
16	comdat_groups: std.ArrayListUnmanaged(Elf.ComdatGroup) = .{},	19	comdat_groups: std.ArrayListUnmanaged(Elf.ComdatGroup) = .{},
17	comdat_group_data: std.ArrayListUnmanaged(u32) = .{},	20	comdat_group_data: std.ArrayListUnmanaged(u32) = .{},
18		21
...	@@ -49,6 +52,8 @@ pub fn deinit(self: *Object, allocator: Allocator) void {	...	@@ -49,6 +52,8 @@ pub fn deinit(self: *Object, allocator: Allocator) void {
49	self.strtab.deinit(allocator);	52	self.strtab.deinit(allocator);
50	self.symbols.deinit(allocator);	53	self.symbols.deinit(allocator);
51	self.atoms.deinit(allocator);	54	self.atoms.deinit(allocator);
		55	self.atoms_indexes.deinit(allocator);
		56	self.atoms_extra.deinit(allocator);
52	self.comdat_groups.deinit(allocator);	57	self.comdat_groups.deinit(allocator);
53	self.comdat_group_data.deinit(allocator);	58	self.comdat_group_data.deinit(allocator);
54	self.relocs.deinit(allocator);	59	self.relocs.deinit(allocator);
...	@@ -71,15 +76,17 @@ pub fn parse(self: Object, elf_file: Elf) !void {	...	@@ -71,15 +76,17 @@ pub fn parse(self: Object, elf_file: Elf) !void {
71		76
72	// Append null input merge section	77	// Append null input merge section
73	try self.input_merge_sections.append(gpa, .{});	78	try self.input_merge_sections.append(gpa, .{});
		79	// Allocate atom index 0 to null atom
		80	try self.atoms.append(gpa, .{ .extra_index = try self.addAtomExtra(gpa, .{}) });
74		81
75	try self.initAtoms(gpa, handle, elf_file);	82	try self.initAtoms(gpa, handle, elf_file);
76	try self.initSymtab(gpa, elf_file);	83	try self.initSymtab(gpa, elf_file);
77		84
78	for (self.shdrs.items, 0..) \|shdr, i\| {	85	for (self.shdrs.items, 0..) \|shdr, i\| {
79	const atom = elf_file.atom(self.atoms.items[i]) orelse continue;	86	const atom_ptr = self.atom(self.atoms_indexes.items[i]) orelse continue;
80	if (!atom.flags.alive) continue;	87	if (!atom_ptr.flags.alive) continue;
81	if ((cpu_arch == .x86_64 and shdr.sh_type == elf.SHT_X86_64_UNWIND) or	88	if ((cpu_arch == .x86_64 and shdr.sh_type == elf.SHT_X86_64_UNWIND) or
82	mem.eql(u8, atom.name(elf_file), ".eh_frame"))	89	mem.eql(u8, atom_ptr.name(elf_file), ".eh_frame"))
83	{	90	{
84	try self.parseEhFrame(gpa, handle, @as(u32, @intCast(i)), elf_file);	91	try self.parseEhFrame(gpa, handle, @as(u32, @intCast(i)), elf_file);
85	}	92	}
...	@@ -179,8 +186,11 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil	...	@@ -179,8 +186,11 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
179		186
180	fn initAtoms(self: Object, allocator: Allocator, handle: std.fs.File, elf_file: Elf) !void {	187	fn initAtoms(self: Object, allocator: Allocator, handle: std.fs.File, elf_file: Elf) !void {
181	const shdrs = self.shdrs.items;	188	const shdrs = self.shdrs.items;
182	try self.atoms.resize(allocator, shdrs.len);	189	try self.atoms.ensureTotalCapacityPrecise(allocator, shdrs.len);
183	@memset(self.atoms.items, 0);	190	try self.atoms_extra.ensureTotalCapacityPrecise(allocator, shdrs.len * @sizeOf(Atom.Extra));
		191	try self.atoms_indexes.ensureTotalCapacityPrecise(allocator, shdrs.len);
		192	try self.atoms_indexes.resize(allocator, shdrs.len);
		193	@memset(self.atoms_indexes.items, 0);
184		194
185	for (shdrs, 0..) \|shdr, i\| {	195	for (shdrs, 0..) \|shdr, i\| {
186	if (shdr.sh_flags & elf.SHF_EXCLUDE != 0 and	196	if (shdr.sh_flags & elf.SHF_EXCLUDE != 0 and
...	@@ -242,7 +252,19 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:	...	@@ -242,7 +252,19 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
242	else => {	252	else => {
243	const shndx = @as(u32, @intCast(i));	253	const shndx = @as(u32, @intCast(i));
244	if (self.skipShdr(shndx, elf_file)) continue;	254	if (self.skipShdr(shndx, elf_file)) continue;
245	try self.addAtom(allocator, handle, shdr, shndx, elf_file);	255	const size, const alignment = if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) blk: {
		256	const data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
		257	defer allocator.free(data);
		258	const chdr = @as(align(1) const elf.Elf64_Chdr, @ptrCast(data.ptr)).;
		259	break :blk .{ chdr.ch_size, Alignment.fromNonzeroByteUnits(chdr.ch_addralign) };
		260	} else .{ shdr.sh_size, Alignment.fromNonzeroByteUnits(shdr.sh_addralign) };
		261	const atom_index = self.addAtomAssumeCapacity(.{
		262	.name = shdr.sh_name,
		263	.shndx = shndx,
		264	.size = size,
		265	.alignment = alignment,
		266	});
		267	self.atoms_indexes.items[shndx] = atom_index;
246	},	268	},
247	}	269	}
248	}	270	}
...	@@ -250,14 +272,14 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:	...	@@ -250,14 +272,14 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
250	// Parse relocs sections if any.	272	// Parse relocs sections if any.
251	for (shdrs, 0..) \|shdr, i\| switch (shdr.sh_type) {	273	for (shdrs, 0..) \|shdr, i\| switch (shdr.sh_type) {
252	elf.SHT_REL, elf.SHT_RELA => {	274	elf.SHT_REL, elf.SHT_RELA => {
253	const atom_index = self.atoms.items[shdr.sh_info];	275	const atom_index = self.atoms_indexes.items[shdr.sh_info];
254	if (elf_file.atom(atom_index)) \|atom\| {	276	if (self.atom(atom_index)) \|atom_ptr\| {
255	const relocs = try self.preadRelocsAlloc(allocator, handle, @intCast(i));	277	const relocs = try self.preadRelocsAlloc(allocator, handle, @intCast(i));
256	defer allocator.free(relocs);	278	defer allocator.free(relocs);
257	atom.relocs_section_index = @intCast(i);	279	atom_ptr.relocs_section_index = @intCast(i);
258	const rel_index: u32 = @intCast(self.relocs.items.len);	280	const rel_index: u32 = @intCast(self.relocs.items.len);
259	const rel_count: u32 = @intCast(relocs.len);	281	const rel_count: u32 = @intCast(relocs.len);
260	try atom.addExtra(.{ .rel_index = rel_index, .rel_count = rel_count }, elf_file);	282	atom_ptr.addExtra(.{ .rel_index = rel_index, .rel_count = rel_count }, elf_file);
261	try self.relocs.appendUnalignedSlice(allocator, relocs);	283	try self.relocs.appendUnalignedSlice(allocator, relocs);
262	if (elf_file.getTarget().cpu.arch == .riscv64) {	284	if (elf_file.getTarget().cpu.arch == .riscv64) {
263	sortRelocs(self.relocs.items[rel_index..][0..rel_count]);	285	sortRelocs(self.relocs.items[rel_index..][0..rel_count]);
...	@@ -268,27 +290,6 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:	...	@@ -268,27 +290,6 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
268	};	290	};
269	}	291	}
270		292
271	fn addAtom(self: Object, allocator: Allocator, handle: std.fs.File, shdr: elf.Elf64_Shdr, shndx: u32, elf_file: Elf) !void {
272	const atom_index = try elf_file.addAtom();
273	const atom = elf_file.atom(atom_index).?;
274	atom.atom_index = atom_index;
275	atom.name_offset = shdr.sh_name;
276	atom.file_index = self.index;
277	atom.input_section_index = shndx;
278	self.atoms.items[shndx] = atom_index;
279
280	if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) {
281	const data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
282	defer allocator.free(data);
283	const chdr = @as(align(1) const elf.Elf64_Chdr, @ptrCast(data.ptr)).;
284	atom.size = chdr.ch_size;
285	atom.alignment = Alignment.fromNonzeroByteUnits(chdr.ch_addralign);
286	} else {
287	atom.size = shdr.sh_size;
288	atom.alignment = Alignment.fromNonzeroByteUnits(shdr.sh_addralign);
289	}
290	}
291
292	fn initOutputSection(self: Object, elf_file: *Elf, shdr: elf.Elf64_Shdr) error{OutOfMemory}!u32 {	293	fn initOutputSection(self: Object, elf_file: *Elf, shdr: elf.Elf64_Shdr) error{OutOfMemory}!u32 {
293	const name = blk: {	294	const name = blk: {
294	const name = self.getString(shdr.sh_name);	295	const name = self.getString(shdr.sh_name);
...	@@ -368,8 +369,10 @@ fn initSymtab(self: Object, allocator: Allocator, elf_file: Elf) !void {	...	@@ -368,8 +369,10 @@ fn initSymtab(self: Object, allocator: Allocator, elf_file: Elf) !void {
368	sym_ptr.value = @intCast(sym.st_value);	369	sym_ptr.value = @intCast(sym.st_value);
369	sym_ptr.name_offset = sym.st_name;	370	sym_ptr.name_offset = sym.st_name;
370	sym_ptr.esym_index = @as(u32, @intCast(i));	371	sym_ptr.esym_index = @as(u32, @intCast(i));
371	sym_ptr.atom_index = if (sym.st_shndx == elf.SHN_ABS) 0 else self.atoms.items[sym.st_shndx];
372	sym_ptr.file_index = self.index;	372	sym_ptr.file_index = self.index;
		373	if (sym.st_shndx != elf.SHN_ABS) {
		374	sym_ptr.atom_ref = .{ .index = self.atoms_indexes.items[sym.st_shndx], .file = self.index };
		375	}
373	}	376	}
374		377
375	for (self.symtab.items[first_global..]) \|sym\| {	378	for (self.symtab.items[first_global..]) \|sym\| {
...	@@ -456,15 +459,15 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:	...	@@ -456,15 +459,15 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
456	var i: u32 = @as(u32, @intCast(fdes_start));	459	var i: u32 = @as(u32, @intCast(fdes_start));
457	while (i < self.fdes.items.len) {	460	while (i < self.fdes.items.len) {
458	const fde = self.fdes.items[i];	461	const fde = self.fdes.items[i];
459	const atom = fde.atom(elf_file);	462	const atom_ptr = fde.atom(elf_file);
460	const start = i;	463	const start = i;
461	i += 1;	464	i += 1;
462	while (i < self.fdes.items.len) : (i += 1) {	465	while (i < self.fdes.items.len) : (i += 1) {
463	const next_fde = self.fdes.items[i];	466	const next_fde = self.fdes.items[i];
464	if (atom.atom_index != next_fde.atom(elf_file).atom_index) break;	467	if (atom_ptr.atom_index != next_fde.atom(elf_file).atom_index) break;
465	}	468	}
466	try atom.addExtra(.{ .fde_start = start, .fde_count = i - start }, elf_file);	469	atom_ptr.addExtra(.{ .fde_start = start, .fde_count = i - start }, elf_file);
467	atom.flags.fde = true;	470	atom_ptr.flags.fde = true;
468	}	471	}
469	}	472	}
470		473
...	@@ -507,19 +510,19 @@ fn filterRelocs(	...	@@ -507,19 +510,19 @@ fn filterRelocs(
507	pub fn scanRelocs(self: Object, elf_file: Elf, undefs: anytype) !void {	510	pub fn scanRelocs(self: Object, elf_file: Elf, undefs: anytype) !void {
508	const comp = elf_file.base.comp;	511	const comp = elf_file.base.comp;
509	const gpa = comp.gpa;	512	const gpa = comp.gpa;
510	for (self.atoms.items) \|atom_index\| {	513	for (self.atoms_indexes.items) \|atom_index\| {
511	const atom = elf_file.atom(atom_index) orelse continue;	514	const atom_ptr = self.atom(atom_index) orelse continue;
512	if (!atom.flags.alive) continue;	515	if (!atom_ptr.flags.alive) continue;
513	const shdr = atom.inputShdr(elf_file);	516	const shdr = atom_ptr.inputShdr(elf_file);
514	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;	517	if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
515	if (shdr.sh_type == elf.SHT_NOBITS) continue;	518	if (shdr.sh_type == elf.SHT_NOBITS) continue;
516	if (atom.scanRelocsRequiresCode(elf_file)) {	519	if (atom_ptr.scanRelocsRequiresCode(elf_file)) {
517	// TODO ideally, we don't have to decompress at this stage (should already be done)	520	// TODO ideally, we don't have to decompress at this stage (should already be done)
518	// and we just fetch the code slice.	521	// and we just fetch the code slice.
519	const code = try self.codeDecompressAlloc(elf_file, atom_index);	522	const code = try self.codeDecompressAlloc(elf_file, atom_index);
520	defer gpa.free(code);	523	defer gpa.free(code);
521	try atom.scanRelocs(elf_file, code, undefs);	524	try atom_ptr.scanRelocs(elf_file, code, undefs);
522	} else try atom.scanRelocs(elf_file, null, undefs);	525	} else try atom_ptr.scanRelocs(elf_file, null, undefs);
523	}	526	}
524		527
525	for (self.cies.items) \|cie\| {	528	for (self.cies.items) \|cie\| {
...	@@ -547,19 +550,21 @@ pub fn resolveSymbols(self: Object, elf_file: Elf) void {	...	@@ -547,19 +550,21 @@ pub fn resolveSymbols(self: Object, elf_file: Elf) void {
547	if (esym.st_shndx == elf.SHN_UNDEF) continue;	550	if (esym.st_shndx == elf.SHN_UNDEF) continue;
548		551
549	if (esym.st_shndx != elf.SHN_ABS and esym.st_shndx != elf.SHN_COMMON) {	552	if (esym.st_shndx != elf.SHN_ABS and esym.st_shndx != elf.SHN_COMMON) {
550	const atom_index = self.atoms.items[esym.st_shndx];	553	const atom_index = self.atoms_indexes.items[esym.st_shndx];
551	const atom = elf_file.atom(atom_index) orelse continue;	554	const atom_ptr = self.atom(atom_index) orelse continue;
552	if (!atom.flags.alive) continue;	555	if (!atom_ptr.flags.alive) continue;
553	}	556	}
554		557
555	const global = elf_file.symbol(index);	558	const global = elf_file.symbol(index);
556	if (self.asFile().symbolRank(esym, !self.alive) < global.symbolRank(elf_file)) {	559	if (self.asFile().symbolRank(esym, !self.alive) < global.symbolRank(elf_file)) {
557	const atom_index = switch (esym.st_shndx) {	560	switch (esym.st_shndx) {
558	elf.SHN_ABS, elf.SHN_COMMON => 0,	561	elf.SHN_ABS, elf.SHN_COMMON => {},
559	else => self.atoms.items[esym.st_shndx],	562	else => global.atom_ref = .{
560	};	563	.index = self.atoms_indexes.items[esym.st_shndx],
		564	.file = self.index,
		565	},
		566	}
561	global.value = @intCast(esym.st_value);	567	global.value = @intCast(esym.st_value);
562	global.atom_index = atom_index;
563	global.esym_index = esym_index;	568	global.esym_index = esym_index;
564	global.file_index = self.index;	569	global.file_index = self.index;
565	global.version_index = elf_file.default_sym_version;	570	global.version_index = elf_file.default_sym_version;
...	@@ -588,7 +593,7 @@ pub fn claimUnresolved(self: Object, elf_file: Elf) void {	...	@@ -588,7 +593,7 @@ pub fn claimUnresolved(self: Object, elf_file: Elf) void {
588	};	593	};
589		594
590	global.value = 0;	595	global.value = 0;
591	global.atom_index = 0;	596	global.atom_ref = .{ .index = 0, .file = 0 };
592	global.esym_index = esym_index;	597	global.esym_index = esym_index;
593	global.file_index = self.index;	598	global.file_index = self.index;
594	global.version_index = if (is_import) elf.VER_NDX_LOCAL else elf_file.default_sym_version;	599	global.version_index = if (is_import) elf.VER_NDX_LOCAL else elf_file.default_sym_version;
...	@@ -609,7 +614,7 @@ pub fn claimUnresolvedObject(self: Object, elf_file: Elf) void {	...	@@ -609,7 +614,7 @@ pub fn claimUnresolvedObject(self: Object, elf_file: Elf) void {
609	}	614	}
610		615
611	global.value = 0;	616	global.value = 0;
612	global.atom_index = 0;	617	global.atom_ref = .{ .index = 0, .file = 0 };
613	global.esym_index = esym_index;	618	global.esym_index = esym_index;
614	global.file_index = self.index;	619	global.file_index = self.index;
615	}	620	}
...	@@ -633,13 +638,13 @@ pub fn markLive(self: Object, elf_file: Elf) void {	...	@@ -633,13 +638,13 @@ pub fn markLive(self: Object, elf_file: Elf) void {
633	}	638	}
634	}	639	}
635		640
636	pub fn markEhFrameAtomsDead(self: Object, elf_file: *Elf) void {	641	pub fn markEhFrameAtomsDead(self: Object, elf_file: Elf) void {
637	const cpu_arch = elf_file.getTarget().cpu.arch;	642	const cpu_arch = elf_file.getTarget().cpu.arch;
638	for (self.atoms.items) \|atom_index\| {	643	for (self.atoms_indexes.items) \|atom_index\| {
639	const atom = elf_file.atom(atom_index) orelse continue;	644	const atom_ptr = self.atom(atom_index) orelse continue;
640	const is_eh_frame = (cpu_arch == .x86_64 and atom.inputShdr(elf_file).sh_type == elf.SHT_X86_64_UNWIND) or	645	const is_eh_frame = (cpu_arch == .x86_64 and atom_ptr.inputShdr(elf_file).sh_type == elf.SHT_X86_64_UNWIND) or
641	mem.eql(u8, atom.name(elf_file), ".eh_frame");	646	mem.eql(u8, atom_ptr.name(elf_file), ".eh_frame");
642	if (atom.flags.alive and is_eh_frame) atom.flags.alive = false;	647	if (atom_ptr.flags.alive and is_eh_frame) atom_ptr.flags.alive = false;
643	}	648	}
644	}	649	}
645		650
...	@@ -657,9 +662,9 @@ pub fn checkDuplicates(self: Object, dupes: anytype, elf_file: Elf) error{OutO	...	@@ -657,9 +662,9 @@ pub fn checkDuplicates(self: Object, dupes: anytype, elf_file: Elf) error{OutO
657	sym.st_shndx == elf.SHN_COMMON) continue;	662	sym.st_shndx == elf.SHN_COMMON) continue;
658		663
659	if (sym.st_shndx != elf.SHN_ABS) {	664	if (sym.st_shndx != elf.SHN_ABS) {
660	const atom_index = self.atoms.items[sym.st_shndx];	665	const atom_index = self.atoms_indexes.items[sym.st_shndx];
661	const atom = elf_file.atom(atom_index) orelse continue;	666	const atom_ptr = self.atom(atom_index) orelse continue;
662	if (!atom.flags.alive) continue;	667	if (!atom_ptr.flags.alive) continue;
663	}	668	}
664		669
665	const gop = try dupes.getOrPut(index);	670	const gop = try dupes.getOrPut(index);
...	@@ -680,8 +685,8 @@ pub fn initMergeSections(self: Object, elf_file: Elf) !void {	...	@@ -680,8 +685,8 @@ pub fn initMergeSections(self: Object, elf_file: Elf) !void {
680	for (self.shdrs.items, 0..) \|shdr, shndx\| {	685	for (self.shdrs.items, 0..) \|shdr, shndx\| {
681	if (shdr.sh_flags & elf.SHF_MERGE == 0) continue;	686	if (shdr.sh_flags & elf.SHF_MERGE == 0) continue;
682		687
683	const atom_index = self.atoms.items[shndx];	688	const atom_index = self.atoms_indexes.items[shndx];
684	const atom_ptr = elf_file.atom(atom_index) orelse continue;	689	const atom_ptr = self.atom(atom_index) orelse continue;
685	if (!atom_ptr.flags.alive) continue;	690	if (!atom_ptr.flags.alive) continue;
686	if (atom_ptr.relocs(elf_file).len > 0) continue;	691	if (atom_ptr.relocs(elf_file).len > 0) continue;
687		692
...	@@ -755,7 +760,7 @@ pub fn resolveMergeSubsections(self: Object, elf_file: Elf) !void {	...	@@ -755,7 +760,7 @@ pub fn resolveMergeSubsections(self: Object, elf_file: Elf) !void {
755	const imsec = self.inputMergeSection(index) orelse continue;	760	const imsec = self.inputMergeSection(index) orelse continue;
756	if (imsec.offsets.items.len == 0) continue;	761	if (imsec.offsets.items.len == 0) continue;
757	const msec = elf_file.mergeSection(imsec.merge_section_index);	762	const msec = elf_file.mergeSection(imsec.merge_section_index);
758	const atom_ptr = elf_file.atom(imsec.atom_index).?;	763	const atom_ptr = self.atom(imsec.atom_index).?;
759	const isec = atom_ptr.inputShdr(elf_file);	764	const isec = atom_ptr.inputShdr(elf_file);
760		765
761	try imsec.subsections.resize(gpa, imsec.strings.items.len);	766	try imsec.subsections.resize(gpa, imsec.strings.items.len);
...	@@ -802,10 +807,10 @@ pub fn resolveMergeSubsections(self: Object, elf_file: Elf) !void {	...	@@ -802,10 +807,10 @@ pub fn resolveMergeSubsections(self: Object, elf_file: Elf) !void {
802	sym.value = offset;	807	sym.value = offset;
803	}	808	}
804		809
805	for (self.atoms.items) \|atom_index\| {	810	for (self.atoms_indexes.items) \|atom_index\| {
806	const atom_ptr = elf_file.atom(atom_index) orelse continue;	811	const atom_ptr = self.atom(atom_index) orelse continue;
807	if (!atom_ptr.flags.alive) continue;	812	if (!atom_ptr.flags.alive) continue;
808	const extras = atom_ptr.extra(elf_file) orelse continue;	813	const extras = atom_ptr.extra(elf_file);
809	const relocs = self.relocs.items[extras.rel_index..][0..extras.rel_count];	814	const relocs = self.relocs.items[extras.rel_index..][0..extras.rel_count];
810	for (relocs) \|*rel\| {	815	for (relocs) \|*rel\| {
811	const esym = self.symtab.items[rel.r_sym()];	816	const esym = self.symtab.items[rel.r_sym()];
...	@@ -867,21 +872,10 @@ pub fn convertCommonSymbols(self: Object, elf_file: Elf) !void {	...	@@ -867,21 +872,10 @@ pub fn convertCommonSymbols(self: Object, elf_file: Elf) !void {
867	const comp = elf_file.base.comp;	872	const comp = elf_file.base.comp;
868	const gpa = comp.gpa;	873	const gpa = comp.gpa;
869		874
870	const atom_index = try elf_file.addAtom();
871	try self.atoms.append(gpa, atom_index);
872
873	const is_tls = global.type(elf_file) == elf.STT_TLS;	875	const is_tls = global.type(elf_file) == elf.STT_TLS;
874	const name = if (is_tls) ".tls_common" else ".common";	876	const name = if (is_tls) ".tls_common" else ".common";
875
876	const atom = elf_file.atom(atom_index).?;
877	const name_offset = @as(u32, @intCast(self.strtab.items.len));	877	const name_offset = @as(u32, @intCast(self.strtab.items.len));
878	try self.strtab.writer(gpa).print("{s}\x00", .{name});	878	try self.strtab.writer(gpa).print("{s}\x00", .{name});
879	atom.atom_index = atom_index;
880	atom.name_offset = name_offset;
881	atom.file_index = self.index;
882	atom.size = this_sym.st_size;
883	const alignment = this_sym.st_value;
884	atom.alignment = Alignment.fromNonzeroByteUnits(alignment);
885		879
886	var sh_flags: u32 = elf.SHF_ALLOC \| elf.SHF_WRITE;	880	var sh_flags: u32 = elf.SHF_ALLOC \| elf.SHF_WRITE;
887	if (is_tls) sh_flags \|= elf.SHF_TLS;	881	if (is_tls) sh_flags \|= elf.SHF_TLS;
...	@@ -897,38 +891,45 @@ pub fn convertCommonSymbols(self: Object, elf_file: Elf) !void {	...	@@ -897,38 +891,45 @@ pub fn convertCommonSymbols(self: Object, elf_file: Elf) !void {
897	.sh_size = sh_size,	891	.sh_size = sh_size,
898	.sh_link = 0,	892	.sh_link = 0,
899	.sh_info = 0,	893	.sh_info = 0,
900	.sh_addralign = alignment,	894	.sh_addralign = this_sym.st_value,
901	.sh_entsize = 0,	895	.sh_entsize = 0,
902	};	896	};
903	atom.input_section_index = shndx;	897
		898	const atom_index = try self.addAtom(gpa, .{
		899	.name = name_offset,
		900	.shndx = shndx,
		901	.size = this_sym.st_size,
		902	.alignment = Alignment.fromNonzeroByteUnits(this_sym.st_value),
		903	});
		904	try self.atoms_indexes.append(gpa, atom_index);
904		905
905	global.value = 0;	906	global.value = 0;
906	global.atom_index = atom_index;	907	global.atom_ref = .{ .index = atom_index, .file = self.index };
907	global.flags.weak = false;	908	global.flags.weak = false;
908	}	909	}
909	}	910	}
910		911
911	pub fn initOutputSections(self: Object, elf_file: *Elf) !void {	912	pub fn initOutputSections(self: Object, elf_file: Elf) !void {
912	for (self.atoms.items) \|atom_index\| {	913	for (self.atoms_indexes.items) \|atom_index\| {
913	const atom = elf_file.atom(atom_index) orelse continue;	914	const atom_ptr = self.atom(atom_index) orelse continue;
914	if (!atom.flags.alive) continue;	915	if (!atom_ptr.flags.alive) continue;
915	const shdr = atom.inputShdr(elf_file);	916	const shdr = atom_ptr.inputShdr(elf_file);
916	_ = try self.initOutputSection(elf_file, shdr);	917	_ = try self.initOutputSection(elf_file, shdr);
917	}	918	}
918	}	919	}
919		920
920	pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {	921	pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {
921	for (self.atoms.items) \|atom_index\| {	922	for (self.atoms_indexes.items) \|atom_index\| {
922	const atom = elf_file.atom(atom_index) orelse continue;	923	const atom_ptr = self.atom(atom_index) orelse continue;
923	if (!atom.flags.alive) continue;	924	if (!atom_ptr.flags.alive) continue;
924	const shdr = atom.inputShdr(elf_file);	925	const shdr = atom_ptr.inputShdr(elf_file);
925	atom.output_section_index = self.initOutputSection(elf_file, shdr) catch unreachable;	926	atom_ptr.output_section_index = self.initOutputSection(elf_file, shdr) catch unreachable;
926		927
927	const comp = elf_file.base.comp;	928	const comp = elf_file.base.comp;
928	const gpa = comp.gpa;	929	const gpa = comp.gpa;
929	const gop = try elf_file.output_sections.getOrPut(gpa, atom.output_section_index);	930	const gop = try elf_file.output_sections.getOrPut(gpa, atom_ptr.output_section_index);
930	if (!gop.found_existing) gop.value_ptr.* = .{};	931	if (!gop.found_existing) gop.value_ptr.* = .{};
931	try gop.value_ptr.append(gpa, atom_index);	932	try gop.value_ptr.append(gpa, .{ .index = atom_index, .file = self.index });
932	}	933	}
933		934
934	for (self.locals()) \|local_index\| {	935	for (self.locals()) \|local_index\| {
...	@@ -938,9 +939,9 @@ pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {	...	@@ -938,9 +939,9 @@ pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {
938	local.output_section_index = msub.mergeSection(elf_file).output_section_index;	939	local.output_section_index = msub.mergeSection(elf_file).output_section_index;
939	continue;	940	continue;
940	}	941	}
941	const atom = local.atom(elf_file) orelse continue;	942	const atom_ptr = local.atom(elf_file) orelse continue;
942	if (!atom.flags.alive) continue;	943	if (!atom_ptr.flags.alive) continue;
943	local.output_section_index = atom.output_section_index;	944	local.output_section_index = atom_ptr.output_section_index;
944	}	945	}
945		946
946	for (self.globals()) \|global_index\| {	947	for (self.globals()) \|global_index\| {
...	@@ -951,9 +952,9 @@ pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {	...	@@ -951,9 +952,9 @@ pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {
951	global.output_section_index = msub.mergeSection(elf_file).output_section_index;	952	global.output_section_index = msub.mergeSection(elf_file).output_section_index;
952	continue;	953	continue;
953	}	954	}
954	const atom = global.atom(elf_file) orelse continue;	955	const atom_ptr = global.atom(elf_file) orelse continue;
955	if (!atom.flags.alive) continue;	956	if (!atom_ptr.flags.alive) continue;
956	global.output_section_index = atom.output_section_index;	957	global.output_section_index = atom_ptr.output_section_index;
957	}	958	}
958		959
959	for (self.symbols.items[self.symtab.items.len..]) \|local_index\| {	960	for (self.symbols.items[self.symtab.items.len..]) \|local_index\| {
...	@@ -964,11 +965,11 @@ pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {	...	@@ -964,11 +965,11 @@ pub fn addAtomsToOutputSections(self: Object, elf_file: Elf) !void {
964	}	965	}
965	}	966	}
966		967
967	pub fn initRelaSections(self: Object, elf_file: *Elf) !void {	968	pub fn initRelaSections(self: Object, elf_file: Elf) !void {
968	for (self.atoms.items) \|atom_index\| {	969	for (self.atoms_indexes.items) \|atom_index\| {
969	const atom = elf_file.atom(atom_index) orelse continue;	970	const atom_ptr = self.atom(atom_index) orelse continue;
970	if (!atom.flags.alive) continue;	971	if (!atom_ptr.flags.alive) continue;
971	const shndx = atom.relocsShndx() orelse continue;	972	const shndx = atom_ptr.relocsShndx() orelse continue;
972	const shdr = self.shdrs.items[shndx];	973	const shdr = self.shdrs.items[shndx];
973	const out_shndx = try self.initOutputSection(elf_file, shdr);	974	const out_shndx = try self.initOutputSection(elf_file, shdr);
974	const out_shdr = &elf_file.shdrs.items[out_shndx];	975	const out_shdr = &elf_file.shdrs.items[out_shndx];
...	@@ -978,24 +979,24 @@ pub fn initRelaSections(self: Object, elf_file: *Elf) !void {	...	@@ -978,24 +979,24 @@ pub fn initRelaSections(self: Object, elf_file: *Elf) !void {
978	}	979	}
979	}	980	}
980		981
981	pub fn addAtomsToRelaSections(self: Object, elf_file: *Elf) !void {	982	pub fn addAtomsToRelaSections(self: Object, elf_file: Elf) !void {
982	for (self.atoms.items) \|atom_index\| {	983	for (self.atoms_indexes.items) \|atom_index\| {
983	const atom = elf_file.atom(atom_index) orelse continue;	984	const atom_ptr = self.atom(atom_index) orelse continue;
984	if (!atom.flags.alive) continue;	985	if (!atom_ptr.flags.alive) continue;
985	const shndx = blk: {	986	const shndx = blk: {
986	const shndx = atom.relocsShndx() orelse continue;	987	const shndx = atom_ptr.relocsShndx() orelse continue;
987	const shdr = self.shdrs.items[shndx];	988	const shdr = self.shdrs.items[shndx];
988	break :blk self.initOutputSection(elf_file, shdr) catch unreachable;	989	break :blk self.initOutputSection(elf_file, shdr) catch unreachable;
989	};	990	};
990	const shdr = &elf_file.shdrs.items[shndx];	991	const shdr = &elf_file.shdrs.items[shndx];
991	shdr.sh_info = atom.outputShndx().?;	992	shdr.sh_info = atom_ptr.outputShndx().?;
992	shdr.sh_link = elf_file.symtab_section_index.?;	993	shdr.sh_link = elf_file.symtab_section_index.?;
993		994
994	const comp = elf_file.base.comp;	995	const comp = elf_file.base.comp;
995	const gpa = comp.gpa;	996	const gpa = comp.gpa;
996	const gop = try elf_file.output_rela_sections.getOrPut(gpa, atom.outputShndx().?);	997	const gop = try elf_file.output_rela_sections.getOrPut(gpa, atom_ptr.outputShndx().?);
997	if (!gop.found_existing) gop.value_ptr.* = .{ .shndx = shndx };	998	if (!gop.found_existing) gop.value_ptr.* = .{ .shndx = shndx };
998	try gop.value_ptr.atom_list.append(gpa, atom_index);	999	try gop.value_ptr.atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
999	}	1000	}
1000	}	1001	}
1001		1002
...	@@ -1129,11 +1130,10 @@ pub fn globals(self: Object) []const Symbol.Index {	...	@@ -1129,11 +1130,10 @@ pub fn globals(self: Object) []const Symbol.Index {
1129		1130
1130	/// Returns atom's code and optionally uncompresses data if required (for compressed sections).	1131	/// Returns atom's code and optionally uncompresses data if required (for compressed sections).
1131	/// Caller owns the memory.	1132	/// Caller owns the memory.
1132	pub fn codeDecompressAlloc(self: Object, elf_file: *Elf, atom_index: Atom.Index) ![]u8 {	1133	pub fn codeDecompressAlloc(self: Object, elf_file: Elf, atom_index: Atom.Index) ![]u8 {
1133	const comp = elf_file.base.comp;	1134	const comp = elf_file.base.comp;
1134	const gpa = comp.gpa;	1135	const gpa = comp.gpa;
1135	const atom_ptr = elf_file.atom(atom_index).?;	1136	const atom_ptr = self.atom(atom_index).?;
1136	assert(atom_ptr.file_index == self.index);
1137	const shdr = atom_ptr.inputShdr(elf_file);	1137	const shdr = atom_ptr.inputShdr(elf_file);
1138	const handle = elf_file.fileHandle(self.file_handle);	1138	const handle = elf_file.fileHandle(self.file_handle);
1139	const data = try self.preadShdrContentsAlloc(gpa, handle, atom_ptr.input_section_index);	1139	const data = try self.preadShdrContentsAlloc(gpa, handle, atom_ptr.input_section_index);
...	@@ -1194,6 +1194,82 @@ fn preadRelocsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, shn	...	@@ -1194,6 +1194,82 @@ fn preadRelocsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, shn
1194	return @as([*]align(1) const elf.Elf64_Rela, @ptrCast(raw.ptr))[0..num];	1194	return @as([*]align(1) const elf.Elf64_Rela, @ptrCast(raw.ptr))[0..num];
1195	}	1195	}
1196		1196
		1197	const AddAtomArgs = struct {
		1198	name: u32,
		1199	shndx: u32,
		1200	size: u64,
		1201	alignment: Alignment,
		1202	};
		1203
		1204	fn addAtom(self: *Object, allocator: Allocator, args: AddAtomArgs) !Atom.Index {
		1205	try self.atoms.ensureUnusedCapacity(allocator, 1);
		1206	try self.atoms_extra.ensureUnusedCapacity(allocator, @sizeOf(Atom.Extra));
		1207	return self.addAtomAssumeCapacity(args);
		1208	}
		1209
		1210	fn addAtomAssumeCapacity(self: *Object, args: AddAtomArgs) Atom.Index {
		1211	const atom_index: Atom.Index = @intCast(self.atoms.items.len);
		1212	const atom_ptr = self.atoms.addOneAssumeCapacity();
		1213	atom_ptr.* = .{
		1214	.atom_index = atom_index,
		1215	.name_offset = args.name,
		1216	.file_index = self.index,
		1217	.input_section_index = args.shndx,
		1218	.extra_index = self.addAtomExtraAssumeCapacity(.{}),
		1219	.size = args.size,
		1220	.alignment = args.alignment,
		1221	};
		1222	return atom_index;
		1223	}
		1224
		1225	pub fn atom(self: Object, atom_index: Atom.Index) ?Atom {
		1226	if (atom_index == 0) return null;
		1227	assert(atom_index < self.atoms.items.len);
		1228	return &self.atoms.items[atom_index];
		1229	}
		1230
		1231	pub fn addAtomExtra(self: *Object, allocator: Allocator, extra: Atom.Extra) !u32 {
		1232	const fields = @typeInfo(Atom.Extra).Struct.fields;
		1233	try self.atoms_extra.ensureUnusedCapacity(allocator, fields.len);
		1234	return self.addAtomExtraAssumeCapacity(extra);
		1235	}
		1236
		1237	pub fn addAtomExtraAssumeCapacity(self: *Object, extra: Atom.Extra) u32 {
		1238	const index = @as(u32, @intCast(self.atoms_extra.items.len));
		1239	const fields = @typeInfo(Atom.Extra).Struct.fields;
		1240	inline for (fields) \|field\| {
		1241	self.atoms_extra.appendAssumeCapacity(switch (field.type) {
		1242	u32 => @field(extra, field.name),
		1243	else => @compileError("bad field type"),
		1244	});
		1245	}
		1246	return index;
		1247	}
		1248
		1249	pub fn atomExtra(self: *Object, index: u32) Atom.Extra {
		1250	const fields = @typeInfo(Atom.Extra).Struct.fields;
		1251	var i: usize = index;
		1252	var result: Atom.Extra = undefined;
		1253	inline for (fields) \|field\| {
		1254	@field(result, field.name) = switch (field.type) {
		1255	u32 => self.atoms_extra.items[i],
		1256	else => @compileError("bad field type"),
		1257	};
		1258	i += 1;
		1259	}
		1260	return result;
		1261	}
		1262
		1263	pub fn setAtomExtra(self: *Object, index: u32, extra: Atom.Extra) void {
		1264	const fields = @typeInfo(Atom.Extra).Struct.fields;
		1265	inline for (fields, 0..) \|field, i\| {
		1266	self.atoms_extra.items[index + i] = switch (field.type) {
		1267	u32 => @field(extra, field.name),
		1268	else => @compileError("bad field type"),
		1269	};
		1270	}
		1271	}
		1272
1197	fn addInputMergeSection(self: *Object, allocator: Allocator) !InputMergeSection.Index {	1273	fn addInputMergeSection(self: *Object, allocator: Allocator) !InputMergeSection.Index {
1198	const index: InputMergeSection.Index = @intCast(self.input_merge_sections.items.len);	1274	const index: InputMergeSection.Index = @intCast(self.input_merge_sections.items.len);
1199	const msec = try self.input_merge_sections.addOne(allocator);	1275	const msec = try self.input_merge_sections.addOne(allocator);
...	@@ -1280,9 +1356,9 @@ fn formatAtoms(	...	@@ -1280,9 +1356,9 @@ fn formatAtoms(
1280	_ = options;	1356	_ = options;
1281	const object = ctx.object;	1357	const object = ctx.object;
1282	try writer.writeAll(" atoms\n");	1358	try writer.writeAll(" atoms\n");
1283	for (object.atoms.items) \|atom_index\| {	1359	for (object.atoms_indexes.items) \|atom_index\| {
1284	const atom = ctx.elf_file.atom(atom_index) orelse continue;	1360	const atom_ptr = object.atom(atom_index) orelse continue;
1285	try writer.print(" {}\n", .{atom.fmt(ctx.elf_file)});	1361	try writer.print(" {}\n", .{atom_ptr.fmt(ctx.elf_file)});
1286	}	1362	}
1287	}	1363	}
1288		1364
...	@@ -1354,9 +1430,9 @@ fn formatComdatGroups(	...	@@ -1354,9 +1430,9 @@ fn formatComdatGroups(
1354	try writer.print(" COMDAT({d})\n", .{cg_index});	1430	try writer.print(" COMDAT({d})\n", .{cg_index});
1355	const cg_members = cg.comdatGroupMembers(elf_file);	1431	const cg_members = cg.comdatGroupMembers(elf_file);
1356	for (cg_members) \|shndx\| {	1432	for (cg_members) \|shndx\| {
1357	const atom_index = object.atoms.items[shndx];	1433	const atom_index = object.atoms_indexes.items[shndx];
1358	const atom = elf_file.atom(atom_index) orelse continue;	1434	const atom_ptr = object.atom(atom_index) orelse continue;
1359	try writer.print(" atom({d}) : {s}\n", .{ atom_index, atom.name(elf_file) });	1435	try writer.print(" atom({d}) : {s}\n", .{ atom_index, atom_ptr.name(elf_file) });
1360	}	1436	}
1361	}	1437	}
1362	}	1438	}

src/link/Elf/SharedObject.zig+1-1

...	@@ -232,7 +232,7 @@ pub fn resolveSymbols(self: SharedObject, elf_file: Elf) void {	...	@@ -232,7 +232,7 @@ pub fn resolveSymbols(self: SharedObject, elf_file: Elf) void {
232	const global = elf_file.symbol(index);	232	const global = elf_file.symbol(index);
233	if (self.asFile().symbolRank(this_sym, false) < global.symbolRank(elf_file)) {	233	if (self.asFile().symbolRank(this_sym, false) < global.symbolRank(elf_file)) {
234	global.value = @intCast(this_sym.st_value);	234	global.value = @intCast(this_sym.st_value);
235	global.atom_index = 0;	235	global.atom_ref = .{ .index = 0, .file = 0 };
236	global.esym_index = esym_index;	236	global.esym_index = esym_index;
237	global.version_index = self.versyms.items[esym_index];	237	global.version_index = self.versyms.items[esym_index];
238	global.file_index = self.index;	238	global.file_index = self.index;

src/link/Elf/Symbol.zig+4-4

 @@ -9,10 +9,9 @@ name_offset: u32 = 0,
 /// Index of file where this symbol is defined.
 file_index: File.Index = 0,
-/// Index of atom containing this symbol.
+/// Reference to Atom containing this symbol if any.
-/// Index of 0 means there is no associated atom with this symbol.
 /// Use `atom` to get the pointer to the atom.
-atom_index: Atom.Index = 0,
+atom_ref: Elf.Ref = .{ .index = 0, .file = 0 },
 /// Assigned output section index for this symbol.
 output_section_index: u32 = 0,
 @@ -68,7 +67,8 @@ pub fn name(symbol: Symbol, elf_file: *Elf) [:0]const u8 {
 }
 pub fn atom(symbol: Symbol, elf_file: *Elf) ?*Atom {
-    return elf_file.atom(symbol.atom_index);
+    const file_ptr = elf_file.file(symbol.atom_ref.file) orelse return null;
+    return file_ptr.atom(symbol.atom_ref.index);
 }
 pub fn mergeSubsection(symbol: Symbol, elf_file: *Elf) ?*MergeSubsection {

src/link/Elf/ZigObject.zig+124-61

 @@ -15,7 +15,9 @@ local_symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},
 global_symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},
 globals_lookup: std.AutoHashMapUnmanaged(u32, Symbol.Index) = .{},
-atoms: std.ArrayListUnmanaged(Atom.Index) = .{},
+atoms: std.ArrayListUnmanaged(Atom) = .{},
+atoms_indexes: std.ArrayListUnmanaged(Atom.Index) = .{},
+atoms_extra: std.ArrayListUnmanaged(u32) = .{},
 relocs: std.ArrayListUnmanaged(std.ArrayListUnmanaged(elf.Elf64_Rela)) = .{},
 num_dynrelocs: u32 = 0,
 @@ -80,7 +82,7 @@ pub fn init(self: *ZigObject, elf_file: *Elf) !void {
     const comp = elf_file.base.comp;
     const gpa = comp.gpa;
-    try self.atoms.append(gpa, 0); // null input section
+    try self.atoms.append(gpa, .{ .extra_index = try self.addAtomExtra(gpa, .{}) }); // null input section
     try self.relocs.append(gpa, .{}); // null relocs section
     try self.strtab.buffer.append(gpa, 0);
 @@ -117,6 +119,8 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {
     self.global_symbols.deinit(allocator);
     self.globals_lookup.deinit(allocator);
     self.atoms.deinit(allocator);
+    self.atoms_indexes.deinit(allocator);
+    self.atoms_extra.deinit(allocator);
     for (self.relocs.items) |*list| {
         list.deinit(allocator);
     }
 @@ -276,24 +280,20 @@ pub fn addGlobalEsym(self: *ZigObject, allocator: Allocator) !Symbol.Index {
     return index | global_symbol_bit;
 }
-pub fn addAtom(self: *ZigObject, elf_file: *Elf) !Symbol.Index {
+pub fn newAtom(self: *ZigObject, elf_file: *Elf) !Symbol.Index {
     const gpa = elf_file.base.comp.gpa;
-    const atom_index = try elf_file.addAtom();
+    const atom_index = try self.addAtom(gpa);
     const symbol_index = try elf_file.addSymbol();
     const esym_index = try self.addLocalEsym(gpa);
-    const shndx = @as(u32, @intCast(self.atoms.items.len));
+    try self.atoms_indexes.append(gpa, atom_index);
-    try self.atoms.append(gpa, atom_index);
     try self.local_symbols.append(gpa, symbol_index);
-    const atom_ptr = elf_file.atom(atom_index).?;
-    atom_ptr.file_index = self.index;
     const symbol_ptr = elf_file.symbol(symbol_index);
     symbol_ptr.file_index = self.index;
-    symbol_ptr.atom_index = atom_index;
+    symbol_ptr.atom_ref = .{ .index = atom_index, .file = self.index };
-    self.local_esyms.items(.shndx)[esym_index] = shndx;
+    self.local_esyms.items(.shndx)[esym_index] = atom_index;
     self.local_esyms.items(.elf_sym)[esym_index].st_shndx = SHN_ATOM;
     symbol_ptr.esym_index = esym_index;
 @@ -301,21 +301,22 @@ pub fn addAtom(self: *ZigObject, elf_file: *Elf) !Symbol.Index {
     const relocs_index = @as(u32, @intCast(self.relocs.items.len));
     const relocs = try self.relocs.addOne(gpa);
     relocs.* = .{};
+    const atom_ptr = self.atom(atom_index).?;
     atom_ptr.relocs_section_index = relocs_index;
     return symbol_index;
 }
 /// TODO actually create fake input shdrs and return that instead.
-pub fn inputShdr(self: ZigObject, atom_index: Atom.Index, elf_file: *Elf) elf.Elf64_Shdr {
+pub fn inputShdr(self: *ZigObject, atom_index: Atom.Index, elf_file: *Elf) elf.Elf64_Shdr {
-    _ = self;
+    const atom_ptr = self.atom(atom_index) orelse return Elf.null_shdr;
-    const atom = elf_file.atom(atom_index) orelse return Elf.null_shdr;
+    const shndx = atom_ptr.outputShndx() orelse return Elf.null_shdr;
-    const shndx = atom.outputShndx() orelse return Elf.null_shdr;
     var shdr = elf_file.shdrs.items[shndx];
     shdr.sh_addr = 0;
     shdr.sh_offset = 0;
-    shdr.sh_size = atom.size;
+    shdr.sh_size = atom_ptr.size;
-    shdr.sh_addralign = atom.alignment.toByteUnits() orelse 1;
+    shdr.sh_addralign = atom_ptr.alignment.toByteUnits() orelse 1;
     return shdr;
 }
 @@ -329,24 +330,23 @@ pub fn resolveSymbols(self: *ZigObject, elf_file: *Elf) void {
         if (esym.st_shndx != elf.SHN_ABS and esym.st_shndx != elf.SHN_COMMON) {
             assert(esym.st_shndx == SHN_ATOM);
-            const atom_index = self.atoms.items[shndx];
+            const atom_ptr = self.atom(shndx) orelse continue;
-            const atom = elf_file.atom(atom_index) orelse continue;
+            if (!atom_ptr.flags.alive) continue;
-            if (!atom.flags.alive) continue;
         }
         const global = elf_file.symbol(index);
         if (self.asFile().symbolRank(esym, false) < global.symbolRank(elf_file)) {
             const atom_index = switch (esym.st_shndx) {
                 elf.SHN_ABS, elf.SHN_COMMON => 0,
-                SHN_ATOM => self.atoms.items[shndx],
+                SHN_ATOM => shndx,
                 else => unreachable,
             };
-            const output_section_index = if (elf_file.atom(atom_index)) |atom|
+            const output_section_index = if (self.atom(atom_index)) |atom_ptr|
-                atom.outputShndx().?
+                atom_ptr.outputShndx().?
             else
                 elf.SHN_UNDEF;
             global.value = @intCast(esym.st_value);
-            global.atom_index = atom_index;
+            global.atom_ref = .{ .index = atom_index, .file = self.index };
             global.esym_index = esym_index;
             global.file_index = self.index;
             global.output_section_index = output_section_index;
 @@ -376,7 +376,7 @@ pub fn claimUnresolved(self: ZigObject, elf_file: *Elf) void {
         };
         global.value = 0;
-        global.atom_index = 0;
+        global.atom_ref = .{ .index = 0, .file = 0 };
         global.esym_index = esym_index;
         global.file_index = self.index;
         global.version_index = if (is_import) elf.VER_NDX_LOCAL else elf_file.default_sym_version;
 @@ -397,7 +397,7 @@ pub fn claimUnresolvedObject(self: ZigObject, elf_file: *Elf) void {
         }
         global.value = 0;
-        global.atom_index = 0;
+        global.atom_ref = .{ .index = 0, .file = 0 };
         global.esym_index = esym_index;
         global.file_index = self.index;
     }
 @@ -405,19 +405,19 @@ pub fn claimUnresolvedObject(self: ZigObject, elf_file: *Elf) void {
 pub fn scanRelocs(self: *ZigObject, elf_file: *Elf, undefs: anytype) !void {
     const gpa = elf_file.base.comp.gpa;
-    for (self.atoms.items) |atom_index| {
+    for (self.atoms_indexes.items) |atom_index| {
-        const atom = elf_file.atom(atom_index) orelse continue;
+        const atom_ptr = self.atom(atom_index) orelse continue;
-        if (!atom.flags.alive) continue;
+        if (!atom_ptr.flags.alive) continue;
-        const shdr = atom.inputShdr(elf_file);
+        const shdr = atom_ptr.inputShdr(elf_file);
         if (shdr.sh_type == elf.SHT_NOBITS) continue;
-        if (atom.scanRelocsRequiresCode(elf_file)) {
+        if (atom_ptr.scanRelocsRequiresCode(elf_file)) {
             // TODO ideally we don't have to fetch the code here.
             // Perhaps it would make sense to save the code until flushModule where we
             // would free all of generated code?
             const code = try self.codeAlloc(elf_file, atom_index);
             defer gpa.free(code);
-            try atom.scanRelocs(elf_file, code, undefs);
+            try atom_ptr.scanRelocs(elf_file, code, undefs);
-        } else try atom.scanRelocs(elf_file, null, undefs);
+        } else try atom_ptr.scanRelocs(elf_file, null, undefs);
     }
 }
 @@ -450,9 +450,8 @@ pub fn checkDuplicates(self: *ZigObject, dupes: anytype, elf_file: *Elf) error{O
             esym.st_shndx == elf.SHN_COMMON) continue;
         if (esym.st_shndx == SHN_ATOM) {
-            const atom_index = self.atoms.items[shndx];
+            const atom_ptr = self.atom(shndx) orelse continue;
-            const atom = elf_file.atom(atom_index) orelse continue;
+            if (!atom_ptr.flags.alive) continue;
-            if (!atom.flags.alive) continue;
         }
         const gop = try dupes.getOrPut(index);
 @@ -517,20 +516,20 @@ pub fn writeAr(self: ZigObject, writer: anytype) !void {
     try writer.writeAll(self.data.items);
 }
-pub fn addAtomsToRelaSections(self: ZigObject, elf_file: *Elf) !void {
+pub fn addAtomsToRelaSections(self: *ZigObject, elf_file: *Elf) !void {
-    for (self.atoms.items) |atom_index| {
+    for (self.atoms_indexes.items) |atom_index| {
-        const atom = elf_file.atom(atom_index) orelse continue;
+        const atom_ptr = self.atom(atom_index) orelse continue;
-        if (!atom.flags.alive) continue;
+        if (!atom_ptr.flags.alive) continue;
-        const rela_shndx = atom.relocsShndx() orelse continue;
+        const rela_shndx = atom_ptr.relocsShndx() orelse continue;
         // TODO this check will become obsolete when we rework our relocs mechanism at the ZigObject level
         if (self.relocs.items[rela_shndx].items.len == 0) continue;
-        const out_shndx = atom.outputShndx().?;
+        const out_shndx = atom_ptr.outputShndx().?;
         const out_shdr = elf_file.shdrs.items[out_shndx];
         if (out_shdr.sh_type == elf.SHT_NOBITS) continue;
         const gpa = elf_file.base.comp.gpa;
         const sec = elf_file.output_rela_sections.getPtr(out_shndx).?;
-        try sec.atom_list.append(gpa, atom_index);
+        try sec.atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
     }
 }
 @@ -561,7 +560,7 @@ pub fn globals(self: ZigObject) []const Symbol.Index {
 pub fn updateSymtabSize(self: *ZigObject, elf_file: *Elf) !void {
     for (self.locals()) |local_index| {
         const local = elf_file.symbol(local_index);
-        if (local.atom(elf_file)) |atom| if (!atom.flags.alive) continue;
+        if (local.atom(elf_file)) |atom_ptr| if (!atom_ptr.flags.alive) continue;
         const esym = local.elfSym(elf_file);
         switch (esym.st_type()) {
             elf.STT_SECTION, elf.STT_NOTYPE => continue,
 @@ -577,7 +576,7 @@ pub fn updateSymtabSize(self: *ZigObject, elf_file: *Elf) !void {
         const global = elf_file.symbol(global_index);
         const file_ptr = global.file(elf_file) orelse continue;
         if (file_ptr.index() != self.index) continue;
-        if (global.atom(elf_file)) |atom| if (!atom.flags.alive) continue;
+        if (global.atom(elf_file)) |atom_ptr| if (!atom_ptr.flags.alive) continue;
         global.flags.output_symtab = true;
         if (global.isLocal(elf_file)) {
             try global.addExtra(.{ .symtab = self.output_symtab_ctx.nlocals }, elf_file);
 @@ -621,11 +620,10 @@ pub fn asFile(self: *ZigObject) File {
 /// Returns atom's code.
 /// Caller owns the memory.
-pub fn codeAlloc(self: ZigObject, elf_file: *Elf, atom_index: Atom.Index) ![]u8 {
+pub fn codeAlloc(self: *ZigObject, elf_file: *Elf, atom_index: Atom.Index) ![]u8 {
     const gpa = elf_file.base.comp.gpa;
-    const atom = elf_file.atom(atom_index).?;
+    const atom_ptr = self.atom(atom_index).?;
-    assert(atom.file_index == self.index);
+    const shdr = &elf_file.shdrs.items[atom_ptr.outputShndx().?];
-    const shdr = &elf_file.shdrs.items[atom.outputShndx().?];
     if (shdr.sh_flags & elf.SHF_TLS != 0) {
         const tlv = self.tls_variables.get(atom_index).?;
 @@ -633,13 +631,13 @@ pub fn codeAlloc(self: ZigObject, elf_file: *Elf, atom_index: Atom.Index) ![]u8
         return code;
     }
-    const file_offset = shdr.sh_offset + @as(u64, @intCast(atom.value));
+    const file_offset = shdr.sh_offset + @as(u64, @intCast(atom_ptr.value));
-    const size = std.math.cast(usize, atom.size) orelse return error.Overflow;
+    const size = std.math.cast(usize, atom_ptr.size) orelse return error.Overflow;
     const code = try gpa.alloc(u8, size);
     errdefer gpa.free(code);
     const amt = try elf_file.base.file.?.preadAll(code, file_offset);
     if (amt != code.len) {
-        log.err("fetching code for {s} failed", .{atom.name(elf_file)});
+        log.err("fetching code for {s} failed", .{atom_ptr.name(elf_file)});
         return error.InputOutput;
     }
     return code;
 @@ -760,7 +758,7 @@ pub fn getOrCreateMetadataForLazySymbol(
     };
     switch (metadata.state.*) {
         .unused => {
-            const symbol_index = try self.addAtom(elf_file);
+            const symbol_index = try self.newAtom(elf_file);
             const sym = elf_file.symbol(symbol_index);
             sym.flags.needs_zig_got = true;
             metadata.symbol_index.* = symbol_index;
 @@ -824,7 +822,7 @@ pub fn getOrCreateMetadataForDecl(
     const gop = try self.decls.getOrPut(gpa, decl_index);
     if (!gop.found_existing) {
         const any_non_single_threaded = elf_file.base.comp.config.any_non_single_threaded;
-        const symbol_index = try self.addAtom(elf_file);
+        const symbol_index = try self.newAtom(elf_file);
         const mod = elf_file.base.comp.module.?;
         const decl = mod.declPtr(decl_index);
         const sym = elf_file.symbol(symbol_index);
 @@ -1048,7 +1046,7 @@ fn updateTlv(
     {
         const gop = try elf_file.output_sections.getOrPut(gpa, atom_ptr.output_section_index);
         if (!gop.found_existing) gop.value_ptr.* = .{};
-        try gop.value_ptr.append(gpa, atom_ptr.atom_index);
+        try gop.value_ptr.append(gpa, .{ .index = atom_ptr.atom_index, .file = self.index });
     }
 }
 @@ -1307,8 +1305,7 @@ pub fn lowerUnnamedConst(
             return error.CodegenFail;
         },
     };
-    const sym = elf_file.symbol(sym_index);
+    try unnamed_consts.append(gpa, sym_index);
-    try unnamed_consts.append(gpa, sym.atom_index);
     return sym_index;
 }
 @@ -1332,7 +1329,7 @@ fn lowerConst(
     var code_buffer = std.ArrayList(u8).init(gpa);
     defer code_buffer.deinit();
-    const sym_index = try self.addAtom(elf_file);
+    const sym_index = try self.newAtom(elf_file);
     const res = try codegen.generateSymbol(
         &elf_file.base,
 @@ -1530,6 +1527,72 @@ pub fn getString(self: ZigObject, off: u32) [:0]const u8 {
     return self.strtab.getAssumeExists(off);
 }
+fn addAtom(self: *ZigObject, allocator: Allocator) !Atom.Index {
+    try self.atoms.ensureUnusedCapacity(allocator, 1);
+    try self.atoms_extra.ensureUnusedCapacity(allocator, @sizeOf(Atom.Extra));
+    return self.addAtomAssumeCapacity();
+}
+fn addAtomAssumeCapacity(self: *ZigObject) Atom.Index {
+    const atom_index: Atom.Index = @intCast(self.atoms.items.len);
+    const atom_ptr = self.atoms.addOneAssumeCapacity();
+    atom_ptr.* = .{
+        .file_index = self.index,
+        .atom_index = atom_index,
+        .extra_index = self.addAtomExtraAssumeCapacity(.{}),
+    };
+    return atom_index;
+}
+pub fn atom(self: *ZigObject, atom_index: Atom.Index) ?*Atom {
+    if (atom_index == 0) return null;
+    assert(atom_index < self.atoms.items.len);
+    return &self.atoms.items[atom_index];
+}
+fn addAtomExtra(self: *ZigObject, allocator: Allocator, extra: Atom.Extra) !u32 {
+    const fields = @typeInfo(Atom.Extra).Struct.fields;
+    try self.atoms_extra.ensureUnusedCapacity(allocator, fields.len);
+    return self.addAtomExtraAssumeCapacity(extra);
+}
+fn addAtomExtraAssumeCapacity(self: *ZigObject, extra: Atom.Extra) u32 {
+    const index = @as(u32, @intCast(self.atoms_extra.items.len));
+    const fields = @typeInfo(Atom.Extra).Struct.fields;
+    inline for (fields) |field| {
+        self.atoms_extra.appendAssumeCapacity(switch (field.type) {
+            u32 => @field(extra, field.name),
+            else => @compileError("bad field type"),
+        });
+    }
+    return index;
+}
+pub fn atomExtra(self: ZigObject, index: u32) Atom.Extra {
+    const fields = @typeInfo(Atom.Extra).Struct.fields;
+    var i: usize = index;
+    var result: Atom.Extra = undefined;
+    inline for (fields) |field| {
+        @field(result, field.name) = switch (field.type) {
+            u32 => self.atoms_extra.items[i],
+            else => @compileError("bad field type"),
+        };
+        i += 1;
+    }
+    return result;
+}
+pub fn setAtomExtra(self: *ZigObject, index: u32, extra: Atom.Extra) void {
+    assert(index > 0);
+    const fields = @typeInfo(Atom.Extra).Struct.fields;
+    inline for (fields, 0..) |field, i| {
+        self.atoms_extra.items[index + i] = switch (field.type) {
+            u32 => @field(extra, field.name),
+            else => @compileError("bad field type"),
+        };
+    }
+}
 pub fn fmtSymtab(self: *ZigObject, elf_file: *Elf) std.fmt.Formatter(formatSymtab) {
     return .{ .data = .{
         .self = self,
 @@ -1578,9 +1641,9 @@ fn formatAtoms(
     _ = unused_fmt_string;
     _ = options;
     try writer.writeAll("  atoms\n");
-    for (ctx.self.atoms.items) |atom_index| {
+    for (ctx.self.atoms_indexes.items) |atom_index| {
-        const atom = ctx.elf_file.atom(atom_index) orelse continue;
+        const atom_ptr = ctx.self.atom(atom_index) orelse continue;
-        try writer.print("    {}\n", .{atom.fmt(ctx.elf_file)});
+        try writer.print("    {}\n", .{atom_ptr.fmt(ctx.elf_file)});
     }
 }

src/link/Elf/eh_frame.zig+2-2

...	@@ -42,8 +42,8 @@ pub const Fde = struct {	...	@@ -42,8 +42,8 @@ pub const Fde = struct {
42	const object = elf_file.file(fde.file_index).?.object;	42	const object = elf_file.file(fde.file_index).?.object;
43	const rel = fde.relocs(elf_file)[0];	43	const rel = fde.relocs(elf_file)[0];
44	const sym = object.symtab.items[rel.r_sym()];	44	const sym = object.symtab.items[rel.r_sym()];
45	const atom_index = object.atoms.items[sym.st_shndx];	45	const atom_index = object.atoms_indexes.items[sym.st_shndx];
46	return elf_file.atom(atom_index).?;	46	return object.atom(atom_index).?;
47	}	47	}
48		48
49	pub fn relocs(fde: Fde, elf_file: *Elf) []align(1) const elf.Elf64_Rela {	49	pub fn relocs(fde: Fde, elf_file: *Elf) []align(1) const elf.Elf64_Rela {

src/link/Elf/file.zig+26-3

...	@@ -98,11 +98,34 @@ pub const File = union(enum) {	...	@@ -98,11 +98,34 @@ pub const File = union(enum) {
98	}	98	}
99	}	99	}
100		100
		101	pub fn atom(file: File, atom_index: Atom.Index) ?*Atom {
		102	return switch (file) {
		103	.shared_object => unreachable,
		104	.linker_defined => null,
		105	inline else => \|x\| x.atom(atom_index),
		106	};
		107	}
		108
101	pub fn atoms(file: File) []const Atom.Index {	109	pub fn atoms(file: File) []const Atom.Index {
102	return switch (file) {	110	return switch (file) {
103	.linker_defined, .shared_object => &[0]Atom.Index{},	111	.shared_object => unreachable,
104	.zig_object => \|x\| x.atoms.items,	112	.linker_defined => &[0]Atom.Index{},
105	.object => \|x\| x.atoms.items,	113	.zig_object => \|x\| x.atoms_indexes.items,
		114	.object => \|x\| x.atoms_indexes.items,
		115	};
		116	}
		117
		118	pub fn atomExtra(file: File, extra_index: u32) Atom.Extra {
		119	return switch (file) {
		120	.shared_object, .linker_defined => unreachable,
		121	inline else => \|x\| x.atomExtra(extra_index),
		122	};
		123	}
		124
		125	pub fn setAtomExtra(file: File, extra_index: u32, extra: Atom.Extra) void {
		126	return switch (file) {
		127	.shared_object, .linker_defined => unreachable,
		128	inline else => \|x\| x.setAtomExtra(extra_index, extra),
106	};	129	};
107	}	130	}
108		131

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

...	@@ -35,7 +35,7 @@ fn collectRoots(roots: std.ArrayList(Atom), files: []const File.Index, elf_fil	...	@@ -35,7 +35,7 @@ fn collectRoots(roots: std.ArrayList(Atom), files: []const File.Index, elf_fil
35	const file = elf_file.file(index).?;	35	const file = elf_file.file(index).?;
36		36
37	for (file.atoms()) \|atom_index\| {	37	for (file.atoms()) \|atom_index\| {
38	const atom = elf_file.atom(atom_index) orelse continue;	38	const atom = file.atom(atom_index) orelse continue;
39	if (!atom.flags.alive) continue;	39	if (!atom.flags.alive) continue;
40		40
41	const shdr = atom.inputShdr(elf_file);	41	const shdr = atom.inputShdr(elf_file);
...	@@ -120,8 +120,9 @@ fn mark(roots: std.ArrayList(Atom), elf_file: Elf) void {	...	@@ -120,8 +120,9 @@ fn mark(roots: std.ArrayList(Atom), elf_file: Elf) void {
120		120
121	fn prune(files: []const File.Index, elf_file: *Elf) void {	121	fn prune(files: []const File.Index, elf_file: *Elf) void {
122	for (files) \|index\| {	122	for (files) \|index\| {
123	for (elf_file.file(index).?.atoms()) \|atom_index\| {	123	const file = elf_file.file(index).?;
124	const atom = elf_file.atom(atom_index) orelse continue;	124	for (file.atoms()) \|atom_index\| {
		125	const atom = file.atom(atom_index) orelse continue;
125	if (atom.flags.alive and !atom.flags.visited) {	126	if (atom.flags.alive and !atom.flags.visited) {
126	atom.flags.alive = false;	127	atom.flags.alive = false;
127	atom.markFdesDead(elf_file);	128	atom.markFdesDead(elf_file);
...	@@ -133,8 +134,9 @@ fn prune(files: []const File.Index, elf_file: *Elf) void {	...	@@ -133,8 +134,9 @@ fn prune(files: []const File.Index, elf_file: *Elf) void {
133	pub fn dumpPrunedAtoms(elf_file: *Elf) !void {	134	pub fn dumpPrunedAtoms(elf_file: *Elf) !void {
134	const stderr = std.io.getStdErr().writer();	135	const stderr = std.io.getStdErr().writer();
135	for (elf_file.objects.items) \|index\| {	136	for (elf_file.objects.items) \|index\| {
136	for (elf_file.file(index).?.object.atoms.items) \|atom_index\| {	137	const file = elf_file.file(index).?;
137	const atom = elf_file.atom(atom_index) orelse continue;	138	for (file.atoms()) \|atom_index\| {
		139	const atom = file.atom(atom_index) orelse continue;
138	if (!atom.flags.alive)	140	if (!atom.flags.alive)
139	// TODO should we simply print to stderr?	141	// TODO should we simply print to stderr?
140	try stderr.print("link: removing unused section '{s}' in file '{}'\n", .{	142	try stderr.print("link: removing unused section '{s}' in file '{}'\n", .{

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

src/link/Elf/synthetic_sections.zig+4-4

...	@@ -1705,14 +1705,14 @@ pub const ComdatGroupSection = struct {	...	@@ -1705,14 +1705,14 @@ pub const ComdatGroupSection = struct {
1705	const shdr = object.shdrs.items[shndx];	1705	const shdr = object.shdrs.items[shndx];
1706	switch (shdr.sh_type) {	1706	switch (shdr.sh_type) {
1707	elf.SHT_RELA => {	1707	elf.SHT_RELA => {
1708	const atom_index = object.atoms.items[shdr.sh_info];	1708	const atom_index = object.atoms_indexes.items[shdr.sh_info];
1709	const atom = elf_file.atom(atom_index).?;	1709	const atom = object.atom(atom_index).?;
1710	const rela = elf_file.output_rela_sections.get(atom.outputShndx().?).?;	1710	const rela = elf_file.output_rela_sections.get(atom.outputShndx().?).?;
1711	try writer.writeInt(u32, rela.shndx, .little);	1711	try writer.writeInt(u32, rela.shndx, .little);
1712	},	1712	},
1713	else => {	1713	else => {
1714	const atom_index = object.atoms.items[shndx];	1714	const atom_index = object.atoms_indexes.items[shndx];
1715	const atom = elf_file.atom(atom_index).?;	1715	const atom = object.atom(atom_index).?;
1716	try writer.writeInt(u32, atom.outputShndx().?, .little);	1716	try writer.writeInt(u32, atom.outputShndx().?, .little);
1717	},	1717	},
1718	}	1718	}

src/link/Elf/thunks.zig+7-8

...	@@ -6,8 +6,8 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {	...	@@ -6,8 +6,8 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {
6	const atoms = elf_file.output_sections.get(shndx).?.items;	6	const atoms = elf_file.output_sections.get(shndx).?.items;
7	assert(atoms.len > 0);	7	assert(atoms.len > 0);
8		8
9	for (atoms) \|atom_index\| {	9	for (atoms) \|ref\| {
10	elf_file.atom(atom_index).?.value = -1;	10	elf_file.atom(ref).?.value = -1;
11	}	11	}
12		12
13	var i: usize = 0;	13	var i: usize = 0;
...	@@ -19,8 +19,7 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {	...	@@ -19,8 +19,7 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {
19	i += 1;	19	i += 1;
20		20
21	while (i < atoms.len) : (i += 1) {	21	while (i < atoms.len) : (i += 1) {
22	const atom_index = atoms[i];	22	const atom = elf_file.atom(atoms[i]).?;
23	const atom = elf_file.atom(atom_index).?;
24	assert(atom.flags.alive);	23	assert(atom.flags.alive);
25	if (@as(i64, @intCast(atom.alignment.forward(shdr.sh_size))) - start_atom.value >= max_distance)	24	if (@as(i64, @intCast(atom.alignment.forward(shdr.sh_size))) - start_atom.value >= max_distance)
26	break;	25	break;
...	@@ -33,10 +32,10 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {	...	@@ -33,10 +32,10 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {
33	thunk.output_section_index = shndx;	32	thunk.output_section_index = shndx;
34		33
35	// Scan relocs in the group and create trampolines for any unreachable callsite	34	// Scan relocs in the group and create trampolines for any unreachable callsite
36	for (atoms[start..i]) \|atom_index\| {	35	for (atoms[start..i]) \|ref\| {
37	const atom = elf_file.atom(atom_index).?;	36	const atom = elf_file.atom(ref).?;
38	const file = atom.file(elf_file).?;	37	const file = atom.file(elf_file).?;
39	log.debug("atom({d}) {s}", .{ atom_index, atom.name(elf_file) });	38	log.debug("atom({}) {s}", .{ ref, atom.name(elf_file) });
40	for (atom.relocs(elf_file)) \|rel\| {	39	for (atom.relocs(elf_file)) \|rel\| {
41	const is_reachable = switch (cpu_arch) {	40	const is_reachable = switch (cpu_arch) {
42	.aarch64 => aarch64.isReachable(atom, rel, elf_file),	41	.aarch64 => aarch64.isReachable(atom, rel, elf_file),
...	@@ -51,7 +50,7 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {	...	@@ -51,7 +50,7 @@ pub fn createThunks(shndx: u32, elf_file: *Elf) !void {
51	};	50	};
52	try thunk.symbols.put(gpa, target, {});	51	try thunk.symbols.put(gpa, target, {});
53	}	52	}
54	try atom.addExtra(.{ .thunk = thunk_index }, elf_file);	53	atom.addExtra(.{ .thunk = thunk_index }, elf_file);
55	atom.flags.thunk = true;	54	atom.flags.thunk = true;
56	}	55	}
57		56

src/link/MachO/InternalObject.zig+1-2

...	@@ -45,8 +45,7 @@ pub fn deinit(self: *InternalObject, allocator: Allocator) void {	...	@@ -45,8 +45,7 @@ pub fn deinit(self: *InternalObject, allocator: Allocator) void {
45		45
46	pub fn init(self: *InternalObject, allocator: Allocator) !void {	46	pub fn init(self: *InternalObject, allocator: Allocator) !void {
47	// Atom at index 0 is reserved as null atom.	47	// Atom at index 0 is reserved as null atom.
48	try self.atoms.append(allocator, .{});	48	try self.atoms.append(allocator, .{ .extra = try self.addAtomExtra(allocator, .{}) });
49	try self.atoms_extra.append(allocator, 0);
50	// Null byte in strtab	49	// Null byte in strtab
51	try self.strtab.append(allocator, 0);	50	try self.strtab.append(allocator, 0);
52	}	51	}

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

...	@@ -1634,7 +1634,7 @@ fn isThreadlocal(macho_file: *MachO, decl_index: InternPool.DeclIndex) bool {	...	@@ -1634,7 +1634,7 @@ fn isThreadlocal(macho_file: *MachO, decl_index: InternPool.DeclIndex) bool {
1634		1634
1635	fn addAtom(self: *ZigObject, allocator: Allocator) !Atom.Index {	1635	fn addAtom(self: *ZigObject, allocator: Allocator) !Atom.Index {
1636	try self.atoms.ensureUnusedCapacity(allocator, 1);	1636	try self.atoms.ensureUnusedCapacity(allocator, 1);
1637	try self.atoms_extra.ensureUnusedCapacity(allocator, 1);	1637	try self.atoms_extra.ensureUnusedCapacity(allocator, @sizeOf(Atom.Extra));
1638	return self.addAtomAssumeCapacity();	1638	return self.addAtomAssumeCapacity();
1639	}	1639	}
1640		1640

...	@@ -68,7 +68,7 @@ pub fn file(self: Atom, elf_file: *Elf) ?File {	...	@@ -68,7 +68,7 @@ pub fn file(self: Atom, elf_file: *Elf) ?File {
68		68
69	pub fn thunk(self: Atom, elf_file: Elf) Thunk {	69	pub fn thunk(self: Atom, elf_file: Elf) Thunk {
70	assert(self.flags.thunk);	70	assert(self.flags.thunk);
71	const extras = self.extra(elf_file).?;	71	const extras = self.extra(elf_file);
72	return elf_file.thunk(extras.thunk);	72	return elf_file.thunk(extras.thunk);
73	}	73	}
74		74
...	@@ -99,7 +99,8 @@ pub fn priority(self: Atom, elf_file: *Elf) u64 {	...	@@ -99,7 +99,8 @@ pub fn priority(self: Atom, elf_file: *Elf) u64 {
99	/// File offset relocation happens transparently, so it is not included in	99	/// File offset relocation happens transparently, so it is not included in
100	/// this calculation.	100	/// this calculation.
101	pub fn capacity(self: Atom, elf_file: *Elf) u64 {	101	pub fn capacity(self: Atom, elf_file: *Elf) u64 {
102	const next_addr = if (elf_file.atom(self.next_index)) \|next\|	102	const zo = elf_file.zigObjectPtr().?;
		103	const next_addr = if (zo.atom(self.next_index)) \|next\|
103	next.address(elf_file)	104	next.address(elf_file)
104	else	105	else
105	std.math.maxInt(u32);	106	std.math.maxInt(u32);
...	@@ -107,8 +108,9 @@ pub fn capacity(self: Atom, elf_file: *Elf) u64 {	...	@@ -107,8 +108,9 @@ pub fn capacity(self: Atom, elf_file: *Elf) u64 {
107	}	108	}
108		109
109	pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {	110	pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {
		111	const zo = elf_file.zigObjectPtr().?;
110	// No need to keep a free list node for the last block.	112	// No need to keep a free list node for the last block.
111	const next = elf_file.atom(self.next_index) orelse return false;	113	const next = zo.atom(self.next_index) orelse return false;
112	const cap: u64 = @intCast(next.address(elf_file) - self.address(elf_file));	114	const cap: u64 = @intCast(next.address(elf_file) - self.address(elf_file));
113	const ideal_cap = Elf.padToIdeal(self.size);	115	const ideal_cap = Elf.padToIdeal(self.size);
114	if (cap <= ideal_cap) return false;	116	if (cap <= ideal_cap) return false;
...	@@ -117,6 +119,7 @@ pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {	...	@@ -117,6 +119,7 @@ pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {
117	}	119	}
118		120
119	pub fn allocate(self: Atom, elf_file: Elf) !void {	121	pub fn allocate(self: Atom, elf_file: Elf) !void {
		122	const zo = elf_file.zigObjectPtr().?;
120	const shdr = &elf_file.shdrs.items[self.outputShndx().?];	123	const shdr = &elf_file.shdrs.items[self.outputShndx().?];
121	const meta = elf_file.last_atom_and_free_list_table.getPtr(self.outputShndx().?).?;	124	const meta = elf_file.last_atom_and_free_list_table.getPtr(self.outputShndx().?).?;
122	const free_list = &meta.free_list;	125	const free_list = &meta.free_list;
...	@@ -137,7 +140,7 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {	...	@@ -137,7 +140,7 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
137	var i: usize = if (elf_file.base.child_pid == null) 0 else free_list.items.len;	140	var i: usize = if (elf_file.base.child_pid == null) 0 else free_list.items.len;
138	while (i < free_list.items.len) {	141	while (i < free_list.items.len) {
139	const big_atom_index = free_list.items[i];	142	const big_atom_index = free_list.items[i];
140	const big_atom = elf_file.atom(big_atom_index).?;	143	const big_atom = zo.atom(big_atom_index).?;
141	// We now have a pointer to a live atom that has too much capacity.	144	// We now have a pointer to a live atom that has too much capacity.
142	// Is it enough that we could fit this new atom?	145	// Is it enough that we could fit this new atom?
143	const cap = big_atom.capacity(elf_file);	146	const cap = big_atom.capacity(elf_file);
...	@@ -169,7 +172,7 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {	...	@@ -169,7 +172,7 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
169	free_list_removal = i;	172	free_list_removal = i;
170	}	173	}
171	break :blk @intCast(new_start_vaddr);	174	break :blk @intCast(new_start_vaddr);
172	} else if (elf_file.atom(last_atom_index.*)) \|last\| {	175	} else if (zo.atom(last_atom_index.*)) \|last\| {
173	const ideal_capacity = Elf.padToIdeal(last.size);	176	const ideal_capacity = Elf.padToIdeal(last.size);
174	const ideal_capacity_end_vaddr = @as(u64, @intCast(last.value)) + ideal_capacity;	177	const ideal_capacity_end_vaddr = @as(u64, @intCast(last.value)) + ideal_capacity;
175	const new_start_vaddr = self.alignment.forward(ideal_capacity_end_vaddr);	178	const new_start_vaddr = self.alignment.forward(ideal_capacity_end_vaddr);
...	@@ -189,7 +192,7 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {	...	@@ -189,7 +192,7 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
189	});	192	});
190		193
191	const expand_section = if (atom_placement) \|placement_index\|	194	const expand_section = if (atom_placement) \|placement_index\|
192	elf_file.atom(placement_index).?.next_index == 0	195	zo.atom(placement_index).?.next_index == 0
193	else	196	else
194	true;	197	true;
195	if (expand_section) {	198	if (expand_section) {
...	@@ -214,15 +217,15 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {	...	@@ -214,15 +217,15 @@ pub fn allocate(self: Atom, elf_file: Elf) !void {
214	// This function can also reallocate an atom.	217	// This function can also reallocate an atom.
215	// In this case we need to "unplug" it from its previous location before	218	// In this case we need to "unplug" it from its previous location before
216	// plugging it in to its new location.	219	// plugging it in to its new location.
217	if (elf_file.atom(self.prev_index)) \|prev\| {	220	if (zo.atom(self.prev_index)) \|prev\| {
218	prev.next_index = self.next_index;	221	prev.next_index = self.next_index;
219	}	222	}
220	if (elf_file.atom(self.next_index)) \|next\| {	223	if (zo.atom(self.next_index)) \|next\| {
221	next.prev_index = self.prev_index;	224	next.prev_index = self.prev_index;
222	}	225	}
223		226
224	if (atom_placement) \|big_atom_index\| {	227	if (atom_placement) \|big_atom_index\| {
225	const big_atom = elf_file.atom(big_atom_index).?;	228	const big_atom = zo.atom(big_atom_index).?;
226	self.prev_index = big_atom_index;	229	self.prev_index = big_atom_index;
227	self.next_index = big_atom.next_index;	230	self.next_index = big_atom.next_index;
228	big_atom.next_index = self.atom_index;	231	big_atom.next_index = self.atom_index;
...	@@ -250,6 +253,7 @@ pub fn grow(self: Atom, elf_file: Elf) !void {	...	@@ -250,6 +253,7 @@ pub fn grow(self: Atom, elf_file: Elf) !void {
250	pub fn free(self: Atom, elf_file: Elf) void {	253	pub fn free(self: Atom, elf_file: Elf) void {
251	log.debug("freeAtom {d} ({s})", .{ self.atom_index, self.name(elf_file) });	254	log.debug("freeAtom {d} ({s})", .{ self.atom_index, self.name(elf_file) });
252		255
		256	const zo = elf_file.zigObjectPtr().?;
253	const comp = elf_file.base.comp;	257	const comp = elf_file.base.comp;
254	const gpa = comp.gpa;	258	const gpa = comp.gpa;
255	const shndx = self.outputShndx().?;	259	const shndx = self.outputShndx().?;
...	@@ -272,9 +276,9 @@ pub fn free(self: Atom, elf_file: Elf) void {	...	@@ -272,9 +276,9 @@ pub fn free(self: Atom, elf_file: Elf) void {
272	}	276	}
273	}	277	}
274		278
275	if (elf_file.atom(last_atom_index.*)) \|last_atom\| {	279	if (zo.atom(last_atom_index.*)) \|last_atom\| {
276	if (last_atom.atom_index == self.atom_index) {	280	if (last_atom.atom_index == self.atom_index) {
277	if (elf_file.atom(self.prev_index)) \|_\| {	281	if (zo.atom(self.prev_index)) \|_\| {
278	// TODO shrink the section size here	282	// TODO shrink the section size here
279	last_atom_index.* = self.prev_index;	283	last_atom_index.* = self.prev_index;
280	} else {	284	} else {
...	@@ -283,7 +287,7 @@ pub fn free(self: Atom, elf_file: Elf) void {	...	@@ -283,7 +287,7 @@ pub fn free(self: Atom, elf_file: Elf) void {
283	}	287	}
284	}	288	}
285		289
286	if (elf_file.atom(self.prev_index)) \|prev\| {	290	if (zo.atom(self.prev_index)) \|prev\| {
287	prev.next_index = self.next_index;	291	prev.next_index = self.next_index;
288	if (!already_have_free_list_node and prev.*.freeListEligible(elf_file)) {	292	if (!already_have_free_list_node and prev.*.freeListEligible(elf_file)) {
289	// The free list is heuristics, it doesn't have to be perfect, so we can	293	// The free list is heuristics, it doesn't have to be perfect, so we can
...	@@ -294,7 +298,7 @@ pub fn free(self: Atom, elf_file: Elf) void {	...	@@ -294,7 +298,7 @@ pub fn free(self: Atom, elf_file: Elf) void {
294	self.prev_index = 0;	298	self.prev_index = 0;
295	}	299	}
296		300
297	if (elf_file.atom(self.next_index)) \|next\| {	301	if (zo.atom(self.next_index)) \|next\| {
298	next.prev_index = self.prev_index;	302	next.prev_index = self.prev_index;
299	} else {	303	} else {
300	self.next_index = 0;	304	self.next_index = 0;
...	@@ -313,7 +317,7 @@ pub fn relocs(self: Atom, elf_file: *Elf) []const elf.Elf64_Rela {	...	@@ -313,7 +317,7 @@ pub fn relocs(self: Atom, elf_file: *Elf) []const elf.Elf64_Rela {
313	switch (self.file(elf_file).?) {	317	switch (self.file(elf_file).?) {
314	.zig_object => \|x\| return x.relocs.items[shndx].items,	318	.zig_object => \|x\| return x.relocs.items[shndx].items,
315	.object => \|x\| {	319	.object => \|x\| {
316	const extras = self.extra(elf_file).?;	320	const extras = self.extra(elf_file);
317	return x.relocs.items[extras.rel_index..][0..extras.rel_count];	321	return x.relocs.items[extras.rel_index..][0..extras.rel_count];
318	},	322	},
319	else => unreachable,	323	else => unreachable,
...	@@ -367,7 +371,7 @@ pub fn writeRelocs(self: Atom, elf_file: Elf, out_relocs: std.ArrayList(elf.El	...	@@ -367,7 +371,7 @@ pub fn writeRelocs(self: Atom, elf_file: Elf, out_relocs: std.ArrayList(elf.El
367		371
368	pub fn fdes(self: Atom, elf_file: *Elf) []Fde {	372	pub fn fdes(self: Atom, elf_file: *Elf) []Fde {
369	if (!self.flags.fde) return &[0]Fde{};	373	if (!self.flags.fde) return &[0]Fde{};
370	const extras = self.extra(elf_file).?;	374	const extras = self.extra(elf_file);
371	const object = self.file(elf_file).?.object;	375	const object = self.file(elf_file).?.object;
372	return object.fdes.items[extras.fde_start..][0..extras.fde_count];	376	return object.fdes.items[extras.fde_start..][0..extras.fde_count];
373	}	377	}
...	@@ -712,9 +716,9 @@ fn reportUndefined(	...	@@ -712,9 +716,9 @@ fn reportUndefined(
712	{	716	{
713	const gop = try undefs.getOrPut(sym_index);	717	const gop = try undefs.getOrPut(sym_index);
714	if (!gop.found_existing) {	718	if (!gop.found_existing) {
715	gop.value_ptr.* = std.ArrayList(Atom.Index).init(gpa);	719	gop.value_ptr.* = std.ArrayList(Elf.Ref).init(gpa);
716	}	720	}
717	try gop.value_ptr.append(self.atom_index);	721	try gop.value_ptr.append(.{ .index = self.atom_index, .file = self.file_index });
718	return true;	722	return true;
719	}	723	}
720		724
...	@@ -1001,25 +1005,23 @@ const AddExtraOpts = struct {	...	@@ -1001,25 +1005,23 @@ const AddExtraOpts = struct {
1001	rel_count: ?u32 = null,	1005	rel_count: ?u32 = null,
1002	};	1006	};
1003		1007
1004	pub fn addExtra(atom: Atom, opts: AddExtraOpts, elf_file: Elf) !void {	1008	pub fn addExtra(atom: Atom, opts: AddExtraOpts, elf_file: Elf) void {
1005	if (atom.extra(elf_file) == null) {	1009	const file_ptr = atom.file(elf_file).?;
1006	atom.extra_index = try elf_file.addAtomExtra(.{});	1010	var extras = file_ptr.atomExtra(atom.extra_index);
1007	}
1008	var extras = atom.extra(elf_file).?;
1009	inline for (@typeInfo(@TypeOf(opts)).Struct.fields) \|field\| {	1011	inline for (@typeInfo(@TypeOf(opts)).Struct.fields) \|field\| {
1010	if (@field(opts, field.name)) \|x\| {	1012	if (@field(opts, field.name)) \|x\| {
1011	@field(extras, field.name) = x;	1013	@field(extras, field.name) = x;
1012	}	1014	}
1013	}	1015	}
1014	atom.setExtra(extras, elf_file);	1016	file_ptr.setAtomExtra(atom.extra_index, extras);
1015	}	1017	}
1016		1018
1017	pub inline fn extra(atom: Atom, elf_file: *Elf) ?Extra {	1019	pub inline fn extra(atom: Atom, elf_file: *Elf) Extra {
1018	return elf_file.atomExtra(atom.extra_index);	1020	return atom.file(elf_file).?.atomExtra(atom.extra_index);
1019	}	1021	}
1020		1022
1021	pub inline fn setExtra(atom: Atom, extras: Extra, elf_file: *Elf) void {	1023	pub inline fn setExtra(atom: Atom, extras: Extra, elf_file: *Elf) void {
1022	elf_file.setAtomExtra(atom.extra_index, extras);	1024	atom.file(elf_file).?.setAtomExtra(atom.extra_index, extras);
1023	}	1025	}
1024		1026
1025	pub fn format(	1027	pub fn format(
...	@@ -1063,7 +1065,7 @@ fn format2(	...	@@ -1063,7 +1065,7 @@ fn format2(
1063	});	1065	});
1064	if (atom.flags.fde) {	1066	if (atom.flags.fde) {
1065	try writer.writeAll(" : fdes{ ");	1067	try writer.writeAll(" : fdes{ ");
1066	const extras = atom.extra(elf_file).?;	1068	const extras = atom.extra(elf_file);
1067	for (atom.fdes(elf_file), extras.fde_start..) \|fde, i\| {	1069	for (atom.fdes(elf_file), extras.fde_start..) \|fde, i\| {
1068	try writer.print("{d}", .{i});	1070	try writer.print("{d}", .{i});
1069	if (!fde.alive) try writer.writeAll("([*])");	1071	if (!fde.alive) try writer.writeAll("([*])");

...	@@ -1,4 +1,5 @@	...	@@ -1,4 +1,5 @@
1	index: File.Index,	1	index: File.Index,
		2
2	symtab: std.ArrayListUnmanaged(elf.Elf64_Sym) = .{},	3	symtab: std.ArrayListUnmanaged(elf.Elf64_Sym) = .{},
3	strtab: std.ArrayListUnmanaged(u8) = .{},	4	strtab: std.ArrayListUnmanaged(u8) = .{},
4	symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},	5	symbols: std.ArrayListUnmanaged(Symbol.Index) = .{},
...	@@ -11,6 +12,11 @@ pub fn deinit(self: *LinkerDefined, allocator: Allocator) void {	...	@@ -11,6 +12,11 @@ pub fn deinit(self: *LinkerDefined, allocator: Allocator) void {
11	self.symbols.deinit(allocator);	12	self.symbols.deinit(allocator);
12	}	13	}
13		14
		15	pub fn init(self: *LinkerDefined, allocator: Allocator) !void {
		16	// Null byte in strtab
		17	try self.strtab.append(allocator, 0);
		18	}
		19
14	pub fn addGlobal(self: LinkerDefined, name: [:0]const u8, elf_file: Elf) !u32 {	20	pub fn addGlobal(self: LinkerDefined, name: [:0]const u8, elf_file: Elf) !u32 {
15	const comp = elf_file.base.comp;	21	const comp = elf_file.base.comp;
16	const gpa = comp.gpa;	22	const gpa = comp.gpa;
...	@@ -41,7 +47,7 @@ pub fn resolveSymbols(self: LinkerDefined, elf_file: Elf) void {	...	@@ -41,7 +47,7 @@ pub fn resolveSymbols(self: LinkerDefined, elf_file: Elf) void {
41	const global = elf_file.symbol(index);	47	const global = elf_file.symbol(index);
42	if (self.asFile().symbolRank(this_sym, false) < global.symbolRank(elf_file)) {	48	if (self.asFile().symbolRank(this_sym, false) < global.symbolRank(elf_file)) {
43	global.value = 0;	49	global.value = 0;
44	global.atom_index = 0;	50	global.atom_ref = .{ .index = 0, .file = 0 };
45	global.file_index = self.index;	51	global.file_index = self.index;
46	global.esym_index = sym_idx;	52	global.esym_index = sym_idx;
47	global.version_index = elf_file.default_sym_version;	53	global.version_index = elf_file.default_sym_version;
...	@@ -127,6 +133,7 @@ const mem = std.mem;	...	@@ -127,6 +133,7 @@ const mem = std.mem;
127	const std = @import("std");	133	const std = @import("std");
128		134
129	const Allocator = mem.Allocator;	135	const Allocator = mem.Allocator;
		136	const Atom = @import("Atom.zig");
130	const Elf = @import("../Elf.zig");	137	const Elf = @import("../Elf.zig");
131	const File = @import("file.zig").File;	138	const File = @import("file.zig").File;
132	const LinkerDefined = @This();	139	const LinkerDefined = @This();

...	@@ -341,8 +341,8 @@ fn initComdatGroups(elf_file: *Elf) !void {	...	@@ -341,8 +341,8 @@ fn initComdatGroups(elf_file: *Elf) !void {
341	fn updateSectionSizes(elf_file: *Elf) !void {	341	fn updateSectionSizes(elf_file: *Elf) !void {
342	for (elf_file.output_sections.keys(), elf_file.output_sections.values()) \|shndx, atom_list\| {	342	for (elf_file.output_sections.keys(), elf_file.output_sections.values()) \|shndx, atom_list\| {
343	const shdr = &elf_file.shdrs.items[shndx];	343	const shdr = &elf_file.shdrs.items[shndx];
344	for (atom_list.items) \|atom_index\| {	344	for (atom_list.items) \|ref\| {
345	const atom_ptr = elf_file.atom(atom_index) orelse continue;	345	const atom_ptr = elf_file.atom(ref) orelse continue;
346	if (!atom_ptr.flags.alive) continue;	346	if (!atom_ptr.flags.alive) continue;
347	const offset = atom_ptr.alignment.forward(shdr.sh_size);	347	const offset = atom_ptr.alignment.forward(shdr.sh_size);
348	const padding = offset - shdr.sh_size;	348	const padding = offset - shdr.sh_size;
...	@@ -354,8 +354,8 @@ fn updateSectionSizes(elf_file: *Elf) !void {	...	@@ -354,8 +354,8 @@ fn updateSectionSizes(elf_file: *Elf) !void {
354		354
355	for (elf_file.output_rela_sections.values()) \|sec\| {	355	for (elf_file.output_rela_sections.values()) \|sec\| {
356	const shdr = &elf_file.shdrs.items[sec.shndx];	356	const shdr = &elf_file.shdrs.items[sec.shndx];
357	for (sec.atom_list.items) \|atom_index\| {	357	for (sec.atom_list.items) \|ref\| {
358	const atom_ptr = elf_file.atom(atom_index) orelse continue;	358	const atom_ptr = elf_file.atom(ref) orelse continue;
359	if (!atom_ptr.flags.alive) continue;	359	if (!atom_ptr.flags.alive) continue;
360	const relocs = atom_ptr.relocs(elf_file);	360	const relocs = atom_ptr.relocs(elf_file);
361	shdr.sh_size += shdr.sh_entsize * relocs.len;	361	shdr.sh_size += shdr.sh_entsize * relocs.len;
...	@@ -448,16 +448,16 @@ fn writeAtoms(elf_file: *Elf) !void {	...	@@ -448,16 +448,16 @@ fn writeAtoms(elf_file: *Elf) !void {
448	0;	448	0;
449	@memset(buffer, padding_byte);	449	@memset(buffer, padding_byte);
450		450
451	for (atom_list.items) \|atom_index\| {	451	for (atom_list.items) \|ref\| {
452	const atom_ptr = elf_file.atom(atom_index).?;	452	const atom_ptr = elf_file.atom(ref).?;
453	assert(atom_ptr.flags.alive);	453	assert(atom_ptr.flags.alive);
454		454
455	const offset = math.cast(usize, atom_ptr.value - @as(i64, @intCast(shdr.sh_addr - base_offset))) orelse	455	const offset = math.cast(usize, atom_ptr.value - @as(i64, @intCast(shdr.sh_addr - base_offset))) orelse
456	return error.Overflow;	456	return error.Overflow;
457	const size = math.cast(usize, atom_ptr.size) orelse return error.Overflow;	457	const size = math.cast(usize, atom_ptr.size) orelse return error.Overflow;
458		458
459	log.debug("writing atom({d}) from 0x{x} to 0x{x}", .{	459	log.debug("writing atom({}) from 0x{x} to 0x{x}", .{
460	atom_index,	460	ref,
461	sh_offset + offset,	461	sh_offset + offset,
462	sh_offset + offset + size,	462	sh_offset + offset + size,
463	});	463	});
...	@@ -465,8 +465,8 @@ fn writeAtoms(elf_file: *Elf) !void {	...	@@ -465,8 +465,8 @@ fn writeAtoms(elf_file: *Elf) !void {
465	// TODO decompress directly into provided buffer	465	// TODO decompress directly into provided buffer
466	const out_code = buffer[offset..][0..size];	466	const out_code = buffer[offset..][0..size];
467	const in_code = switch (atom_ptr.file(elf_file).?) {	467	const in_code = switch (atom_ptr.file(elf_file).?) {
468	.object => \|x\| try x.codeDecompressAlloc(elf_file, atom_index),	468	.object => \|x\| try x.codeDecompressAlloc(elf_file, ref.index),
469	.zig_object => \|x\| try x.codeAlloc(elf_file, atom_index),	469	.zig_object => \|x\| try x.codeAlloc(elf_file, ref.index),
470	else => unreachable,	470	else => unreachable,
471	};	471	};
472	defer gpa.free(in_code);	472	defer gpa.free(in_code);
...	@@ -490,8 +490,8 @@ fn writeSyntheticSections(elf_file: *Elf) !void {	...	@@ -490,8 +490,8 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
490	var relocs = try std.ArrayList(elf.Elf64_Rela).initCapacity(gpa, num_relocs);	490	var relocs = try std.ArrayList(elf.Elf64_Rela).initCapacity(gpa, num_relocs);
491	defer relocs.deinit();	491	defer relocs.deinit();
492		492
493	for (sec.atom_list.items) \|atom_index\| {	493	for (sec.atom_list.items) \|ref\| {
494	const atom_ptr = elf_file.atom(atom_index) orelse continue;	494	const atom_ptr = elf_file.atom(ref) orelse continue;
495	if (!atom_ptr.flags.alive) continue;	495	if (!atom_ptr.flags.alive) continue;
496	try atom_ptr.writeRelocs(elf_file, &relocs);	496	try atom_ptr.writeRelocs(elf_file, &relocs);
497	}	497	}