aboutsummaryrefslogtreecommitdiff
path: root/src/link/MachO/Object.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/link/MachO/Object.zig')
-rw-r--r--src/link/MachO/Object.zig526
1 files changed, 432 insertions, 94 deletions
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 401184da51..13219084b6 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -8,6 +8,7 @@ const std = @import("std");
const build_options = @import("build_options");
const assert = std.debug.assert;
const dwarf = std.dwarf;
+const eh_frame = @import("eh_frame.zig");
const fs = std.fs;
const io = std.io;
const log = std.log.scoped(.link);
@@ -24,6 +25,7 @@ const DwarfInfo = @import("DwarfInfo.zig");
const LoadCommandIterator = macho.LoadCommandIterator;
const Zld = @import("zld.zig").Zld;
const SymbolWithLoc = @import("zld.zig").SymbolWithLoc;
+const UnwindInfo = @import("UnwindInfo.zig");
name: []const u8,
mtime: u64,
@@ -44,6 +46,8 @@ symtab: []macho.nlist_64 = undefined,
/// Can be undefined as set together with in_symtab.
source_symtab_lookup: []u32 = undefined,
/// Can be undefined as set together with in_symtab.
+reverse_symtab_lookup: []u32 = undefined,
+/// Can be undefined as set together with in_symtab.
source_address_lookup: []i64 = undefined,
/// Can be undefined as set together with in_symtab.
source_section_index_lookup: []i64 = undefined,
@@ -53,22 +57,49 @@ strtab_lookup: []u32 = undefined,
atom_by_index_table: []AtomIndex = undefined,
/// Can be undefined as set together with in_symtab.
globals_lookup: []i64 = undefined,
+/// Can be undefined as set together with in_symtab.
+relocs_lookup: []RelocEntry = undefined,
atoms: std.ArrayListUnmanaged(AtomIndex) = .{},
+exec_atoms: std.ArrayListUnmanaged(AtomIndex) = .{},
+
+eh_frame_sect: ?macho.section_64 = null,
+eh_frame_relocs_lookup: std.AutoArrayHashMapUnmanaged(u32, Record) = .{},
+eh_frame_records_lookup: std.AutoArrayHashMapUnmanaged(AtomIndex, u32) = .{},
+
+unwind_info_sect: ?macho.section_64 = null,
+unwind_relocs_lookup: []Record = undefined,
+unwind_records_lookup: std.AutoHashMapUnmanaged(AtomIndex, u32) = .{},
+
+const RelocEntry = struct { start: u32, len: u32 };
+
+const Record = struct {
+ dead: bool,
+ reloc: RelocEntry,
+};
pub fn deinit(self: *Object, gpa: Allocator) void {
self.atoms.deinit(gpa);
+ self.exec_atoms.deinit(gpa);
gpa.free(self.name);
gpa.free(self.contents);
if (self.in_symtab) |_| {
gpa.free(self.source_symtab_lookup);
+ gpa.free(self.reverse_symtab_lookup);
gpa.free(self.source_address_lookup);
gpa.free(self.source_section_index_lookup);
gpa.free(self.strtab_lookup);
gpa.free(self.symtab);
gpa.free(self.atom_by_index_table);
gpa.free(self.globals_lookup);
+ gpa.free(self.relocs_lookup);
}
+ self.eh_frame_relocs_lookup.deinit(gpa);
+ self.eh_frame_records_lookup.deinit(gpa);
+ if (self.hasUnwindRecords()) {
+ gpa.free(self.unwind_relocs_lookup);
+ }
+ self.unwind_records_lookup.deinit(gpa);
}
pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch) !void {
@@ -105,76 +136,95 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
.ncmds = self.header.ncmds,
.buffer = self.contents[@sizeOf(macho.mach_header_64)..][0..self.header.sizeofcmds],
};
- while (it.next()) |cmd| {
- switch (cmd.cmd()) {
- .SYMTAB => {
- const symtab = cmd.cast(macho.symtab_command).?;
- self.in_symtab = @ptrCast(
- [*]const macho.nlist_64,
- @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]),
- )[0..symtab.nsyms];
- self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize];
-
- const nsects = self.getSourceSections().len;
-
- self.symtab = try allocator.alloc(macho.nlist_64, self.in_symtab.?.len + nsects);
- self.source_symtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len);
- self.strtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len);
- self.globals_lookup = try allocator.alloc(i64, self.in_symtab.?.len);
- self.atom_by_index_table = try allocator.alloc(AtomIndex, self.in_symtab.?.len + nsects);
- // This is wasteful but we need to be able to lookup source symbol address after stripping and
- // allocating of sections.
- self.source_address_lookup = try allocator.alloc(i64, self.in_symtab.?.len);
- self.source_section_index_lookup = try allocator.alloc(i64, nsects);
-
- for (self.symtab) |*sym| {
- sym.* = .{
- .n_value = 0,
- .n_sect = 0,
- .n_desc = 0,
- .n_strx = 0,
- .n_type = 0,
- };
- }
+ const nsects = self.getSourceSections().len;
+ const symtab = while (it.next()) |cmd| switch (cmd.cmd()) {
+ .SYMTAB => break cmd.cast(macho.symtab_command).?,
+ else => {},
+ } else return;
+
+ self.in_symtab = @ptrCast(
+ [*]const macho.nlist_64,
+ @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]),
+ )[0..symtab.nsyms];
+ self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize];
+
+ self.symtab = try allocator.alloc(macho.nlist_64, self.in_symtab.?.len + nsects);
+ self.source_symtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len);
+ self.reverse_symtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len);
+ self.strtab_lookup = try allocator.alloc(u32, self.in_symtab.?.len);
+ self.globals_lookup = try allocator.alloc(i64, self.in_symtab.?.len);
+ self.atom_by_index_table = try allocator.alloc(AtomIndex, self.in_symtab.?.len + nsects);
+ self.relocs_lookup = try allocator.alloc(RelocEntry, self.in_symtab.?.len + nsects);
+ // This is wasteful but we need to be able to lookup source symbol address after stripping and
+ // allocating of sections.
+ self.source_address_lookup = try allocator.alloc(i64, self.in_symtab.?.len);
+ self.source_section_index_lookup = try allocator.alloc(i64, nsects);
+
+ for (self.symtab) |*sym| {
+ sym.* = .{
+ .n_value = 0,
+ .n_sect = 0,
+ .n_desc = 0,
+ .n_strx = 0,
+ .n_type = 0,
+ };
+ }
- mem.set(i64, self.globals_lookup, -1);
- mem.set(AtomIndex, self.atom_by_index_table, 0);
- mem.set(i64, self.source_section_index_lookup, -1);
+ mem.set(i64, self.globals_lookup, -1);
+ mem.set(AtomIndex, self.atom_by_index_table, 0);
+ mem.set(i64, self.source_section_index_lookup, -1);
+ mem.set(RelocEntry, self.relocs_lookup, .{
+ .start = 0,
+ .len = 0,
+ });
- // You would expect that the symbol table is at least pre-sorted based on symbol's type:
- // local < extern defined < undefined. Unfortunately, this is not guaranteed! For instance,
- // the GO compiler does not necessarily respect that therefore we sort immediately by type
- // and address within.
- var sorted_all_syms = try std.ArrayList(SymbolAtIndex).initCapacity(allocator, self.in_symtab.?.len);
- defer sorted_all_syms.deinit();
+ // You would expect that the symbol table is at least pre-sorted based on symbol's type:
+ // local < extern defined < undefined. Unfortunately, this is not guaranteed! For instance,
+ // the GO compiler does not necessarily respect that therefore we sort immediately by type
+ // and address within.
+ var sorted_all_syms = try std.ArrayList(SymbolAtIndex).initCapacity(allocator, self.in_symtab.?.len);
+ defer sorted_all_syms.deinit();
- for (self.in_symtab.?) |_, index| {
- sorted_all_syms.appendAssumeCapacity(.{ .index = @intCast(u32, index) });
- }
+ for (self.in_symtab.?) |_, index| {
+ sorted_all_syms.appendAssumeCapacity(.{ .index = @intCast(u32, index) });
+ }
- // We sort by type: defined < undefined, and
- // afterwards by address in each group. Normally, dysymtab should
- // be enough to guarantee the sort, but turns out not every compiler
- // is kind enough to specify the symbols in the correct order.
- sort.sort(SymbolAtIndex, sorted_all_syms.items, self, SymbolAtIndex.lessThan);
+ // We sort by type: defined < undefined, and
+ // afterwards by address in each group. Normally, dysymtab should
+ // be enough to guarantee the sort, but turns out not every compiler
+ // is kind enough to specify the symbols in the correct order.
+ sort.sort(SymbolAtIndex, sorted_all_syms.items, self, SymbolAtIndex.lessThan);
- for (sorted_all_syms.items) |sym_id, i| {
- const sym = sym_id.getSymbol(self);
+ for (sorted_all_syms.items) |sym_id, i| {
+ const sym = sym_id.getSymbol(self);
- if (sym.sect() and self.source_section_index_lookup[sym.n_sect - 1] == -1) {
- self.source_section_index_lookup[sym.n_sect - 1] = @intCast(i64, i);
- }
+ if (sym.sect() and self.source_section_index_lookup[sym.n_sect - 1] == -1) {
+ self.source_section_index_lookup[sym.n_sect - 1] = @intCast(i64, i);
+ }
- self.symtab[i] = sym;
- self.source_symtab_lookup[i] = sym_id.index;
- self.source_address_lookup[i] = if (sym.undf()) -1 else @intCast(i64, sym.n_value);
+ self.symtab[i] = sym;
+ self.source_symtab_lookup[i] = sym_id.index;
+ self.reverse_symtab_lookup[sym_id.index] = @intCast(u32, i);
+ self.source_address_lookup[i] = if (sym.undf()) -1 else @intCast(i64, sym.n_value);
- const sym_name_len = mem.sliceTo(@ptrCast([*:0]const u8, self.in_strtab.?.ptr + sym.n_strx), 0).len + 1;
- self.strtab_lookup[i] = @intCast(u32, sym_name_len);
- }
+ const sym_name_len = mem.sliceTo(@ptrCast([*:0]const u8, self.in_strtab.?.ptr + sym.n_strx), 0).len + 1;
+ self.strtab_lookup[i] = @intCast(u32, sym_name_len);
+ }
+
+ // Parse __TEXT,__eh_frame header if one exists
+ self.eh_frame_sect = self.getSourceSectionByName("__TEXT", "__eh_frame");
+
+ // Parse __LD,__compact_unwind header if one exists
+ self.unwind_info_sect = self.getSourceSectionByName("__LD", "__compact_unwind");
+ if (self.hasUnwindRecords()) {
+ self.unwind_relocs_lookup = try allocator.alloc(Record, self.getUnwindRecords().len);
+ mem.set(Record, self.unwind_relocs_lookup, .{
+ .dead = true,
+ .reloc = .{
+ .start = 0,
+ .len = 0,
},
- else => {},
- }
+ });
}
}
@@ -192,6 +242,17 @@ const SymbolAtIndex = struct {
return mem.sliceTo(@ptrCast([*:0]const u8, ctx.in_strtab.?.ptr + off), 0);
}
+ fn getSymbolSeniority(self: SymbolAtIndex, ctx: Context) u2 {
+ const sym = self.getSymbol(ctx);
+ if (!sym.ext()) {
+ const sym_name = self.getSymbolName(ctx);
+ if (mem.startsWith(u8, sym_name, "l") or mem.startsWith(u8, sym_name, "L")) return 0;
+ return 1;
+ }
+ if (sym.weakDef() or sym.pext()) return 2;
+ return 3;
+ }
+
/// Performs lexicographic-like check.
/// * lhs and rhs defined
/// * if lhs == rhs
@@ -206,23 +267,15 @@ const SymbolAtIndex = struct {
if (lhs.sect() and rhs.sect()) {
if (lhs.n_value == rhs.n_value) {
if (lhs.n_sect == rhs.n_sect) {
- if (lhs.ext() and rhs.ext()) {
- if ((lhs.pext() or lhs.weakDef()) and (rhs.pext() or rhs.weakDef())) {
- return false;
- } else return rhs.pext() or rhs.weakDef();
- } else {
- const lhs_name = lhs_index.getSymbolName(ctx);
- const lhs_temp = mem.startsWith(u8, lhs_name, "l") or mem.startsWith(u8, lhs_name, "L");
- const rhs_name = rhs_index.getSymbolName(ctx);
- const rhs_temp = mem.startsWith(u8, rhs_name, "l") or mem.startsWith(u8, rhs_name, "L");
- if (lhs_temp and rhs_temp) {
- return false;
- } else return rhs_temp;
- }
+ const lhs_senior = lhs_index.getSymbolSeniority(ctx);
+ const rhs_senior = rhs_index.getSymbolSeniority(ctx);
+ if (lhs_senior == rhs_senior) {
+ return lessThanByNStrx(ctx, lhs_index, rhs_index);
+ } else return lhs_senior < rhs_senior;
} else return lhs.n_sect < rhs.n_sect;
} else return lhs.n_value < rhs.n_value;
} else if (lhs.undf() and rhs.undf()) {
- return false;
+ return lessThanByNStrx(ctx, lhs_index, rhs_index);
} else return rhs.undf();
}
@@ -295,14 +348,20 @@ fn sectionLessThanByAddress(ctx: void, lhs: SortedSection, rhs: SortedSection) b
return lhs.header.addr < rhs.header.addr;
}
-/// Splits input sections into Atoms.
+pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u32) !void {
+ log.debug("splitting object({d}, {s}) into atoms", .{ object_id, self.name });
+
+ try self.splitRegularSections(zld, object_id);
+ try self.parseEhFrameSection(zld, object_id);
+ try self.parseUnwindInfo(zld, object_id);
+}
+
+/// Splits input regular sections into Atoms.
/// If the Object was compiled with `MH_SUBSECTIONS_VIA_SYMBOLS`, splits section
/// into subsections where each subsection then represents an Atom.
-pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void {
+pub fn splitRegularSections(self: *Object, zld: *Zld, object_id: u32) !void {
const gpa = zld.gpa;
- log.debug("splitting object({d}, {s}) into atoms", .{ object_id, self.name });
-
const sections = self.getSourceSections();
for (sections) |sect, id| {
if (sect.isDebug()) continue;
@@ -418,6 +477,9 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void {
sect.@"align",
out_sect_id,
);
+ if (!sect.isZerofill()) {
+ try self.cacheRelocs(zld, atom_index);
+ }
zld.addAtomToSection(atom_index);
}
@@ -431,7 +493,6 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void {
const nsyms_trailing = atom_loc.len - 1;
next_sym_index += atom_loc.len;
- // TODO: We want to bubble up the first externally defined symbol here.
const atom_size = if (next_sym_index < sect_start_index + sect_loc.len)
symtab[next_sym_index].n_value - addr
else
@@ -461,7 +522,9 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void {
const alias_index = self.getSectionAliasSymbolIndex(sect_id);
self.atom_by_index_table[alias_index] = atom_index;
}
-
+ if (!sect.isZerofill()) {
+ try self.cacheRelocs(zld, atom_index);
+ }
zld.addAtomToSection(atom_index);
}
} else {
@@ -476,6 +539,9 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void {
sect.@"align",
out_sect_id,
);
+ if (!sect.isZerofill()) {
+ try self.cacheRelocs(zld, atom_index);
+ }
zld.addAtomToSection(atom_index);
}
}
@@ -484,7 +550,7 @@ pub fn splitIntoAtoms(self: *Object, zld: *Zld, object_id: u31) !void {
fn createAtomFromSubsection(
self: *Object,
zld: *Zld,
- object_id: u31,
+ object_id: u32,
sym_index: u32,
inner_sym_index: u32,
inner_nsyms_trailing: u32,
@@ -497,7 +563,7 @@ fn createAtomFromSubsection(
const atom = zld.getAtomPtr(atom_index);
atom.inner_sym_index = inner_sym_index;
atom.inner_nsyms_trailing = inner_nsyms_trailing;
- atom.file = object_id;
+ atom.file = object_id + 1;
self.symtab[sym_index].n_sect = out_sect_id + 1;
log.debug("creating ATOM(%{d}, '{s}') in sect({d}, '{s},{s}') in object({d})", .{
@@ -519,9 +585,220 @@ fn createAtomFromSubsection(
self.atom_by_index_table[sym_loc.sym_index] = atom_index;
}
+ const out_sect = zld.sections.items(.header)[out_sect_id];
+ if (out_sect.isCode() and
+ mem.eql(u8, "__TEXT", out_sect.segName()) and
+ mem.eql(u8, "__text", out_sect.sectName()))
+ {
+ // TODO currently assuming a single section for executable machine code
+ try self.exec_atoms.append(gpa, atom_index);
+ }
+
return atom_index;
}
+fn filterRelocs(
+ relocs: []align(1) const macho.relocation_info,
+ start_addr: u64,
+ end_addr: u64,
+) RelocEntry {
+ const Predicate = struct {
+ addr: u64,
+
+ pub fn predicate(self: @This(), rel: macho.relocation_info) bool {
+ return rel.r_address >= self.addr;
+ }
+ };
+ const LPredicate = struct {
+ addr: u64,
+
+ pub fn predicate(self: @This(), rel: macho.relocation_info) bool {
+ return rel.r_address < self.addr;
+ }
+ };
+
+ const start = @import("zld.zig").bsearch(macho.relocation_info, relocs, Predicate{ .addr = end_addr });
+ const len = @import("zld.zig").lsearch(macho.relocation_info, relocs[start..], LPredicate{ .addr = start_addr });
+
+ return .{ .start = @intCast(u32, start), .len = @intCast(u32, len) };
+}
+
+fn cacheRelocs(self: *Object, zld: *Zld, atom_index: AtomIndex) !void {
+ const atom = zld.getAtom(atom_index);
+
+ const source_sect = if (self.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
+ const source_sect = self.getSourceSection(source_sym.n_sect - 1);
+ assert(!source_sect.isZerofill());
+ break :blk source_sect;
+ } else blk: {
+ // If there was no matching symbol present in the source symtab, this means
+ // we are dealing with either an entire section, or part of it, but also
+ // starting at the beginning.
+ const nbase = @intCast(u32, self.in_symtab.?.len);
+ const sect_id = @intCast(u16, atom.sym_index - nbase);
+ const source_sect = self.getSourceSection(sect_id);
+ assert(!source_sect.isZerofill());
+ break :blk source_sect;
+ };
+
+ const relocs = self.getRelocs(source_sect);
+
+ self.relocs_lookup[atom.sym_index] = if (self.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
+ const offset = source_sym.n_value - source_sect.addr;
+ break :blk filterRelocs(relocs, offset, offset + atom.size);
+ } else filterRelocs(relocs, 0, atom.size);
+}
+
+fn parseEhFrameSection(self: *Object, zld: *Zld, object_id: u32) !void {
+ const sect = self.eh_frame_sect orelse return;
+
+ log.debug("parsing __TEXT,__eh_frame section", .{});
+
+ if (zld.getSectionByName("__TEXT", "__eh_frame") == null) {
+ _ = try zld.initSection("__TEXT", "__eh_frame", .{});
+ }
+
+ const gpa = zld.gpa;
+ const cpu_arch = zld.options.target.cpu.arch;
+ const relocs = self.getRelocs(sect);
+
+ var it = self.getEhFrameRecordsIterator();
+ var record_count: u32 = 0;
+ while (try it.next()) |_| {
+ record_count += 1;
+ }
+
+ try self.eh_frame_relocs_lookup.ensureTotalCapacity(gpa, record_count);
+ try self.eh_frame_records_lookup.ensureTotalCapacity(gpa, record_count);
+
+ it.reset();
+
+ while (try it.next()) |record| {
+ const offset = it.pos - record.getSize();
+ const rel_pos = switch (cpu_arch) {
+ .aarch64 => filterRelocs(relocs, offset, offset + record.getSize()),
+ .x86_64 => RelocEntry{ .start = 0, .len = 0 },
+ else => unreachable,
+ };
+ self.eh_frame_relocs_lookup.putAssumeCapacityNoClobber(offset, .{
+ .dead = false,
+ .reloc = rel_pos,
+ });
+
+ if (record.tag == .fde) {
+ const target = blk: {
+ switch (cpu_arch) {
+ .aarch64 => {
+ assert(rel_pos.len > 0); // TODO convert to an error as the FDE eh frame is malformed
+ // Find function symbol that this record describes
+ const rel = relocs[rel_pos.start..][rel_pos.len - 1];
+ const target = UnwindInfo.parseRelocTarget(
+ zld,
+ object_id,
+ rel,
+ it.data[offset..],
+ @intCast(i32, offset),
+ );
+ break :blk target;
+ },
+ .x86_64 => {
+ const target_address = record.getTargetSymbolAddress(.{
+ .base_addr = sect.addr,
+ .base_offset = offset,
+ });
+ const target_sym_index = self.getSymbolByAddress(target_address, null);
+ const target = if (self.getGlobal(target_sym_index)) |global_index|
+ zld.globals.items[global_index]
+ else
+ SymbolWithLoc{ .sym_index = target_sym_index, .file = object_id + 1 };
+ break :blk target;
+ },
+ else => unreachable,
+ }
+ };
+ log.debug("FDE at offset {x} tracks {s}", .{ offset, zld.getSymbolName(target) });
+ if (target.getFile() != object_id) {
+ self.eh_frame_relocs_lookup.getPtr(offset).?.dead = true;
+ } else {
+ const atom_index = self.getAtomIndexForSymbol(target.sym_index).?;
+ self.eh_frame_records_lookup.putAssumeCapacityNoClobber(atom_index, offset);
+ }
+ }
+ }
+}
+
+fn parseUnwindInfo(self: *Object, zld: *Zld, object_id: u32) !void {
+ const sect = self.unwind_info_sect orelse {
+ // If it so happens that the object had `__eh_frame` section defined but no `__compact_unwind`,
+ // we will try fully synthesising unwind info records to somewhat match Apple ld's
+ // approach. However, we will only synthesise DWARF records and nothing more. For this reason,
+ // we still create the output `__TEXT,__unwind_info` section.
+ if (self.eh_frame_sect != null) {
+ if (zld.getSectionByName("__TEXT", "__unwind_info") == null) {
+ _ = try zld.initSection("__TEXT", "__unwind_info", .{});
+ }
+ }
+ return;
+ };
+
+ log.debug("parsing unwind info in {s}", .{self.name});
+
+ const gpa = zld.gpa;
+ const cpu_arch = zld.options.target.cpu.arch;
+
+ if (zld.getSectionByName("__TEXT", "__unwind_info") == null) {
+ _ = try zld.initSection("__TEXT", "__unwind_info", .{});
+ }
+
+ try self.unwind_records_lookup.ensureTotalCapacity(gpa, @intCast(u32, self.exec_atoms.items.len));
+
+ const unwind_records = self.getUnwindRecords();
+
+ const needs_eh_frame = for (unwind_records) |record| {
+ if (UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) break true;
+ } else false;
+
+ if (needs_eh_frame) {
+ if (self.eh_frame_sect == null) {
+ log.err("missing __TEXT,__eh_frame section", .{});
+ log.err(" in object {s}", .{self.name});
+ return error.MissingSection;
+ }
+ }
+
+ const relocs = self.getRelocs(sect);
+ for (unwind_records) |record, record_id| {
+ const offset = record_id * @sizeOf(macho.compact_unwind_entry);
+ const rel_pos = filterRelocs(
+ relocs,
+ offset,
+ offset + @sizeOf(macho.compact_unwind_entry),
+ );
+ assert(rel_pos.len > 0); // TODO convert to an error as the unwind info is malformed
+ self.unwind_relocs_lookup[record_id] = .{
+ .dead = false,
+ .reloc = rel_pos,
+ };
+
+ // Find function symbol that this record describes
+ const rel = relocs[rel_pos.start..][rel_pos.len - 1];
+ const target = UnwindInfo.parseRelocTarget(
+ zld,
+ object_id,
+ rel,
+ mem.asBytes(&record),
+ @intCast(i32, offset),
+ );
+ log.debug("unwind record {d} tracks {s}", .{ record_id, zld.getSymbolName(target) });
+ if (target.getFile() != object_id) {
+ self.unwind_relocs_lookup[record_id].dead = true;
+ } else {
+ const atom_index = self.getAtomIndexForSymbol(target.sym_index).?;
+ self.unwind_records_lookup.putAssumeCapacityNoClobber(atom_index, @intCast(u32, record_id));
+ }
+ }
+}
+
pub fn getSourceSymbol(self: Object, index: u32) ?macho.nlist_64 {
const symtab = self.in_symtab.?;
if (index >= symtab.len) return null;
@@ -529,23 +806,28 @@ pub fn getSourceSymbol(self: Object, index: u32) ?macho.nlist_64 {
return symtab[mapped_index];
}
-/// Expects an arena allocator.
-/// Caller owns memory.
-pub fn createReverseSymbolLookup(self: Object, arena: Allocator) ![]u32 {
- const symtab = self.in_symtab orelse return &[0]u32{};
- const lookup = try arena.alloc(u32, symtab.len);
- for (self.source_symtab_lookup) |source_id, id| {
- lookup[source_id] = @intCast(u32, id);
- }
- return lookup;
-}
-
pub fn getSourceSection(self: Object, index: u16) macho.section_64 {
const sections = self.getSourceSections();
assert(index < sections.len);
return sections[index];
}
+pub fn getSourceSectionByName(self: Object, segname: []const u8, sectname: []const u8) ?macho.section_64 {
+ const sections = self.getSourceSections();
+ for (sections) |sect| {
+ if (mem.eql(u8, segname, sect.segName()) and mem.eql(u8, sectname, sect.sectName()))
+ return sect;
+ } else return null;
+}
+
+pub fn getSourceSectionIndexByName(self: Object, segname: []const u8, sectname: []const u8) ?u8 {
+ const sections = self.getSourceSections();
+ for (sections) |sect, i| {
+ if (mem.eql(u8, segname, sect.segName()) and mem.eql(u8, sectname, sect.sectName()))
+ return @intCast(u8, i + 1);
+ } else return null;
+}
+
pub fn getSourceSections(self: Object) []const macho.section_64 {
var it = LoadCommandIterator{
.ncmds = self.header.ncmds,
@@ -652,8 +934,64 @@ pub fn getSymbolName(self: Object, index: u32) []const u8 {
return strtab[start..][0 .. len - 1 :0];
}
+pub fn getSymbolByAddress(self: Object, addr: u64, sect_hint: ?u8) u32 {
+ // Find containing atom
+ const Predicate = struct {
+ addr: i64,
+
+ pub fn predicate(pred: @This(), other: i64) bool {
+ return if (other == -1) true else other > pred.addr;
+ }
+ };
+
+ if (sect_hint) |sect_id| {
+ if (self.source_section_index_lookup[sect_id] > -1) {
+ const first_sym_index = @intCast(usize, self.source_section_index_lookup[sect_id]);
+ const target_sym_index = @import("zld.zig").lsearch(i64, self.source_address_lookup[first_sym_index..], Predicate{
+ .addr = @intCast(i64, addr),
+ });
+ if (target_sym_index > 0) {
+ return @intCast(u32, first_sym_index + target_sym_index - 1);
+ }
+ }
+ return self.getSectionAliasSymbolIndex(sect_id);
+ }
+
+ const target_sym_index = @import("zld.zig").lsearch(i64, self.source_address_lookup, Predicate{
+ .addr = @intCast(i64, addr),
+ });
+ assert(target_sym_index > 0);
+ return @intCast(u32, target_sym_index - 1);
+}
+
+pub fn getGlobal(self: Object, sym_index: u32) ?u32 {
+ if (self.globals_lookup[sym_index] == -1) return null;
+ return @intCast(u32, self.globals_lookup[sym_index]);
+}
+
pub fn getAtomIndexForSymbol(self: Object, sym_index: u32) ?AtomIndex {
const atom_index = self.atom_by_index_table[sym_index];
if (atom_index == 0) return null;
return atom_index;
}
+
+pub fn hasUnwindRecords(self: Object) bool {
+ return self.unwind_info_sect != null;
+}
+
+pub fn getUnwindRecords(self: Object) []align(1) const macho.compact_unwind_entry {
+ const sect = self.unwind_info_sect orelse return &[0]macho.compact_unwind_entry{};
+ const data = self.getSectionContents(sect);
+ const num_entries = @divExact(data.len, @sizeOf(macho.compact_unwind_entry));
+ return @ptrCast([*]align(1) const macho.compact_unwind_entry, data)[0..num_entries];
+}
+
+pub fn hasEhFrameRecords(self: Object) bool {
+ return self.eh_frame_sect != null;
+}
+
+pub fn getEhFrameRecordsIterator(self: Object) eh_frame.Iterator {
+ const sect = self.eh_frame_sect orelse return .{ .data = &[0]u8{} };
+ const data = self.getSectionContents(sect);
+ return .{ .data = data };
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-28 08:45:59 +0000