Merge pull request #20873 from ziglang/elf-ownership

elf: clean up resource ownership in the linker

Author: kubkon

src/link/Elf.zig

@@ -30,23 +30,25 @@ atom_index: Index = 0,
 prev_index: Index = 0,
 next_index: Index = 0,
 
-/// Flags we use for state tracking.
-flags: Flags = .{},
+/// Specifies whether this atom is alive or has been garbage collected.
+alive: bool = true,
+
+/// Specifies if the atom has been visited during garbage collection.
+visited: bool = false,
 
 extra_index: u32 = 0,
 
 pub const Alignment = @import("../../InternPool.zig").Alignment;
 
-pub fn name(self: Atom, elf_file: *Elf) []const u8 {
+pub fn name(self: Atom, elf_file: *Elf) [:0]const u8 {
     const file_ptr = self.file(elf_file).?;
     return switch (file_ptr) {
         inline else => |x| x.getString(self.name_offset),
     };
 }
 
 pub fn address(self: Atom, elf_file: *Elf) i64 {
-    const shndx = self.outputShndx() orelse return self.value;
-    const shdr = elf_file.shdrs.items[shndx];
+    const shdr = elf_file.shdrs.items[self.output_section_index];
     return @as(i64, @intCast(shdr.sh_addr)) + self.value;
 }
 
@@ -55,7 +57,7 @@ pub fn debugTombstoneValue(self: Atom, target: Symbol, elf_file: *Elf) ?u64 {
         if (msub.alive) return null;
     }
     if (target.atom(elf_file)) |atom_ptr| {
-        if (atom_ptr.flags.alive) return null;
+        if (atom_ptr.alive) return null;
     }
     const atom_name = self.name(elf_file);
     if (!mem.startsWith(u8, atom_name, ".debug")) return null;
@@ -67,8 +69,7 @@ pub fn file(self: Atom, elf_file: *Elf) ?File {
 }
 
 pub fn thunk(self: Atom, elf_file: *Elf) *Thunk {
-    assert(self.flags.thunk);
-    const extras = self.extra(elf_file).?;
+    const extras = self.extra(elf_file);
     return elf_file.thunk(extras.thunk);
 }
 
@@ -85,11 +86,6 @@ pub fn relocsShndx(self: Atom) ?u32 {
     return self.relocs_section_index;
 }
 
-pub fn outputShndx(self: Atom) ?u32 {
-    if (self.output_section_index == 0) return null;
-    return self.output_section_index;
-}
-
 pub fn priority(self: Atom, elf_file: *Elf) u64 {
     const index = self.file(elf_file).?.index();
     return (@as(u64, @intCast(index)) << 32) | @as(u64, @intCast(self.input_section_index));
@@ -99,16 +95,18 @@ pub fn priority(self: Atom, elf_file: *Elf) u64 {
 /// File offset relocation happens transparently, so it is not included in
 /// this calculation.
 pub fn capacity(self: Atom, elf_file: *Elf) u64 {
-    const next_addr = if (elf_file.atom(self.next_index)) |next|
+    const zo = elf_file.zigObjectPtr().?;
+    const next_addr = if (zo.atom(self.next_index)) |next|
         next.address(elf_file)
     else
         std.math.maxInt(u32);
     return @intCast(next_addr - self.address(elf_file));
 }
 
 pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {
+    const zo = elf_file.zigObjectPtr().?;
     // No need to keep a free list node for the last block.
-    const next = elf_file.atom(self.next_index) orelse return false;
+    const next = zo.atom(self.next_index) orelse return false;
     const cap: u64 = @intCast(next.address(elf_file) - self.address(elf_file));
     const ideal_cap = Elf.padToIdeal(self.size);
     if (cap <= ideal_cap) return false;
@@ -117,8 +115,9 @@ pub fn freeListEligible(self: Atom, elf_file: *Elf) bool {
 }
 
 pub fn allocate(self: *Atom, elf_file: *Elf) !void {
-    const shdr = &elf_file.shdrs.items[self.outputShndx().?];
-    const meta = elf_file.last_atom_and_free_list_table.getPtr(self.outputShndx().?).?;
+    const zo = elf_file.zigObjectPtr().?;
+    const shdr = &elf_file.shdrs.items[self.output_section_index];
+    const meta = elf_file.last_atom_and_free_list_table.getPtr(self.output_section_index).?;
     const free_list = &meta.free_list;
     const last_atom_index = &meta.last_atom_index;
     const new_atom_ideal_capacity = Elf.padToIdeal(self.size);
@@ -137,7 +136,7 @@ pub fn allocate(self: *Atom, elf_file: *Elf) !void {
         var i: usize = if (elf_file.base.child_pid == null) 0 else free_list.items.len;
         while (i < free_list.items.len) {
             const big_atom_index = free_list.items[i];
-            const big_atom = elf_file.atom(big_atom_index).?;
+            const big_atom = zo.atom(big_atom_index).?;
             // We now have a pointer to a live atom that has too much capacity.
             // Is it enough that we could fit this new atom?
             const cap = big_atom.capacity(elf_file);
@@ -169,7 +168,7 @@ pub fn allocate(self: *Atom, elf_file: *Elf) !void {
                 free_list_removal = i;
             }
             break :blk @intCast(new_start_vaddr);
-        } else if (elf_file.atom(last_atom_index.*)) |last| {
+        } else if (zo.atom(last_atom_index.*)) |last| {
             const ideal_capacity = Elf.padToIdeal(last.size);
             const ideal_capacity_end_vaddr = @as(u64, @intCast(last.value)) + ideal_capacity;
             const new_start_vaddr = self.alignment.forward(ideal_capacity_end_vaddr);
@@ -189,12 +188,12 @@ pub fn allocate(self: *Atom, elf_file: *Elf) !void {
     });
 
     const expand_section = if (atom_placement) |placement_index|
-        elf_file.atom(placement_index).?.next_index == 0
+        zo.atom(placement_index).?.next_index == 0
     else
         true;
     if (expand_section) {
         const needed_size: u64 = @intCast(self.value + @as(i64, @intCast(self.size)));
-        try elf_file.growAllocSection(self.outputShndx().?, needed_size);
+        try elf_file.growAllocSection(self.output_section_index, needed_size);
         last_atom_index.* = self.atom_index;
 
         const zig_object = elf_file.zigObjectPtr().?;
@@ -214,15 +213,15 @@ pub fn allocate(self: *Atom, elf_file: *Elf) !void {
     // This function can also reallocate an atom.
     // In this case we need to "unplug" it from its previous location before
     // plugging it in to its new location.
-    if (elf_file.atom(self.prev_index)) |prev| {
+    if (zo.atom(self.prev_index)) |prev| {
         prev.next_index = self.next_index;
     }
-    if (elf_file.atom(self.next_index)) |next| {
+    if (zo.atom(self.next_index)) |next| {
         next.prev_index = self.prev_index;
     }
 
     if (atom_placement) |big_atom_index| {
-        const big_atom = elf_file.atom(big_atom_index).?;
+        const big_atom = zo.atom(big_atom_index).?;
         self.prev_index = big_atom_index;
         self.next_index = big_atom.next_index;
         big_atom.next_index = self.atom_index;
@@ -234,7 +233,7 @@ pub fn allocate(self: *Atom, elf_file: *Elf) !void {
         _ = free_list.swapRemove(i);
     }
 
-    self.flags.alive = true;
+    self.alive = true;
 }
 
 pub fn shrink(self: *Atom, elf_file: *Elf) void {
@@ -250,9 +249,10 @@ pub fn grow(self: *Atom, elf_file: *Elf) !void {
 pub fn free(self: *Atom, elf_file: *Elf) void {
     log.debug("freeAtom {d} ({s})", .{ self.atom_index, self.name(elf_file) });
 
+    const zo = elf_file.zigObjectPtr().?;
     const comp = elf_file.base.comp;
     const gpa = comp.gpa;
-    const shndx = self.outputShndx().?;
+    const shndx = self.output_section_index;
     const meta = elf_file.last_atom_and_free_list_table.getPtr(shndx).?;
     const free_list = &meta.free_list;
     const last_atom_index = &meta.last_atom_index;
@@ -272,9 +272,9 @@ pub fn free(self: *Atom, elf_file: *Elf) void {
         }
     }
 
-    if (elf_file.atom(last_atom_index.*)) |last_atom| {
+    if (zo.atom(last_atom_index.*)) |last_atom| {
         if (last_atom.atom_index == self.atom_index) {
-            if (elf_file.atom(self.prev_index)) |_| {
+            if (zo.atom(self.prev_index)) |_| {
                 // TODO shrink the section size here
                 last_atom_index.* = self.prev_index;
             } else {
@@ -283,7 +283,7 @@ pub fn free(self: *Atom, elf_file: *Elf) void {
         }
     }
 
-    if (elf_file.atom(self.prev_index)) |prev| {
+    if (zo.atom(self.prev_index)) |prev| {
         prev.next_index = self.next_index;
         if (!already_have_free_list_node and prev.*.freeListEligible(elf_file)) {
             // The free list is heuristics, it doesn't have to be perfect, so we can
@@ -294,7 +294,7 @@ pub fn free(self: *Atom, elf_file: *Elf) void {
         self.prev_index = 0;
     }
 
-    if (elf_file.atom(self.next_index)) |next| {
+    if (zo.atom(self.next_index)) |next| {
         next.prev_index = self.prev_index;
     } else {
         self.next_index = 0;
@@ -313,7 +313,7 @@ pub fn relocs(self: Atom, elf_file: *Elf) []const elf.Elf64_Rela {
     switch (self.file(elf_file).?) {
         .zig_object => |x| return x.relocs.items[shndx].items,
         .object => |x| {
-            const extras = self.extra(elf_file).?;
+            const extras = self.extra(elf_file);
             return x.relocs.items[extras.rel_index..][0..extras.rel_count];
         },
         else => unreachable,
@@ -337,12 +337,12 @@ pub fn writeRelocs(self: Atom, elf_file: *Elf, out_relocs: *std.ArrayList(elf.El
         var r_addend = rel.r_addend;
         var r_sym: u32 = 0;
         switch (target.type(elf_file)) {
-            elf.STT_SECTION => if (target.mergeSubsection(elf_file)) |msub| {
-                r_addend += @intCast(target.address(.{}, elf_file));
-                r_sym = elf_file.sectionSymbolOutputSymtabIndex(msub.mergeSection(elf_file).output_section_index);
-            } else {
+            elf.STT_SECTION => {
                 r_addend += @intCast(target.address(.{}, elf_file));
-                r_sym = elf_file.sectionSymbolOutputSymtabIndex(target.outputShndx().?);
+                r_sym = if (target.outputShndx(elf_file)) |osec|
+                    elf_file.sectionSymbolOutputSymtabIndex(osec)
+                else
+                    0;
             },
             else => {
                 r_sym = target.outputSymtabIndex(elf_file) orelse 0;
@@ -366,10 +366,12 @@ pub fn writeRelocs(self: Atom, elf_file: *Elf, out_relocs: *std.ArrayList(elf.El
 }
 
 pub fn fdes(self: Atom, elf_file: *Elf) []Fde {
-    if (!self.flags.fde) return &[0]Fde{};
-    const extras = self.extra(elf_file).?;
-    const object = self.file(elf_file).?.object;
-    return object.fdes.items[extras.fde_start..][0..extras.fde_count];
+    const extras = self.extra(elf_file);
+    return switch (self.file(elf_file).?) {
+        .shared_object => unreachable,
+        .linker_defined, .zig_object => &[0]Fde{},
+        .object => |x| x.fdes.items[extras.fde_start..][0..extras.fde_count],
+    };
 }
 
 pub fn markFdesDead(self: Atom, elf_file: *Elf) void {
@@ -712,9 +714,9 @@ fn reportUndefined(
     {
         const gop = try undefs.getOrPut(sym_index);
         if (!gop.found_existing) {
-            gop.value_ptr.* = std.ArrayList(Atom.Index).init(gpa);
+            gop.value_ptr.* = std.ArrayList(Elf.Ref).init(gpa);
         }
-        try gop.value_ptr.append(self.atom_index);
+        try gop.value_ptr.append(.{ .index = self.atom_index, .file = self.file_index });
         return true;
     }
 
@@ -1001,25 +1003,23 @@ const AddExtraOpts = struct {
     rel_count: ?u32 = null,
 };
 
-pub fn addExtra(atom: *Atom, opts: AddExtraOpts, elf_file: *Elf) !void {
-    if (atom.extra(elf_file) == null) {
-        atom.extra_index = try elf_file.addAtomExtra(.{});
-    }
-    var extras = atom.extra(elf_file).?;
+pub fn addExtra(atom: *Atom, opts: AddExtraOpts, elf_file: *Elf) void {
+    const file_ptr = atom.file(elf_file).?;
+    var extras = file_ptr.atomExtra(atom.extra_index);
     inline for (@typeInfo(@TypeOf(opts)).Struct.fields) |field| {
         if (@field(opts, field.name)) |x| {
             @field(extras, field.name) = x;
         }
     }
-    atom.setExtra(extras, elf_file);
+    file_ptr.setAtomExtra(atom.extra_index, extras);
 }
 
-pub inline fn extra(atom: Atom, elf_file: *Elf) ?Extra {
-    return elf_file.atomExtra(atom.extra_index);
+pub inline fn extra(atom: Atom, elf_file: *Elf) Extra {
+    return atom.file(elf_file).?.atomExtra(atom.extra_index);
 }
 
 pub inline fn setExtra(atom: Atom, extras: Extra, elf_file: *Elf) void {
-    elf_file.setAtomExtra(atom.extra_index, extras);
+    atom.file(elf_file).?.setAtomExtra(atom.extra_index, extras);
 }
 
 pub fn format(
@@ -1061,37 +1061,23 @@ fn format2(
         atom.atom_index,           atom.name(elf_file), atom.address(elf_file),
         atom.output_section_index, atom.alignment,      atom.size,
     });
-    if (atom.flags.fde) {
+    if (atom.fdes(elf_file).len > 0) {
         try writer.writeAll(" : fdes{ ");
-        const extras = atom.extra(elf_file).?;
+        const extras = atom.extra(elf_file);
         for (atom.fdes(elf_file), extras.fde_start..) |fde, i| {
             try writer.print("{d}", .{i});
             if (!fde.alive) try writer.writeAll("([*])");
             if (i - extras.fde_start < extras.fde_count - 1) try writer.writeAll(", ");
         }
         try writer.writeAll(" }");
     }
-    if (!atom.flags.alive) {
+    if (!atom.alive) {
         try writer.writeAll(" : [*]");
     }
 }
 
 pub const Index = u32;
 
-pub const Flags = packed struct {
-    /// Specifies whether this atom is alive or has been garbage collected.
-    alive: bool = true,
-
-    /// Specifies if the atom has been visited during garbage collection.
-    visited: bool = false,
-
-    /// Whether this atom has a range extension thunk.
-    thunk: bool = false,
-
-    /// Whether this atom has FDE records.
-    fde: bool = false,
-};
-
 const x86_64 = struct {
     fn scanReloc(
         atom: Atom,