mirror of
https://github.com/ziglang/zig.git
synced 2024-11-14 16:13:24 +00:00
zld: parse, synthesise and emit unwind records
This commit is contained in:
Jakub Konka
parent
74b72a766d
commit
835a60a34f
@ -593,10 +593,12 @@ set(ZIG_STAGE2_SOURCES
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/Object.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/Relocation.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/Trie.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/UnwindInfo.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/ZldAtom.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/dyld_info/bind.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/dyld_info/Rebase.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/dead_strip.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/eh_frame.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/fat.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/load_commands.zig"
|
||||
"${CMAKE_SOURCE_DIR}/src/link/MachO/thunks.zig"
|
||||
|
||||
@ -697,6 +697,7 @@ pub const File = struct {
|
||||
/// TODO audit this error set. most of these should be collapsed into one error,
|
||||
/// and ErrorFlags should be updated to convey the meaning to the user.
|
||||
pub const FlushError = error{
|
||||
BadDwarfCfi,
|
||||
CacheUnavailable,
|
||||
CurrentWorkingDirectoryUnlinked,
|
||||
DivisionByZero,
|
||||
@ -737,6 +738,8 @@ pub const File = struct {
|
||||
MissingEndForExpression,
|
||||
/// TODO: this should be removed from the error set in favor of using ErrorFlags
|
||||
MissingMainEntrypoint,
|
||||
/// TODO: this should be removed from the error set in favor of using ErrorFlags
|
||||
MissingSection,
|
||||
MissingSymbol,
|
||||
MissingTableSymbols,
|
||||
ModuleNameMismatch,
|
||||
|
||||
@ -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;
|
||||
const symtab = while (it.next()) |cmd| switch (cmd.cmd()) {
|
||||
.SYMTAB => break cmd.cast(macho.symtab_command).?,
|
||||
else => {},
|
||||
} else return;
|
||||
|
||||
const nsects = self.getSourceSections().len;
|
||||
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.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);
|
||||
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,
|
||||
};
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
}
|
||||
},
|
||||
else => {},
|
||||
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.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);
|
||||
}
|
||||
|
||||
// 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,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@ -295,14 +345,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 +474,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 +490,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 +519,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 +536,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 +547,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 +560,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 +582,208 @@ 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 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),
|
||||
);
|
||||
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 +791,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 +919,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 };
|
||||
}
|
||||
|
||||
831
src/link/MachO/UnwindInfo.zig
Normal file
831
src/link/MachO/UnwindInfo.zig
Normal file
@ -0,0 +1,831 @@
|
||||
const UnwindInfo = @This();
|
||||
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const eh_frame = @import("eh_frame.zig");
|
||||
const fs = std.fs;
|
||||
const leb = std.leb;
|
||||
const log = std.log.scoped(.unwind_info);
|
||||
const macho = std.macho;
|
||||
const math = std.math;
|
||||
const mem = std.mem;
|
||||
const trace = @import("../../tracy.zig").trace;
|
||||
|
||||
const Allocator = mem.Allocator;
|
||||
const Atom = @import("ZldAtom.zig");
|
||||
const AtomIndex = @import("zld.zig").AtomIndex;
|
||||
const EhFrameRecord = eh_frame.EhFrameRecord;
|
||||
const Object = @import("Object.zig");
|
||||
const SymbolWithLoc = @import("zld.zig").SymbolWithLoc;
|
||||
const Zld = @import("zld.zig").Zld;
|
||||
|
||||
const N_DEAD = @import("zld.zig").N_DEAD;
|
||||
|
||||
gpa: Allocator,
|
||||
|
||||
/// List of all unwind records gathered from all objects and sorted
|
||||
/// by source function address.
|
||||
records: std.ArrayListUnmanaged(macho.compact_unwind_entry) = .{},
|
||||
records_lookup: std.AutoHashMapUnmanaged(AtomIndex, RecordIndex) = .{},
|
||||
|
||||
/// List of all personalities referenced by either unwind info entries
|
||||
/// or __eh_frame entries.
|
||||
personalities: [max_personalities]SymbolWithLoc = undefined,
|
||||
personalities_count: u2 = 0,
|
||||
|
||||
/// List of common encodings sorted in descending order with the most common first.
|
||||
common_encodings: [max_common_encodings]macho.compact_unwind_encoding_t = undefined,
|
||||
common_encodings_count: u7 = 0,
|
||||
|
||||
/// List of record indexes containing an LSDA pointer.
|
||||
lsdas: std.ArrayListUnmanaged(RecordIndex) = .{},
|
||||
lsdas_lookup: std.AutoHashMapUnmanaged(RecordIndex, u32) = .{},
|
||||
|
||||
/// List of second level pages.
|
||||
pages: std.ArrayListUnmanaged(Page) = .{},
|
||||
|
||||
const RecordIndex = u32;
|
||||
|
||||
const max_personalities = 3;
|
||||
const max_common_encodings = 127;
|
||||
const max_compact_encodings = 256;
|
||||
|
||||
const second_level_page_bytes = 0x1000;
|
||||
const second_level_page_words = second_level_page_bytes / @sizeOf(u32);
|
||||
|
||||
const max_regular_second_level_entries =
|
||||
(second_level_page_bytes - @sizeOf(macho.unwind_info_regular_second_level_page_header)) /
|
||||
@sizeOf(macho.unwind_info_regular_second_level_entry);
|
||||
|
||||
const max_compressed_second_level_entries =
|
||||
(second_level_page_bytes - @sizeOf(macho.unwind_info_compressed_second_level_page_header)) /
|
||||
@sizeOf(u32);
|
||||
|
||||
const compressed_entry_func_offset_mask = ~@as(u24, 0);
|
||||
|
||||
const Page = struct {
|
||||
kind: enum { regular, compressed },
|
||||
start: RecordIndex,
|
||||
count: u16,
|
||||
page_encodings: [max_compact_encodings]RecordIndex = undefined,
|
||||
page_encodings_count: u8 = 0,
|
||||
|
||||
fn appendPageEncoding(page: *Page, record_id: RecordIndex) void {
|
||||
assert(page.page_encodings_count <= max_compact_encodings);
|
||||
page.page_encodings[page.page_encodings_count] = record_id;
|
||||
page.page_encodings_count += 1;
|
||||
}
|
||||
|
||||
fn getPageEncoding(
|
||||
page: *const Page,
|
||||
info: *const UnwindInfo,
|
||||
enc: macho.compact_unwind_encoding_t,
|
||||
) ?u8 {
|
||||
comptime var index: u8 = 0;
|
||||
inline while (index < max_compact_encodings) : (index += 1) {
|
||||
if (index >= page.page_encodings_count) return null;
|
||||
const record_id = page.page_encodings[index];
|
||||
const record = info.records.items[record_id];
|
||||
if (record.compactUnwindEncoding == enc) {
|
||||
return index;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
fn format(
|
||||
page: *const Page,
|
||||
comptime unused_format_string: []const u8,
|
||||
options: std.fmt.FormatOptions,
|
||||
writer: anytype,
|
||||
) !void {
|
||||
_ = page;
|
||||
_ = unused_format_string;
|
||||
_ = options;
|
||||
_ = writer;
|
||||
@compileError("do not format Page directly; use page.fmtDebug()");
|
||||
}
|
||||
|
||||
const DumpCtx = struct {
|
||||
page: *const Page,
|
||||
info: *const UnwindInfo,
|
||||
};
|
||||
|
||||
fn dump(
|
||||
ctx: DumpCtx,
|
||||
comptime unused_format_string: []const u8,
|
||||
options: std.fmt.FormatOptions,
|
||||
writer: anytype,
|
||||
) @TypeOf(writer).Error!void {
|
||||
_ = options;
|
||||
comptime assert(unused_format_string.len == 0);
|
||||
try writer.writeAll("Page:\n");
|
||||
try writer.print(" kind: {s}\n", .{@tagName(ctx.page.kind)});
|
||||
try writer.print(" entries: {d} - {d}\n", .{
|
||||
ctx.page.start,
|
||||
ctx.page.start + ctx.page.count,
|
||||
});
|
||||
try writer.print(" encodings (count = {d})\n", .{ctx.page.page_encodings_count});
|
||||
for (ctx.page.page_encodings[0..ctx.page.page_encodings_count]) |record_id, i| {
|
||||
const record = ctx.info.records.items[record_id];
|
||||
const enc = record.compactUnwindEncoding;
|
||||
try writer.print(" {d}: 0x{x:0>8}\n", .{ ctx.info.common_encodings_count + i, enc });
|
||||
}
|
||||
}
|
||||
|
||||
fn fmtDebug(page: *const Page, info: *const UnwindInfo) std.fmt.Formatter(dump) {
|
||||
return .{ .data = .{
|
||||
.page = page,
|
||||
.info = info,
|
||||
} };
|
||||
}
|
||||
|
||||
fn write(page: *const Page, info: *const UnwindInfo, writer: anytype) !void {
|
||||
switch (page.kind) {
|
||||
.regular => {
|
||||
try writer.writeStruct(macho.unwind_info_regular_second_level_page_header{
|
||||
.entryPageOffset = @sizeOf(macho.unwind_info_regular_second_level_page_header),
|
||||
.entryCount = page.count,
|
||||
});
|
||||
|
||||
for (info.records.items[page.start..][0..page.count]) |record| {
|
||||
try writer.writeStruct(macho.unwind_info_regular_second_level_entry{
|
||||
.functionOffset = @intCast(u32, record.rangeStart),
|
||||
.encoding = record.compactUnwindEncoding,
|
||||
});
|
||||
}
|
||||
},
|
||||
.compressed => {
|
||||
const entry_offset = @sizeOf(macho.unwind_info_compressed_second_level_page_header) +
|
||||
@intCast(u16, page.page_encodings_count) * @sizeOf(u32);
|
||||
try writer.writeStruct(macho.unwind_info_compressed_second_level_page_header{
|
||||
.entryPageOffset = entry_offset,
|
||||
.entryCount = page.count,
|
||||
.encodingsPageOffset = @sizeOf(
|
||||
macho.unwind_info_compressed_second_level_page_header,
|
||||
),
|
||||
.encodingsCount = page.page_encodings_count,
|
||||
});
|
||||
|
||||
for (page.page_encodings[0..page.page_encodings_count]) |record_id| {
|
||||
const enc = info.records.items[record_id].compactUnwindEncoding;
|
||||
try writer.writeIntLittle(u32, enc);
|
||||
}
|
||||
|
||||
assert(page.count > 0);
|
||||
const first_entry = info.records.items[page.start];
|
||||
for (info.records.items[page.start..][0..page.count]) |record| {
|
||||
const enc_index = blk: {
|
||||
if (info.getCommonEncoding(record.compactUnwindEncoding)) |id| {
|
||||
break :blk id;
|
||||
}
|
||||
const ncommon = info.common_encodings_count;
|
||||
break :blk ncommon + page.getPageEncoding(info, record.compactUnwindEncoding).?;
|
||||
};
|
||||
const compressed = macho.UnwindInfoCompressedEntry{
|
||||
.funcOffset = @intCast(u24, record.rangeStart - first_entry.rangeStart),
|
||||
.encodingIndex = @intCast(u8, enc_index),
|
||||
};
|
||||
try writer.writeStruct(compressed);
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
pub fn deinit(info: *UnwindInfo) void {
|
||||
info.records.deinit(info.gpa);
|
||||
info.records_lookup.deinit(info.gpa);
|
||||
info.pages.deinit(info.gpa);
|
||||
info.lsdas.deinit(info.gpa);
|
||||
info.lsdas_lookup.deinit(info.gpa);
|
||||
}
|
||||
|
||||
pub fn scanRelocs(zld: *Zld) !void {
|
||||
if (zld.getSectionByName("__TEXT", "__unwind_info") == null) return;
|
||||
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
for (zld.objects.items) |*object, object_id| {
|
||||
const unwind_records = object.getUnwindRecords();
|
||||
for (object.exec_atoms.items) |atom_index| {
|
||||
const record_id = object.unwind_records_lookup.get(atom_index) orelse continue;
|
||||
if (object.unwind_relocs_lookup[record_id].dead) continue;
|
||||
const record = unwind_records[record_id];
|
||||
if (!UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) {
|
||||
if (getPersonalityFunctionReloc(
|
||||
zld,
|
||||
@intCast(u32, object_id),
|
||||
record_id,
|
||||
)) |rel| {
|
||||
// Personality function; add GOT pointer.
|
||||
const target = parseRelocTarget(
|
||||
zld,
|
||||
@intCast(u32, object_id),
|
||||
rel,
|
||||
mem.asBytes(&record),
|
||||
@intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)),
|
||||
);
|
||||
try Atom.addGotEntry(zld, target);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn collect(info: *UnwindInfo, zld: *Zld) !void {
|
||||
if (zld.getSectionByName("__TEXT", "__unwind_info") == null) return;
|
||||
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
|
||||
var records = std.ArrayList(macho.compact_unwind_entry).init(info.gpa);
|
||||
defer records.deinit();
|
||||
|
||||
var atom_indexes = std.ArrayList(AtomIndex).init(info.gpa);
|
||||
defer atom_indexes.deinit();
|
||||
|
||||
// TODO handle dead stripping
|
||||
for (zld.objects.items) |*object, object_id| {
|
||||
log.debug("collecting unwind records in {s} ({d})", .{ object.name, object_id });
|
||||
const unwind_records = object.getUnwindRecords();
|
||||
|
||||
// Contents of unwind records does not have to cover all symbol in executable section
|
||||
// so we need insert them ourselves.
|
||||
try records.ensureUnusedCapacity(object.exec_atoms.items.len);
|
||||
try atom_indexes.ensureUnusedCapacity(object.exec_atoms.items.len);
|
||||
|
||||
var it = object.getEhFrameRecordsIterator();
|
||||
|
||||
for (object.exec_atoms.items) |atom_index| {
|
||||
var record = if (object.unwind_records_lookup.get(atom_index)) |record_id| blk: {
|
||||
if (object.unwind_relocs_lookup[record_id].dead) continue;
|
||||
var record = unwind_records[record_id];
|
||||
|
||||
if (UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) {
|
||||
const fde_offset = object.eh_frame_records_lookup.get(atom_index).?;
|
||||
it.seekTo(fde_offset);
|
||||
const fde = (try it.next()).?;
|
||||
const cie_ptr = fde.getCiePointer();
|
||||
const cie_offset = fde_offset + 4 - cie_ptr;
|
||||
it.seekTo(cie_offset);
|
||||
const cie = (try it.next()).?;
|
||||
|
||||
if (cie.getPersonalityPointerReloc(
|
||||
zld,
|
||||
@intCast(u32, object_id),
|
||||
cie_offset,
|
||||
)) |target| {
|
||||
const personality_index = info.getPersonalityFunction(target) orelse inner: {
|
||||
const personality_index = info.personalities_count;
|
||||
info.personalities[personality_index] = target;
|
||||
info.personalities_count += 1;
|
||||
break :inner personality_index;
|
||||
};
|
||||
|
||||
record.personalityFunction = personality_index + 1;
|
||||
UnwindEncoding.setPersonalityIndex(&record.compactUnwindEncoding, personality_index + 1);
|
||||
}
|
||||
} else {
|
||||
if (getPersonalityFunctionReloc(
|
||||
zld,
|
||||
@intCast(u32, object_id),
|
||||
record_id,
|
||||
)) |rel| {
|
||||
const target = parseRelocTarget(
|
||||
zld,
|
||||
@intCast(u32, object_id),
|
||||
rel,
|
||||
mem.asBytes(&record),
|
||||
@intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)),
|
||||
);
|
||||
const personality_index = info.getPersonalityFunction(target) orelse inner: {
|
||||
const personality_index = info.personalities_count;
|
||||
info.personalities[personality_index] = target;
|
||||
info.personalities_count += 1;
|
||||
break :inner personality_index;
|
||||
};
|
||||
|
||||
record.personalityFunction = personality_index + 1;
|
||||
UnwindEncoding.setPersonalityIndex(&record.compactUnwindEncoding, personality_index + 1);
|
||||
}
|
||||
|
||||
if (getLsdaReloc(zld, @intCast(u32, object_id), record_id)) |rel| {
|
||||
const target = parseRelocTarget(
|
||||
zld,
|
||||
@intCast(u32, object_id),
|
||||
rel,
|
||||
mem.asBytes(&record),
|
||||
@intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)),
|
||||
);
|
||||
record.lsda = @bitCast(u64, target);
|
||||
}
|
||||
}
|
||||
break :blk record;
|
||||
} else blk: {
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const sym = zld.getSymbol(atom.getSymbolWithLoc());
|
||||
if (sym.n_desc == N_DEAD) continue;
|
||||
break :blk nullRecord();
|
||||
};
|
||||
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const sym_loc = atom.getSymbolWithLoc();
|
||||
const sym = zld.getSymbol(sym_loc);
|
||||
assert(sym.n_desc != N_DEAD);
|
||||
record.rangeStart = sym.n_value;
|
||||
record.rangeLength = @intCast(u32, atom.size);
|
||||
|
||||
records.appendAssumeCapacity(record);
|
||||
atom_indexes.appendAssumeCapacity(atom_index);
|
||||
}
|
||||
}
|
||||
|
||||
// Fold records
|
||||
try info.records.ensureTotalCapacity(info.gpa, records.items.len);
|
||||
try info.records_lookup.ensureTotalCapacity(info.gpa, @intCast(u32, atom_indexes.items.len));
|
||||
|
||||
var maybe_prev: ?macho.compact_unwind_entry = null;
|
||||
for (records.items) |record, i| {
|
||||
const record_id = blk: {
|
||||
if (maybe_prev) |prev| {
|
||||
const is_dwarf = UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch);
|
||||
if (is_dwarf or
|
||||
(prev.compactUnwindEncoding != record.compactUnwindEncoding) or
|
||||
(prev.personalityFunction != record.personalityFunction) or
|
||||
record.lsda > 0)
|
||||
{
|
||||
const record_id = @intCast(RecordIndex, info.records.items.len);
|
||||
info.records.appendAssumeCapacity(record);
|
||||
maybe_prev = record;
|
||||
break :blk record_id;
|
||||
} else {
|
||||
break :blk @intCast(RecordIndex, info.records.items.len - 1);
|
||||
}
|
||||
} else {
|
||||
const record_id = @intCast(RecordIndex, info.records.items.len);
|
||||
info.records.appendAssumeCapacity(record);
|
||||
maybe_prev = record;
|
||||
break :blk record_id;
|
||||
}
|
||||
};
|
||||
info.records_lookup.putAssumeCapacityNoClobber(atom_indexes.items[i], record_id);
|
||||
}
|
||||
|
||||
// Calculate common encodings
|
||||
{
|
||||
const CommonEncWithCount = struct {
|
||||
enc: macho.compact_unwind_encoding_t,
|
||||
count: u32,
|
||||
|
||||
fn greaterThan(ctx: void, lhs: @This(), rhs: @This()) bool {
|
||||
_ = ctx;
|
||||
return lhs.count > rhs.count;
|
||||
}
|
||||
};
|
||||
|
||||
const Context = struct {
|
||||
pub fn hash(ctx: @This(), key: macho.compact_unwind_encoding_t) u32 {
|
||||
_ = ctx;
|
||||
return key;
|
||||
}
|
||||
|
||||
pub fn eql(
|
||||
ctx: @This(),
|
||||
key1: macho.compact_unwind_encoding_t,
|
||||
key2: macho.compact_unwind_encoding_t,
|
||||
b_index: usize,
|
||||
) bool {
|
||||
_ = ctx;
|
||||
_ = b_index;
|
||||
return key1 == key2;
|
||||
}
|
||||
};
|
||||
|
||||
var common_encodings_counts = std.ArrayHashMap(
|
||||
macho.compact_unwind_encoding_t,
|
||||
CommonEncWithCount,
|
||||
Context,
|
||||
false,
|
||||
).init(info.gpa);
|
||||
defer common_encodings_counts.deinit();
|
||||
|
||||
for (info.records.items) |record| {
|
||||
assert(!isNull(record));
|
||||
if (UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) continue;
|
||||
const enc = record.compactUnwindEncoding;
|
||||
const gop = try common_encodings_counts.getOrPut(enc);
|
||||
if (!gop.found_existing) {
|
||||
gop.value_ptr.* = .{
|
||||
.enc = enc,
|
||||
.count = 0,
|
||||
};
|
||||
}
|
||||
gop.value_ptr.count += 1;
|
||||
}
|
||||
|
||||
var slice = common_encodings_counts.values();
|
||||
std.sort.sort(CommonEncWithCount, slice, {}, CommonEncWithCount.greaterThan);
|
||||
|
||||
var i: u7 = 0;
|
||||
while (i < slice.len) : (i += 1) {
|
||||
if (i >= max_common_encodings) break;
|
||||
if (slice[i].count < 2) continue;
|
||||
info.appendCommonEncoding(slice[i].enc);
|
||||
log.debug("adding common encoding: {d} => 0x{x:0>8}", .{ i, slice[i].enc });
|
||||
}
|
||||
}
|
||||
|
||||
// Compute page allocations
|
||||
{
|
||||
var i: u32 = 0;
|
||||
while (i < info.records.items.len) {
|
||||
const range_start_max: u64 =
|
||||
info.records.items[i].rangeStart + compressed_entry_func_offset_mask;
|
||||
var encoding_count: u9 = info.common_encodings_count;
|
||||
var space_left: u32 = second_level_page_words -
|
||||
@sizeOf(macho.unwind_info_compressed_second_level_page_header) / @sizeOf(u32);
|
||||
var page = Page{
|
||||
.kind = undefined,
|
||||
.start = i,
|
||||
.count = 0,
|
||||
};
|
||||
|
||||
while (space_left >= 1 and i < info.records.items.len) {
|
||||
const record = info.records.items[i];
|
||||
const enc = record.compactUnwindEncoding;
|
||||
const is_dwarf = UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch);
|
||||
|
||||
if (record.rangeStart >= range_start_max) {
|
||||
break;
|
||||
} else if (info.getCommonEncoding(enc) != null or
|
||||
page.getPageEncoding(info, enc) != null and !is_dwarf)
|
||||
{
|
||||
i += 1;
|
||||
space_left -= 1;
|
||||
} else if (space_left >= 2 and encoding_count < max_compact_encodings) {
|
||||
page.appendPageEncoding(i);
|
||||
i += 1;
|
||||
space_left -= 2;
|
||||
encoding_count += 1;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
page.count = @intCast(u16, i - page.start);
|
||||
|
||||
if (i < info.records.items.len and page.count < max_regular_second_level_entries) {
|
||||
page.kind = .regular;
|
||||
page.count = @intCast(u16, @min(
|
||||
max_regular_second_level_entries,
|
||||
info.records.items.len - page.start,
|
||||
));
|
||||
i = page.start + page.count;
|
||||
} else {
|
||||
page.kind = .compressed;
|
||||
}
|
||||
|
||||
log.debug("{}", .{page.fmtDebug(info)});
|
||||
|
||||
try info.pages.append(info.gpa, page);
|
||||
}
|
||||
}
|
||||
|
||||
// Save indices of records requiring LSDA relocation
|
||||
try info.lsdas_lookup.ensureTotalCapacity(info.gpa, @intCast(u32, info.records.items.len));
|
||||
for (info.records.items) |rec, i| {
|
||||
info.lsdas_lookup.putAssumeCapacityNoClobber(@intCast(RecordIndex, i), @intCast(u32, info.lsdas.items.len));
|
||||
if (rec.lsda == 0) continue;
|
||||
try info.lsdas.append(info.gpa, @intCast(RecordIndex, i));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn calcSectionSize(info: UnwindInfo, zld: *Zld) !void {
|
||||
const sect_id = zld.getSectionByName("__TEXT", "__unwind_info") orelse return;
|
||||
const sect = &zld.sections.items(.header)[sect_id];
|
||||
sect.@"align" = 2;
|
||||
sect.size = info.calcRequiredSize();
|
||||
}
|
||||
|
||||
fn calcRequiredSize(info: UnwindInfo) usize {
|
||||
var total_size: usize = 0;
|
||||
total_size += @sizeOf(macho.unwind_info_section_header);
|
||||
total_size +=
|
||||
@intCast(usize, info.common_encodings_count) * @sizeOf(macho.compact_unwind_encoding_t);
|
||||
total_size += @intCast(usize, info.personalities_count) * @sizeOf(u32);
|
||||
total_size += (info.pages.items.len + 1) * @sizeOf(macho.unwind_info_section_header_index_entry);
|
||||
total_size += info.lsdas.items.len * @sizeOf(macho.unwind_info_section_header_lsda_index_entry);
|
||||
total_size += info.pages.items.len * second_level_page_bytes;
|
||||
return total_size;
|
||||
}
|
||||
|
||||
pub fn write(info: *UnwindInfo, zld: *Zld) !void {
|
||||
const sect_id = zld.getSectionByName("__TEXT", "__unwind_info") orelse return;
|
||||
const sect = &zld.sections.items(.header)[sect_id];
|
||||
const seg_id = zld.sections.items(.segment_index)[sect_id];
|
||||
const seg = zld.segments.items[seg_id];
|
||||
|
||||
const text_sect_id = zld.getSectionByName("__TEXT", "__text").?;
|
||||
const text_sect = zld.sections.items(.header)[text_sect_id];
|
||||
|
||||
var personalities: [max_personalities]u32 = undefined;
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
|
||||
log.debug("Personalities:", .{});
|
||||
for (info.personalities[0..info.personalities_count]) |target, i| {
|
||||
const atom_index = zld.getGotAtomIndexForSymbol(target).?;
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const sym = zld.getSymbol(atom.getSymbolWithLoc());
|
||||
personalities[i] = @intCast(u32, sym.n_value - seg.vmaddr);
|
||||
log.debug(" {d}: 0x{x} ({s})", .{ i, personalities[i], zld.getSymbolName(target) });
|
||||
}
|
||||
|
||||
for (info.records.items) |*rec| {
|
||||
// Finalize missing address values
|
||||
rec.rangeStart += text_sect.addr - seg.vmaddr;
|
||||
if (rec.personalityFunction > 0) {
|
||||
rec.personalityFunction = personalities[rec.personalityFunction - 1];
|
||||
}
|
||||
|
||||
if (rec.compactUnwindEncoding > 0 and !UnwindEncoding.isDwarf(rec.compactUnwindEncoding, cpu_arch)) {
|
||||
const lsda_target = @bitCast(SymbolWithLoc, rec.lsda);
|
||||
if (lsda_target.getFile()) |_| {
|
||||
const sym = zld.getSymbol(lsda_target);
|
||||
rec.lsda = sym.n_value - seg.vmaddr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (info.records.items) |record, i| {
|
||||
log.debug("Unwind record at offset 0x{x}", .{i * @sizeOf(macho.compact_unwind_entry)});
|
||||
log.debug(" start: 0x{x}", .{record.rangeStart});
|
||||
log.debug(" length: 0x{x}", .{record.rangeLength});
|
||||
log.debug(" compact encoding: 0x{x:0>8}", .{record.compactUnwindEncoding});
|
||||
log.debug(" personality: 0x{x}", .{record.personalityFunction});
|
||||
log.debug(" LSDA: 0x{x}", .{record.lsda});
|
||||
}
|
||||
|
||||
var buffer = std.ArrayList(u8).init(info.gpa);
|
||||
defer buffer.deinit();
|
||||
|
||||
const size = info.calcRequiredSize();
|
||||
try buffer.ensureTotalCapacityPrecise(size);
|
||||
|
||||
var cwriter = std.io.countingWriter(buffer.writer());
|
||||
const writer = cwriter.writer();
|
||||
|
||||
const common_encodings_offset: u32 = @sizeOf(macho.unwind_info_section_header);
|
||||
const common_encodings_count: u32 = info.common_encodings_count;
|
||||
const personalities_offset: u32 = common_encodings_offset + common_encodings_count * @sizeOf(u32);
|
||||
const personalities_count: u32 = info.personalities_count;
|
||||
const indexes_offset: u32 = personalities_offset + personalities_count * @sizeOf(u32);
|
||||
const indexes_count: u32 = @intCast(u32, info.pages.items.len + 1);
|
||||
|
||||
try writer.writeStruct(macho.unwind_info_section_header{
|
||||
.commonEncodingsArraySectionOffset = common_encodings_offset,
|
||||
.commonEncodingsArrayCount = common_encodings_count,
|
||||
.personalityArraySectionOffset = personalities_offset,
|
||||
.personalityArrayCount = personalities_count,
|
||||
.indexSectionOffset = indexes_offset,
|
||||
.indexCount = indexes_count,
|
||||
});
|
||||
|
||||
try writer.writeAll(mem.sliceAsBytes(info.common_encodings[0..info.common_encodings_count]));
|
||||
try writer.writeAll(mem.sliceAsBytes(personalities[0..info.personalities_count]));
|
||||
|
||||
const pages_base_offset = @intCast(u32, size - (info.pages.items.len * second_level_page_bytes));
|
||||
const lsda_base_offset = @intCast(u32, pages_base_offset -
|
||||
(info.lsdas.items.len * @sizeOf(macho.unwind_info_section_header_lsda_index_entry)));
|
||||
for (info.pages.items) |page, i| {
|
||||
assert(page.count > 0);
|
||||
const first_entry = info.records.items[page.start];
|
||||
try writer.writeStruct(macho.unwind_info_section_header_index_entry{
|
||||
.functionOffset = @intCast(u32, first_entry.rangeStart),
|
||||
.secondLevelPagesSectionOffset = @intCast(u32, pages_base_offset + i * second_level_page_bytes),
|
||||
.lsdaIndexArraySectionOffset = lsda_base_offset +
|
||||
info.lsdas_lookup.get(page.start).? * @sizeOf(macho.unwind_info_section_header_lsda_index_entry),
|
||||
});
|
||||
}
|
||||
|
||||
const last_entry = info.records.items[info.records.items.len - 1];
|
||||
const sentinel_address = @intCast(u32, last_entry.rangeStart + last_entry.rangeLength);
|
||||
try writer.writeStruct(macho.unwind_info_section_header_index_entry{
|
||||
.functionOffset = sentinel_address,
|
||||
.secondLevelPagesSectionOffset = 0,
|
||||
.lsdaIndexArraySectionOffset = lsda_base_offset +
|
||||
@intCast(u32, info.lsdas.items.len) * @sizeOf(macho.unwind_info_section_header_lsda_index_entry),
|
||||
});
|
||||
|
||||
for (info.lsdas.items) |record_id| {
|
||||
const record = info.records.items[record_id];
|
||||
try writer.writeStruct(macho.unwind_info_section_header_lsda_index_entry{
|
||||
.functionOffset = @intCast(u32, record.rangeStart),
|
||||
.lsdaOffset = @intCast(u32, record.lsda),
|
||||
});
|
||||
}
|
||||
|
||||
for (info.pages.items) |page| {
|
||||
const start = cwriter.bytes_written;
|
||||
try page.write(info, writer);
|
||||
const nwritten = cwriter.bytes_written - start;
|
||||
if (nwritten < second_level_page_bytes) {
|
||||
try writer.writeByteNTimes(0, second_level_page_bytes - nwritten);
|
||||
}
|
||||
}
|
||||
|
||||
const padding = buffer.items.len - cwriter.bytes_written;
|
||||
if (padding > 0) {
|
||||
mem.set(u8, buffer.items[cwriter.bytes_written..], 0);
|
||||
}
|
||||
|
||||
try zld.file.pwriteAll(buffer.items, sect.offset);
|
||||
}
|
||||
|
||||
pub fn parseRelocTarget(
|
||||
zld: *Zld,
|
||||
object_id: u32,
|
||||
rel: macho.relocation_info,
|
||||
code: []const u8,
|
||||
base_offset: i32,
|
||||
) SymbolWithLoc {
|
||||
const tracy = trace(@src());
|
||||
defer tracy.end();
|
||||
|
||||
const object = &zld.objects.items[object_id];
|
||||
|
||||
const sym_index = if (rel.r_extern == 0) blk: {
|
||||
const sect_id = @intCast(u8, rel.r_symbolnum - 1);
|
||||
const rel_offset = @intCast(u32, rel.r_address - base_offset);
|
||||
assert(rel.r_pcrel == 0 and rel.r_length == 3);
|
||||
const address_in_section = mem.readIntLittle(u64, code[rel_offset..][0..8]);
|
||||
const sym_index = object.getSymbolByAddress(address_in_section, sect_id);
|
||||
break :blk sym_index;
|
||||
} else object.reverse_symtab_lookup[rel.r_symbolnum];
|
||||
|
||||
const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = object_id + 1 };
|
||||
const sym = zld.getSymbol(sym_loc);
|
||||
|
||||
if (sym.sect() and !sym.ext()) {
|
||||
// Make sure we are not dealing with a local alias.
|
||||
const atom_index = object.getAtomIndexForSymbol(sym_index) orelse
|
||||
return sym_loc;
|
||||
const atom = zld.getAtom(atom_index);
|
||||
return atom.getSymbolWithLoc();
|
||||
} else if (object.getGlobal(sym_index)) |global_index| {
|
||||
return zld.globals.items[global_index];
|
||||
} else return sym_loc;
|
||||
}
|
||||
|
||||
fn getRelocs(
|
||||
zld: *Zld,
|
||||
object_id: u32,
|
||||
record_id: usize,
|
||||
) []align(1) const macho.relocation_info {
|
||||
const object = &zld.objects.items[object_id];
|
||||
assert(object.hasUnwindRecords());
|
||||
const rel_pos = object.unwind_relocs_lookup[record_id].reloc;
|
||||
const relocs = object.getRelocs(object.unwind_info_sect.?);
|
||||
return relocs[rel_pos.start..][0..rel_pos.len];
|
||||
}
|
||||
|
||||
fn isPersonalityFunction(record_id: usize, rel: macho.relocation_info) bool {
|
||||
const base_offset = @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry));
|
||||
const rel_offset = rel.r_address - base_offset;
|
||||
return rel_offset == 16;
|
||||
}
|
||||
|
||||
pub fn getPersonalityFunctionReloc(
|
||||
zld: *Zld,
|
||||
object_id: u32,
|
||||
record_id: usize,
|
||||
) ?macho.relocation_info {
|
||||
const relocs = getRelocs(zld, object_id, record_id);
|
||||
for (relocs) |rel| {
|
||||
if (isPersonalityFunction(record_id, rel)) return rel;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
fn getPersonalityFunction(info: UnwindInfo, global_index: SymbolWithLoc) ?u2 {
|
||||
comptime var index: u2 = 0;
|
||||
inline while (index < max_personalities) : (index += 1) {
|
||||
if (index >= info.personalities_count) return null;
|
||||
if (info.personalities[index].eql(global_index)) {
|
||||
return index;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
fn isLsda(record_id: usize, rel: macho.relocation_info) bool {
|
||||
const base_offset = @intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry));
|
||||
const rel_offset = rel.r_address - base_offset;
|
||||
return rel_offset == 24;
|
||||
}
|
||||
|
||||
pub fn getLsdaReloc(zld: *Zld, object_id: u32, record_id: usize) ?macho.relocation_info {
|
||||
const relocs = getRelocs(zld, object_id, record_id);
|
||||
for (relocs) |rel| {
|
||||
if (isLsda(record_id, rel)) return rel;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
pub fn isNull(rec: macho.compact_unwind_entry) bool {
|
||||
return rec.rangeStart == 0 and
|
||||
rec.rangeLength == 0 and
|
||||
rec.compactUnwindEncoding == 0 and
|
||||
rec.lsda == 0 and
|
||||
rec.personalityFunction == 0;
|
||||
}
|
||||
|
||||
inline fn nullRecord() macho.compact_unwind_entry {
|
||||
return .{
|
||||
.rangeStart = 0,
|
||||
.rangeLength = 0,
|
||||
.compactUnwindEncoding = 0,
|
||||
.personalityFunction = 0,
|
||||
.lsda = 0,
|
||||
};
|
||||
}
|
||||
|
||||
fn appendCommonEncoding(info: *UnwindInfo, enc: macho.compact_unwind_encoding_t) void {
|
||||
assert(info.common_encodings_count <= max_common_encodings);
|
||||
info.common_encodings[info.common_encodings_count] = enc;
|
||||
info.common_encodings_count += 1;
|
||||
}
|
||||
|
||||
fn getCommonEncoding(info: UnwindInfo, enc: macho.compact_unwind_encoding_t) ?u7 {
|
||||
comptime var index: u7 = 0;
|
||||
inline while (index < max_common_encodings) : (index += 1) {
|
||||
if (index >= info.common_encodings_count) return null;
|
||||
if (info.common_encodings[index] == enc) {
|
||||
return index;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
pub const UnwindEncoding = struct {
|
||||
pub const UNWIND_X86_64_MODE = enum(u4) {
|
||||
none = 0,
|
||||
ebp_frame = 1,
|
||||
stack_immd = 2,
|
||||
stack_ind = 3,
|
||||
dwarf = 4,
|
||||
};
|
||||
|
||||
pub const UNWIND_ARM64_MODE = enum(u4) {
|
||||
none = 0,
|
||||
frameless = 2,
|
||||
dwarf = 3,
|
||||
frame = 4,
|
||||
};
|
||||
|
||||
pub const UNWIND_MODE_MASK: u32 = 0x0F000000;
|
||||
pub const UNWIND_PERSONALITY_INDEX_MASK: u32 = 0x30000000;
|
||||
pub const UNWIND_HAS_LSDA_MASK: u32 = 0x40000000;
|
||||
|
||||
pub fn getMode(enc: macho.compact_unwind_encoding_t) u4 {
|
||||
const mode = @truncate(u4, (enc & UNWIND_MODE_MASK) >> 24);
|
||||
return mode;
|
||||
}
|
||||
|
||||
pub fn isDwarf(enc: macho.compact_unwind_encoding_t, cpu_arch: std.Target.Cpu.Arch) bool {
|
||||
switch (cpu_arch) {
|
||||
.aarch64 => return @intToEnum(UNWIND_ARM64_MODE, getMode(enc)) == .dwarf,
|
||||
.x86_64 => return @intToEnum(UNWIND_X86_64_MODE, getMode(enc)) == .dwarf,
|
||||
else => unreachable,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn hasLsda(enc: macho.compact_unwind_encoding_t) bool {
|
||||
const has_lsda = @truncate(u1, (enc & UNWIND_HAS_LSDA_MASK) >> 31);
|
||||
return has_lsda == 1;
|
||||
}
|
||||
|
||||
pub fn setHasLsda(enc: *macho.compact_unwind_encoding_t, has_lsda: bool) void {
|
||||
const mask = @intCast(u32, @boolToInt(has_lsda)) << 31;
|
||||
enc.* |= mask;
|
||||
}
|
||||
|
||||
pub fn getPersonalityIndex(enc: macho.compact_unwind_encoding_t) u2 {
|
||||
const index = @truncate(u2, (enc & UNWIND_PERSONALITY_INDEX_MASK) >> 28);
|
||||
return index;
|
||||
}
|
||||
|
||||
pub fn setPersonalityIndex(enc: *macho.compact_unwind_encoding_t, index: u2) void {
|
||||
const mask = @intCast(u32, index) << 28;
|
||||
enc.* |= mask;
|
||||
}
|
||||
|
||||
pub fn getDwarfSectionOffset(enc: macho.compact_unwind_encoding_t, cpu_arch: std.Target.Cpu.Arch) u24 {
|
||||
assert(isDwarf(enc, cpu_arch));
|
||||
const offset = @truncate(u24, enc);
|
||||
return offset;
|
||||
}
|
||||
|
||||
pub fn setDwarfSectionOffset(enc: *macho.compact_unwind_encoding_t, cpu_arch: std.Target.Cpu.Arch, offset: u24) void {
|
||||
assert(isDwarf(enc.*, cpu_arch));
|
||||
enc.* |= offset;
|
||||
}
|
||||
};
|
||||
@ -29,11 +29,11 @@ const Zld = @import("zld.zig").Zld;
|
||||
/// a stub trampoline, it can be found in the linkers `locals` arraylist.
|
||||
sym_index: u32,
|
||||
|
||||
/// -1 means an Atom is a synthetic Atom such as a GOT cell defined by the linker.
|
||||
/// Otherwise, it is the index into appropriate object file.
|
||||
/// 0 means an Atom is a synthetic Atom such as a GOT cell defined by the linker.
|
||||
/// Otherwise, it is the index into appropriate object file (indexing from 1).
|
||||
/// Prefer using `getFile()` helper to get the file index out rather than using
|
||||
/// the field directly.
|
||||
file: i32,
|
||||
file: u32,
|
||||
|
||||
/// If this Atom is not a synthetic Atom, i.e., references a subsection in an
|
||||
/// Object file, `inner_sym_index` and `inner_nsyms_trailing` tell where and if
|
||||
@ -51,13 +51,6 @@ size: u64,
|
||||
/// For instance, aligmment of 0 should be read as 2^0 = 1 byte aligned.
|
||||
alignment: u32,
|
||||
|
||||
/// Cached index and length into the relocations records array that correspond to
|
||||
/// this Atom and need to be resolved before the Atom can be committed into the
|
||||
/// final linked image.
|
||||
/// Do not use these fields directly. Instead, use `getAtomRelocs()` helper.
|
||||
cached_relocs_start: i32,
|
||||
cached_relocs_len: u32,
|
||||
|
||||
/// Points to the previous and next neighbours
|
||||
next_index: ?AtomIndex,
|
||||
prev_index: ?AtomIndex,
|
||||
@ -66,20 +59,18 @@ pub const empty = Atom{
|
||||
.sym_index = 0,
|
||||
.inner_sym_index = 0,
|
||||
.inner_nsyms_trailing = 0,
|
||||
.file = -1,
|
||||
.file = 0,
|
||||
.size = 0,
|
||||
.alignment = 0,
|
||||
.cached_relocs_start = -1,
|
||||
.cached_relocs_len = 0,
|
||||
.prev_index = null,
|
||||
.next_index = null,
|
||||
};
|
||||
|
||||
/// Returns `null` if the Atom is a synthetic Atom.
|
||||
/// Otherwise, returns an index into an array of Objects.
|
||||
pub inline fn getFile(self: Atom) ?u31 {
|
||||
if (self.file == -1) return null;
|
||||
return @intCast(u31, self.file);
|
||||
pub fn getFile(self: Atom) ?u32 {
|
||||
if (self.file == 0) return null;
|
||||
return self.file - 1;
|
||||
}
|
||||
|
||||
pub inline fn getSymbolWithLoc(self: Atom) SymbolWithLoc {
|
||||
@ -92,7 +83,7 @@ pub inline fn getSymbolWithLoc(self: Atom) SymbolWithLoc {
|
||||
const InnerSymIterator = struct {
|
||||
sym_index: u32,
|
||||
count: u32,
|
||||
file: i32,
|
||||
file: u32,
|
||||
|
||||
pub fn next(it: *@This()) ?SymbolWithLoc {
|
||||
if (it.count == 0) return null;
|
||||
@ -159,19 +150,14 @@ pub fn calcInnerSymbolOffset(zld: *Zld, atom_index: AtomIndex, sym_index: u32) u
|
||||
return source_sym.n_value - base_addr;
|
||||
}
|
||||
|
||||
pub fn scanAtomRelocs(
|
||||
zld: *Zld,
|
||||
atom_index: AtomIndex,
|
||||
relocs: []align(1) const macho.relocation_info,
|
||||
reverse_lookup: []u32,
|
||||
) !void {
|
||||
pub fn scanAtomRelocs(zld: *Zld, atom_index: AtomIndex, relocs: []align(1) const macho.relocation_info) !void {
|
||||
const arch = zld.options.target.cpu.arch;
|
||||
const atom = zld.getAtom(atom_index);
|
||||
assert(atom.getFile() != null); // synthetic atoms do not have relocs
|
||||
|
||||
return switch (arch) {
|
||||
.aarch64 => scanAtomRelocsArm64(zld, atom_index, relocs, reverse_lookup),
|
||||
.x86_64 => scanAtomRelocsX86(zld, atom_index, relocs, reverse_lookup),
|
||||
.aarch64 => scanAtomRelocsArm64(zld, atom_index, relocs),
|
||||
.x86_64 => scanAtomRelocsX86(zld, atom_index, relocs),
|
||||
else => unreachable,
|
||||
};
|
||||
}
|
||||
@ -202,16 +188,11 @@ pub fn getRelocContext(zld: *Zld, atom_index: AtomIndex) RelocContext {
|
||||
};
|
||||
}
|
||||
|
||||
pub fn parseRelocTarget(
|
||||
zld: *Zld,
|
||||
atom_index: AtomIndex,
|
||||
rel: macho.relocation_info,
|
||||
reverse_lookup: []u32,
|
||||
) SymbolWithLoc {
|
||||
pub fn parseRelocTarget(zld: *Zld, atom_index: AtomIndex, rel: macho.relocation_info) SymbolWithLoc {
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const object = &zld.objects.items[atom.getFile().?];
|
||||
|
||||
if (rel.r_extern == 0) {
|
||||
const sym_index = if (rel.r_extern == 0) sym_index: {
|
||||
const sect_id = @intCast(u8, rel.r_symbolnum - 1);
|
||||
const ctx = getRelocContext(zld, atom_index);
|
||||
const atom_code = getAtomCode(zld, atom_index);
|
||||
@ -219,9 +200,9 @@ pub fn parseRelocTarget(
|
||||
|
||||
const address_in_section = if (rel.r_pcrel == 0) blk: {
|
||||
break :blk if (rel.r_length == 3)
|
||||
mem.readIntLittle(i64, atom_code[rel_offset..][0..8])
|
||||
mem.readIntLittle(u64, atom_code[rel_offset..][0..8])
|
||||
else
|
||||
mem.readIntLittle(i32, atom_code[rel_offset..][0..4]);
|
||||
mem.readIntLittle(u32, atom_code[rel_offset..][0..4]);
|
||||
} else blk: {
|
||||
const correction: u3 = switch (@intToEnum(macho.reloc_type_x86_64, rel.r_type)) {
|
||||
.X86_64_RELOC_SIGNED => 0,
|
||||
@ -232,38 +213,14 @@ pub fn parseRelocTarget(
|
||||
};
|
||||
const addend = mem.readIntLittle(i32, atom_code[rel_offset..][0..4]);
|
||||
const target_address = @intCast(i64, ctx.base_addr) + rel.r_address + 4 + correction + addend;
|
||||
break :blk target_address;
|
||||
break :blk @intCast(u64, target_address);
|
||||
};
|
||||
|
||||
// Find containing atom
|
||||
const Predicate = struct {
|
||||
addr: i64,
|
||||
const sym_index = object.getSymbolByAddress(address_in_section, sect_id);
|
||||
break :sym_index sym_index;
|
||||
} else object.reverse_symtab_lookup[rel.r_symbolnum];
|
||||
|
||||
pub fn predicate(pred: @This(), other: i64) bool {
|
||||
return if (other == -1) true else other > pred.addr;
|
||||
}
|
||||
};
|
||||
|
||||
if (object.source_section_index_lookup[sect_id] > -1) {
|
||||
const first_sym_index = @intCast(usize, object.source_section_index_lookup[sect_id]);
|
||||
const target_sym_index = @import("zld.zig").lsearch(i64, object.source_address_lookup[first_sym_index..], Predicate{
|
||||
.addr = address_in_section,
|
||||
});
|
||||
|
||||
if (target_sym_index > 0) {
|
||||
return SymbolWithLoc{
|
||||
.sym_index = @intCast(u32, first_sym_index + target_sym_index - 1),
|
||||
.file = atom.file,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Start of section is not contained anywhere, return synthetic atom.
|
||||
const sym_index = object.getSectionAliasSymbolIndex(sect_id);
|
||||
return SymbolWithLoc{ .sym_index = sym_index, .file = atom.file };
|
||||
}
|
||||
|
||||
const sym_index = reverse_lookup[rel.r_symbolnum];
|
||||
const sym_loc = SymbolWithLoc{
|
||||
.sym_index = sym_index,
|
||||
.file = atom.file,
|
||||
@ -272,30 +229,12 @@ pub fn parseRelocTarget(
|
||||
|
||||
if (sym.sect() and !sym.ext()) {
|
||||
return sym_loc;
|
||||
} else if (object.globals_lookup[sym_index] > -1) {
|
||||
const global_index = @intCast(u32, object.globals_lookup[sym_index]);
|
||||
} else if (object.getGlobal(sym_index)) |global_index| {
|
||||
return zld.globals.items[global_index];
|
||||
} else return sym_loc;
|
||||
}
|
||||
|
||||
pub fn getRelocTargetAtomIndex(zld: *Zld, rel: macho.relocation_info, target: SymbolWithLoc) ?AtomIndex {
|
||||
const is_via_got = got: {
|
||||
switch (zld.options.target.cpu.arch) {
|
||||
.aarch64 => break :got switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) {
|
||||
.ARM64_RELOC_GOT_LOAD_PAGE21,
|
||||
.ARM64_RELOC_GOT_LOAD_PAGEOFF12,
|
||||
.ARM64_RELOC_POINTER_TO_GOT,
|
||||
=> true,
|
||||
else => false,
|
||||
},
|
||||
.x86_64 => break :got switch (@intToEnum(macho.reloc_type_x86_64, rel.r_type)) {
|
||||
.X86_64_RELOC_GOT, .X86_64_RELOC_GOT_LOAD => true,
|
||||
else => false,
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
};
|
||||
|
||||
pub fn getRelocTargetAtomIndex(zld: *Zld, target: SymbolWithLoc, is_via_got: bool) ?AtomIndex {
|
||||
if (is_via_got) {
|
||||
return zld.getGotAtomIndexForSymbol(target).?; // panic means fatal error
|
||||
}
|
||||
@ -314,12 +253,7 @@ pub fn getRelocTargetAtomIndex(zld: *Zld, rel: macho.relocation_info, target: Sy
|
||||
return object.getAtomIndexForSymbol(target.sym_index);
|
||||
}
|
||||
|
||||
fn scanAtomRelocsArm64(
|
||||
zld: *Zld,
|
||||
atom_index: AtomIndex,
|
||||
relocs: []align(1) const macho.relocation_info,
|
||||
reverse_lookup: []u32,
|
||||
) !void {
|
||||
fn scanAtomRelocsArm64(zld: *Zld, atom_index: AtomIndex, relocs: []align(1) const macho.relocation_info) !void {
|
||||
for (relocs) |rel| {
|
||||
const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type);
|
||||
|
||||
@ -332,7 +266,7 @@ fn scanAtomRelocsArm64(
|
||||
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const object = &zld.objects.items[atom.getFile().?];
|
||||
const sym_index = reverse_lookup[rel.r_symbolnum];
|
||||
const sym_index = object.reverse_symtab_lookup[rel.r_symbolnum];
|
||||
const sym_loc = SymbolWithLoc{
|
||||
.sym_index = sym_index,
|
||||
.file = atom.file,
|
||||
@ -341,10 +275,10 @@ fn scanAtomRelocsArm64(
|
||||
|
||||
if (sym.sect() and !sym.ext()) continue;
|
||||
|
||||
const target = if (object.globals_lookup[sym_index] > -1) blk: {
|
||||
const global_index = @intCast(u32, object.globals_lookup[sym_index]);
|
||||
break :blk zld.globals.items[global_index];
|
||||
} else sym_loc;
|
||||
const target = if (object.getGlobal(sym_index)) |global_index|
|
||||
zld.globals.items[global_index]
|
||||
else
|
||||
sym_loc;
|
||||
|
||||
switch (rel_type) {
|
||||
.ARM64_RELOC_BRANCH26 => {
|
||||
@ -368,12 +302,7 @@ fn scanAtomRelocsArm64(
|
||||
}
|
||||
}
|
||||
|
||||
fn scanAtomRelocsX86(
|
||||
zld: *Zld,
|
||||
atom_index: AtomIndex,
|
||||
relocs: []align(1) const macho.relocation_info,
|
||||
reverse_lookup: []u32,
|
||||
) !void {
|
||||
fn scanAtomRelocsX86(zld: *Zld, atom_index: AtomIndex, relocs: []align(1) const macho.relocation_info) !void {
|
||||
for (relocs) |rel| {
|
||||
const rel_type = @intToEnum(macho.reloc_type_x86_64, rel.r_type);
|
||||
|
||||
@ -386,7 +315,7 @@ fn scanAtomRelocsX86(
|
||||
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const object = &zld.objects.items[atom.getFile().?];
|
||||
const sym_index = reverse_lookup[rel.r_symbolnum];
|
||||
const sym_index = object.reverse_symtab_lookup[rel.r_symbolnum];
|
||||
const sym_loc = SymbolWithLoc{
|
||||
.sym_index = sym_index,
|
||||
.file = atom.file,
|
||||
@ -395,10 +324,10 @@ fn scanAtomRelocsX86(
|
||||
|
||||
if (sym.sect() and !sym.ext()) continue;
|
||||
|
||||
const target = if (object.globals_lookup[sym_index] > -1) blk: {
|
||||
const global_index = @intCast(u32, object.globals_lookup[sym_index]);
|
||||
break :blk zld.globals.items[global_index];
|
||||
} else sym_loc;
|
||||
const target = if (object.getGlobal(sym_index)) |global_index|
|
||||
zld.globals.items[global_index]
|
||||
else
|
||||
sym_loc;
|
||||
|
||||
switch (rel_type) {
|
||||
.X86_64_RELOC_BRANCH => {
|
||||
@ -432,7 +361,7 @@ fn addTlvPtrEntry(zld: *Zld, target: SymbolWithLoc) !void {
|
||||
try zld.tlv_ptr_table.putNoClobber(gpa, target, tlv_ptr_index);
|
||||
}
|
||||
|
||||
fn addGotEntry(zld: *Zld, target: SymbolWithLoc) !void {
|
||||
pub fn addGotEntry(zld: *Zld, target: SymbolWithLoc) !void {
|
||||
if (zld.got_table.contains(target)) return;
|
||||
const gpa = zld.gpa;
|
||||
const atom_index = try zld.createGotAtom();
|
||||
@ -466,7 +395,6 @@ pub fn resolveRelocs(
|
||||
atom_index: AtomIndex,
|
||||
atom_code: []u8,
|
||||
atom_relocs: []align(1) const macho.relocation_info,
|
||||
reverse_lookup: []u32,
|
||||
) !void {
|
||||
const arch = zld.options.target.cpu.arch;
|
||||
const atom = zld.getAtom(atom_index);
|
||||
@ -480,14 +408,14 @@ pub fn resolveRelocs(
|
||||
const ctx = getRelocContext(zld, atom_index);
|
||||
|
||||
return switch (arch) {
|
||||
.aarch64 => resolveRelocsArm64(zld, atom_index, atom_code, atom_relocs, reverse_lookup, ctx),
|
||||
.x86_64 => resolveRelocsX86(zld, atom_index, atom_code, atom_relocs, reverse_lookup, ctx),
|
||||
.aarch64 => resolveRelocsArm64(zld, atom_index, atom_code, atom_relocs, ctx),
|
||||
.x86_64 => resolveRelocsX86(zld, atom_index, atom_code, atom_relocs, ctx),
|
||||
else => unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn getRelocTargetAddress(zld: *Zld, rel: macho.relocation_info, target: SymbolWithLoc, is_tlv: bool) !u64 {
|
||||
const target_atom_index = getRelocTargetAtomIndex(zld, rel, target) orelse {
|
||||
pub fn getRelocTargetAddress(zld: *Zld, target: SymbolWithLoc, is_via_got: bool, is_tlv: bool) !u64 {
|
||||
const target_atom_index = getRelocTargetAtomIndex(zld, target, is_via_got) orelse {
|
||||
// If there is no atom for target, we still need to check for special, atom-less
|
||||
// symbols such as `___dso_handle`.
|
||||
const target_name = zld.getSymbolName(target);
|
||||
@ -499,7 +427,7 @@ pub fn getRelocTargetAddress(zld: *Zld, rel: macho.relocation_info, target: Symb
|
||||
log.debug(" | target ATOM(%{d}, '{s}') in object({?})", .{
|
||||
target_atom.sym_index,
|
||||
zld.getSymbolName(target_atom.getSymbolWithLoc()),
|
||||
target_atom.file,
|
||||
target_atom.getFile(),
|
||||
});
|
||||
|
||||
const target_sym = zld.getSymbol(target_atom.getSymbolWithLoc());
|
||||
@ -541,7 +469,6 @@ fn resolveRelocsArm64(
|
||||
atom_index: AtomIndex,
|
||||
atom_code: []u8,
|
||||
atom_relocs: []align(1) const macho.relocation_info,
|
||||
reverse_lookup: []u32,
|
||||
context: RelocContext,
|
||||
) !void {
|
||||
const atom = zld.getAtom(atom_index);
|
||||
@ -565,20 +492,20 @@ fn resolveRelocsArm64(
|
||||
.ARM64_RELOC_SUBTRACTOR => {
|
||||
assert(subtractor == null);
|
||||
|
||||
log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{
|
||||
log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{
|
||||
@tagName(rel_type),
|
||||
rel.r_address,
|
||||
rel.r_symbolnum,
|
||||
atom.file,
|
||||
atom.getFile(),
|
||||
});
|
||||
|
||||
subtractor = parseRelocTarget(zld, atom_index, rel, reverse_lookup);
|
||||
subtractor = parseRelocTarget(zld, atom_index, rel);
|
||||
continue;
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
|
||||
const target = parseRelocTarget(zld, atom_index, rel, reverse_lookup);
|
||||
const target = parseRelocTarget(zld, atom_index, rel);
|
||||
const rel_offset = @intCast(u32, rel.r_address - context.base_offset);
|
||||
|
||||
log.debug(" RELA({s}) @ {x} => %{d} ('{s}') in object({?})", .{
|
||||
@ -586,19 +513,20 @@ fn resolveRelocsArm64(
|
||||
rel.r_address,
|
||||
target.sym_index,
|
||||
zld.getSymbolName(target),
|
||||
target.file,
|
||||
target.getFile(),
|
||||
});
|
||||
|
||||
const source_addr = blk: {
|
||||
const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
|
||||
break :blk source_sym.n_value + rel_offset;
|
||||
};
|
||||
const is_via_got = relocRequiresGot(zld, rel);
|
||||
const is_tlv = is_tlv: {
|
||||
const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
|
||||
const header = zld.sections.items(.header)[source_sym.n_sect - 1];
|
||||
break :is_tlv header.type() == macho.S_THREAD_LOCAL_VARIABLES;
|
||||
};
|
||||
const target_addr = try getRelocTargetAddress(zld, rel, target, is_tlv);
|
||||
const target_addr = try getRelocTargetAddress(zld, target, is_via_got, is_tlv);
|
||||
|
||||
log.debug(" | source_addr = 0x{x}", .{source_addr});
|
||||
|
||||
@ -610,9 +538,9 @@ fn resolveRelocsArm64(
|
||||
} else target;
|
||||
log.debug(" source {s} (object({?})), target {s} (object({?}))", .{
|
||||
zld.getSymbolName(atom.getSymbolWithLoc()),
|
||||
atom.file,
|
||||
atom.getFile(),
|
||||
zld.getSymbolName(target),
|
||||
zld.getAtom(getRelocTargetAtomIndex(zld, rel, target).?).file,
|
||||
zld.getAtom(getRelocTargetAtomIndex(zld, target, is_via_got).?).getFile(),
|
||||
});
|
||||
|
||||
const displacement = if (calcPcRelativeDisplacementArm64(
|
||||
@ -628,7 +556,7 @@ fn resolveRelocsArm64(
|
||||
zld,
|
||||
actual_target,
|
||||
).?);
|
||||
log.debug(" | target_addr = 0x{x}", .{thunk_sym.n_value});
|
||||
log.debug(" | target_addr = 0x{x} (thunk)", .{thunk_sym.n_value});
|
||||
break :blk try calcPcRelativeDisplacementArm64(source_addr, thunk_sym.n_value);
|
||||
};
|
||||
|
||||
@ -832,7 +760,6 @@ fn resolveRelocsX86(
|
||||
atom_index: AtomIndex,
|
||||
atom_code: []u8,
|
||||
atom_relocs: []align(1) const macho.relocation_info,
|
||||
reverse_lookup: []u32,
|
||||
context: RelocContext,
|
||||
) !void {
|
||||
const atom = zld.getAtom(atom_index);
|
||||
@ -847,33 +774,34 @@ fn resolveRelocsX86(
|
||||
.X86_64_RELOC_SUBTRACTOR => {
|
||||
assert(subtractor == null);
|
||||
|
||||
log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{
|
||||
log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{
|
||||
@tagName(rel_type),
|
||||
rel.r_address,
|
||||
rel.r_symbolnum,
|
||||
atom.file,
|
||||
atom.getFile(),
|
||||
});
|
||||
|
||||
subtractor = parseRelocTarget(zld, atom_index, rel, reverse_lookup);
|
||||
subtractor = parseRelocTarget(zld, atom_index, rel);
|
||||
continue;
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
|
||||
const target = parseRelocTarget(zld, atom_index, rel, reverse_lookup);
|
||||
const target = parseRelocTarget(zld, atom_index, rel);
|
||||
const rel_offset = @intCast(u32, rel.r_address - context.base_offset);
|
||||
|
||||
log.debug(" RELA({s}) @ {x} => %{d} in object({?})", .{
|
||||
@tagName(rel_type),
|
||||
rel.r_address,
|
||||
target.sym_index,
|
||||
target.file,
|
||||
target.getFile(),
|
||||
});
|
||||
|
||||
const source_addr = blk: {
|
||||
const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
|
||||
break :blk source_sym.n_value + rel_offset;
|
||||
};
|
||||
const is_via_got = relocRequiresGot(zld, rel);
|
||||
const is_tlv = is_tlv: {
|
||||
const source_sym = zld.getSymbol(atom.getSymbolWithLoc());
|
||||
const header = zld.sections.items(.header)[source_sym.n_sect - 1];
|
||||
@ -882,7 +810,7 @@ fn resolveRelocsX86(
|
||||
|
||||
log.debug(" | source_addr = 0x{x}", .{source_addr});
|
||||
|
||||
const target_addr = try getRelocTargetAddress(zld, rel, target, is_tlv);
|
||||
const target_addr = try getRelocTargetAddress(zld, target, is_via_got, is_tlv);
|
||||
|
||||
switch (rel_type) {
|
||||
.X86_64_RELOC_BRANCH => {
|
||||
@ -1016,9 +944,10 @@ pub fn getAtomCode(zld: *Zld, atom_index: AtomIndex) []const u8 {
|
||||
}
|
||||
|
||||
pub fn getAtomRelocs(zld: *Zld, atom_index: AtomIndex) []align(1) const macho.relocation_info {
|
||||
const atom = zld.getAtomPtr(atom_index);
|
||||
const atom = zld.getAtom(atom_index);
|
||||
assert(atom.getFile() != null); // Synthetic atom shouldn't need to unique for relocs.
|
||||
const object = zld.objects.items[atom.getFile().?];
|
||||
const cache = object.relocs_lookup[atom.sym_index];
|
||||
|
||||
const source_sect = if (object.getSourceSymbol(atom.sym_index)) |source_sym| blk: {
|
||||
const source_sect = object.getSourceSection(source_sym.n_sect - 1);
|
||||
@ -1036,43 +965,7 @@ pub fn getAtomRelocs(zld: *Zld, atom_index: AtomIndex) []align(1) const macho.re
|
||||
};
|
||||
|
||||
const relocs = object.getRelocs(source_sect);
|
||||
|
||||
if (atom.cached_relocs_start == -1) {
|
||||
const indexes = if (object.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);
|
||||
atom.cached_relocs_start = indexes.start;
|
||||
atom.cached_relocs_len = indexes.len;
|
||||
}
|
||||
|
||||
return relocs[@intCast(u32, atom.cached_relocs_start)..][0..atom.cached_relocs_len];
|
||||
}
|
||||
|
||||
fn filterRelocs(
|
||||
relocs: []align(1) const macho.relocation_info,
|
||||
start_addr: u64,
|
||||
end_addr: u64,
|
||||
) struct { start: i32, len: u32 } {
|
||||
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(i32, start), .len = @intCast(u32, len) };
|
||||
return relocs[cache.start..][0..cache.len];
|
||||
}
|
||||
|
||||
pub fn calcPcRelativeDisplacementX86(source_addr: u64, target_addr: u64, correction: u3) error{Overflow}!i32 {
|
||||
@ -1111,3 +1004,22 @@ pub fn calcPageOffset(target_addr: u64, kind: PageOffsetInstKind) !u12 {
|
||||
.load_store_128 => try math.divExact(u12, narrowed, 16),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn relocRequiresGot(zld: *Zld, rel: macho.relocation_info) bool {
|
||||
switch (zld.options.target.cpu.arch) {
|
||||
.aarch64 => switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) {
|
||||
.ARM64_RELOC_GOT_LOAD_PAGE21,
|
||||
.ARM64_RELOC_GOT_LOAD_PAGEOFF12,
|
||||
.ARM64_RELOC_POINTER_TO_GOT,
|
||||
=> return true,
|
||||
else => return false,
|
||||
},
|
||||
.x86_64 => switch (@intToEnum(macho.reloc_type_x86_64, rel.r_type)) {
|
||||
.X86_64_RELOC_GOT,
|
||||
.X86_64_RELOC_GOT_LOAD,
|
||||
=> return true,
|
||||
else => return false,
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
}
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const eh_frame = @import("eh_frame.zig");
|
||||
const log = std.log.scoped(.dead_strip);
|
||||
const macho = std.macho;
|
||||
const math = std.math;
|
||||
@ -11,13 +12,14 @@ const Allocator = mem.Allocator;
|
||||
const AtomIndex = @import("zld.zig").AtomIndex;
|
||||
const Atom = @import("ZldAtom.zig");
|
||||
const SymbolWithLoc = @import("zld.zig").SymbolWithLoc;
|
||||
const UnwindInfo = @import("UnwindInfo.zig");
|
||||
const Zld = @import("zld.zig").Zld;
|
||||
|
||||
const N_DEAD = @import("zld.zig").N_DEAD;
|
||||
|
||||
const AtomTable = std.AutoHashMap(AtomIndex, void);
|
||||
|
||||
pub fn gcAtoms(zld: *Zld, reverse_lookups: [][]u32) Allocator.Error!void {
|
||||
pub fn gcAtoms(zld: *Zld) !void {
|
||||
const gpa = zld.gpa;
|
||||
|
||||
var arena = std.heap.ArenaAllocator.init(gpa);
|
||||
@ -30,7 +32,7 @@ pub fn gcAtoms(zld: *Zld, reverse_lookups: [][]u32) Allocator.Error!void {
|
||||
try alive.ensureTotalCapacity(@intCast(u32, zld.atoms.items.len));
|
||||
|
||||
try collectRoots(zld, &roots);
|
||||
mark(zld, roots, &alive, reverse_lookups);
|
||||
try mark(zld, roots, &alive);
|
||||
prune(zld, alive);
|
||||
}
|
||||
|
||||
@ -45,10 +47,10 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
|
||||
const atom_index = object.getAtomIndexForSymbol(global.sym_index).?; // panic here means fatal error
|
||||
_ = try roots.getOrPut(atom_index);
|
||||
|
||||
log.debug("root(ATOM({d}, %{d}, {d}))", .{
|
||||
log.debug("root(ATOM({d}, %{d}, {?d}))", .{
|
||||
atom_index,
|
||||
zld.getAtom(atom_index).sym_index,
|
||||
zld.getAtom(atom_index).file,
|
||||
zld.getAtom(atom_index).getFile(),
|
||||
});
|
||||
},
|
||||
else => |other| {
|
||||
@ -63,32 +65,15 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
|
||||
const atom_index = object.getAtomIndexForSymbol(global.sym_index).?; // panic here means fatal error
|
||||
_ = try roots.getOrPut(atom_index);
|
||||
|
||||
log.debug("root(ATOM({d}, %{d}, {d}))", .{
|
||||
log.debug("root(ATOM({d}, %{d}, {?d}))", .{
|
||||
atom_index,
|
||||
zld.getAtom(atom_index).sym_index,
|
||||
zld.getAtom(atom_index).file,
|
||||
zld.getAtom(atom_index).getFile(),
|
||||
});
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
// TODO just a temp until we learn how to parse unwind records
|
||||
for (zld.globals.items) |global| {
|
||||
if (mem.eql(u8, "___gxx_personality_v0", zld.getSymbolName(global))) {
|
||||
const object = zld.objects.items[global.getFile().?];
|
||||
if (object.getAtomIndexForSymbol(global.sym_index)) |atom_index| {
|
||||
_ = try roots.getOrPut(atom_index);
|
||||
|
||||
log.debug("root(ATOM({d}, %{d}, {d}))", .{
|
||||
atom_index,
|
||||
zld.getAtom(atom_index).sym_index,
|
||||
zld.getAtom(atom_index).file,
|
||||
});
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (zld.objects.items) |object| {
|
||||
const has_subsections = object.header.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0;
|
||||
|
||||
@ -119,28 +104,23 @@ fn collectRoots(zld: *Zld, roots: *AtomTable) !void {
|
||||
if (is_gc_root) {
|
||||
try roots.putNoClobber(atom_index, {});
|
||||
|
||||
log.debug("root(ATOM({d}, %{d}, {d}))", .{
|
||||
log.debug("root(ATOM({d}, %{d}, {?d}))", .{
|
||||
atom_index,
|
||||
zld.getAtom(atom_index).sym_index,
|
||||
zld.getAtom(atom_index).file,
|
||||
zld.getAtom(atom_index).getFile(),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn markLive(
|
||||
zld: *Zld,
|
||||
atom_index: AtomIndex,
|
||||
alive: *AtomTable,
|
||||
reverse_lookups: [][]u32,
|
||||
) void {
|
||||
fn markLive(zld: *Zld, atom_index: AtomIndex, alive: *AtomTable) void {
|
||||
if (alive.contains(atom_index)) return;
|
||||
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const sym_loc = atom.getSymbolWithLoc();
|
||||
|
||||
log.debug("mark(ATOM({d}, %{d}, {d}))", .{ atom_index, sym_loc.sym_index, sym_loc.file });
|
||||
log.debug("mark(ATOM({d}, %{d}, {?d}))", .{ atom_index, sym_loc.sym_index, sym_loc.getFile() });
|
||||
|
||||
alive.putAssumeCapacityNoClobber(atom_index, {});
|
||||
|
||||
@ -151,14 +131,13 @@ fn markLive(
|
||||
if (header.isZerofill()) return;
|
||||
|
||||
const relocs = Atom.getAtomRelocs(zld, atom_index);
|
||||
const reverse_lookup = reverse_lookups[atom.getFile().?];
|
||||
for (relocs) |rel| {
|
||||
const target = switch (cpu_arch) {
|
||||
.aarch64 => switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) {
|
||||
.ARM64_RELOC_ADDEND => continue,
|
||||
else => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup),
|
||||
else => Atom.parseRelocTarget(zld, atom_index, rel),
|
||||
},
|
||||
.x86_64 => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup),
|
||||
.x86_64 => Atom.parseRelocTarget(zld, atom_index, rel),
|
||||
else => unreachable,
|
||||
};
|
||||
const target_sym = zld.getSymbol(target);
|
||||
@ -174,21 +153,21 @@ fn markLive(
|
||||
|
||||
const object = zld.objects.items[target.getFile().?];
|
||||
const target_atom_index = object.getAtomIndexForSymbol(target.sym_index).?;
|
||||
log.debug(" following ATOM({d}, %{d}, {d})", .{
|
||||
log.debug(" following ATOM({d}, %{d}, {?d})", .{
|
||||
target_atom_index,
|
||||
zld.getAtom(target_atom_index).sym_index,
|
||||
zld.getAtom(target_atom_index).file,
|
||||
zld.getAtom(target_atom_index).getFile(),
|
||||
});
|
||||
|
||||
markLive(zld, target_atom_index, alive, reverse_lookups);
|
||||
markLive(zld, target_atom_index, alive);
|
||||
}
|
||||
}
|
||||
|
||||
fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookups: [][]u32) bool {
|
||||
fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable) bool {
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const sym_loc = atom.getSymbolWithLoc();
|
||||
|
||||
log.debug("refersLive(ATOM({d}, %{d}, {d}))", .{ atom_index, sym_loc.sym_index, sym_loc.file });
|
||||
log.debug("refersLive(ATOM({d}, %{d}, {?d}))", .{ atom_index, sym_loc.sym_index, sym_loc.getFile() });
|
||||
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
|
||||
@ -197,14 +176,13 @@ fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookup
|
||||
assert(!header.isZerofill());
|
||||
|
||||
const relocs = Atom.getAtomRelocs(zld, atom_index);
|
||||
const reverse_lookup = reverse_lookups[atom.getFile().?];
|
||||
for (relocs) |rel| {
|
||||
const target = switch (cpu_arch) {
|
||||
.aarch64 => switch (@intToEnum(macho.reloc_type_arm64, rel.r_type)) {
|
||||
.ARM64_RELOC_ADDEND => continue,
|
||||
else => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup),
|
||||
else => Atom.parseRelocTarget(zld, atom_index, rel),
|
||||
},
|
||||
.x86_64 => Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup),
|
||||
.x86_64 => Atom.parseRelocTarget(zld, atom_index, rel),
|
||||
else => unreachable,
|
||||
};
|
||||
|
||||
@ -214,10 +192,10 @@ fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookup
|
||||
continue;
|
||||
};
|
||||
if (alive.contains(target_atom_index)) {
|
||||
log.debug(" refers live ATOM({d}, %{d}, {d})", .{
|
||||
log.debug(" refers live ATOM({d}, %{d}, {?d})", .{
|
||||
target_atom_index,
|
||||
zld.getAtom(target_atom_index).sym_index,
|
||||
zld.getAtom(target_atom_index).file,
|
||||
zld.getAtom(target_atom_index).getFile(),
|
||||
});
|
||||
return true;
|
||||
}
|
||||
@ -226,10 +204,10 @@ fn refersLive(zld: *Zld, atom_index: AtomIndex, alive: AtomTable, reverse_lookup
|
||||
return false;
|
||||
}
|
||||
|
||||
fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable, reverse_lookups: [][]u32) void {
|
||||
fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable) !void {
|
||||
var it = roots.keyIterator();
|
||||
while (it.next()) |root| {
|
||||
markLive(zld, root.*, alive, reverse_lookups);
|
||||
markLive(zld, root.*, alive);
|
||||
}
|
||||
|
||||
var loop: bool = true;
|
||||
@ -251,14 +229,135 @@ fn mark(zld: *Zld, roots: AtomTable, alive: *AtomTable, reverse_lookups: [][]u32
|
||||
const source_sect = object.getSourceSection(sect_id);
|
||||
|
||||
if (source_sect.isDontDeadStripIfReferencesLive()) {
|
||||
if (refersLive(zld, atom_index, alive.*, reverse_lookups)) {
|
||||
markLive(zld, atom_index, alive, reverse_lookups);
|
||||
if (refersLive(zld, atom_index, alive.*)) {
|
||||
markLive(zld, atom_index, alive);
|
||||
loop = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (zld.objects.items) |object, object_id| {
|
||||
// Traverse unwind and eh_frame records noting if the source symbol has been marked, and if so,
|
||||
// marking all references as live.
|
||||
// TODO I am currently assuming there will always be __unwind_info section emitted which implies
|
||||
// we will not traverse __eh_frame in isolation. This however is only true for more recent versions
|
||||
// of macOS so if there is a feature request to handle earlier versions of macOS, the following
|
||||
// bit code needs updating as well.
|
||||
if (object.hasUnwindRecords()) {
|
||||
try markUnwindRecords(zld, @intCast(u32, object_id), alive);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn markUnwindRecords(zld: *Zld, object_id: u32, alive: *AtomTable) !void {
|
||||
const object = &zld.objects.items[object_id];
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
|
||||
const unwind_records = object.getUnwindRecords();
|
||||
var it = object.getEhFrameRecordsIterator();
|
||||
|
||||
for (object.exec_atoms.items) |atom_index| {
|
||||
const record_id = object.unwind_records_lookup.get(atom_index) orelse continue;
|
||||
if (object.unwind_relocs_lookup[record_id].dead) continue; // already marked, nothing to do
|
||||
if (!alive.contains(atom_index)) {
|
||||
// Mark the record dead and continue.
|
||||
object.unwind_relocs_lookup[record_id].dead = true;
|
||||
if (object.eh_frame_records_lookup.get(atom_index)) |fde_offset| {
|
||||
object.eh_frame_relocs_lookup.getPtr(fde_offset).?.dead = true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
const record = unwind_records[record_id];
|
||||
if (UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch)) {
|
||||
const fde_offset = object.eh_frame_records_lookup.get(atom_index).?;
|
||||
it.seekTo(fde_offset);
|
||||
const fde = (try it.next()).?;
|
||||
|
||||
const cie_ptr = fde.getCiePointer();
|
||||
const cie_offset = fde_offset + 4 - cie_ptr;
|
||||
it.seekTo(cie_offset);
|
||||
const cie = (try it.next()).?;
|
||||
|
||||
switch (cpu_arch) {
|
||||
.aarch64 => {
|
||||
// Mark FDE references which should include any referenced LSDA record
|
||||
const relocs = eh_frame.getRelocs(zld, object_id, fde_offset);
|
||||
for (relocs) |rel| {
|
||||
const target = UnwindInfo.parseRelocTarget(
|
||||
zld,
|
||||
object_id,
|
||||
rel,
|
||||
fde.data,
|
||||
@intCast(i32, fde_offset) + 4,
|
||||
);
|
||||
const target_sym = zld.getSymbol(target);
|
||||
if (!target_sym.undf()) blk: {
|
||||
const target_object = zld.objects.items[target.getFile().?];
|
||||
const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index) orelse
|
||||
break :blk;
|
||||
markLive(zld, target_atom_index, alive);
|
||||
}
|
||||
}
|
||||
},
|
||||
.x86_64 => {
|
||||
const lsda_ptr = try fde.getLsdaPointer(cie, .{
|
||||
.base_addr = object.eh_frame_sect.?.addr,
|
||||
.base_offset = fde_offset,
|
||||
});
|
||||
if (lsda_ptr) |lsda_address| {
|
||||
// Mark LSDA record as live
|
||||
const sym_index = object.getSymbolByAddress(lsda_address, null);
|
||||
const target_atom_index = object.getAtomIndexForSymbol(sym_index).?;
|
||||
markLive(zld, target_atom_index, alive);
|
||||
}
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
|
||||
// Mark CIE references which should include any referenced personalities
|
||||
// that are defined locally.
|
||||
if (cie.getPersonalityPointerReloc(zld, object_id, cie_offset)) |target| {
|
||||
const target_sym = zld.getSymbol(target);
|
||||
if (!target_sym.undf()) {
|
||||
const target_object = zld.objects.items[target.getFile().?];
|
||||
const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?;
|
||||
markLive(zld, target_atom_index, alive);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (UnwindInfo.getPersonalityFunctionReloc(zld, object_id, record_id)) |rel| {
|
||||
const target = UnwindInfo.parseRelocTarget(
|
||||
zld,
|
||||
object_id,
|
||||
rel,
|
||||
mem.asBytes(&record),
|
||||
@intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)),
|
||||
);
|
||||
const target_sym = zld.getSymbol(target);
|
||||
if (!target_sym.undf()) {
|
||||
const target_object = zld.objects.items[target.getFile().?];
|
||||
const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?;
|
||||
markLive(zld, target_atom_index, alive);
|
||||
}
|
||||
}
|
||||
|
||||
if (UnwindInfo.getLsdaReloc(zld, object_id, record_id)) |rel| {
|
||||
const target = UnwindInfo.parseRelocTarget(
|
||||
zld,
|
||||
object_id,
|
||||
rel,
|
||||
mem.asBytes(&record),
|
||||
@intCast(i32, record_id * @sizeOf(macho.compact_unwind_entry)),
|
||||
);
|
||||
const target_object = zld.objects.items[target.getFile().?];
|
||||
const target_atom_index = target_object.getAtomIndexForSymbol(target.sym_index).?;
|
||||
markLive(zld, target_atom_index, alive);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn prune(zld: *Zld, alive: AtomTable) void {
|
||||
@ -275,10 +374,10 @@ fn prune(zld: *Zld, alive: AtomTable) void {
|
||||
const atom = zld.getAtom(atom_index);
|
||||
const sym_loc = atom.getSymbolWithLoc();
|
||||
|
||||
log.debug("prune(ATOM({d}, %{d}, {d}))", .{
|
||||
log.debug("prune(ATOM({d}, %{d}, {?d}))", .{
|
||||
atom_index,
|
||||
sym_loc.sym_index,
|
||||
sym_loc.file,
|
||||
sym_loc.getFile(),
|
||||
});
|
||||
log.debug(" {s} in {s}", .{ zld.getSymbolName(sym_loc), object.name });
|
||||
|
||||
|
||||
617
src/link/MachO/eh_frame.zig
Normal file
617
src/link/MachO/eh_frame.zig
Normal file
@ -0,0 +1,617 @@
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const macho = std.macho;
|
||||
const math = std.math;
|
||||
const mem = std.mem;
|
||||
const leb = std.leb;
|
||||
const log = std.log.scoped(.eh_frame);
|
||||
|
||||
const Allocator = mem.Allocator;
|
||||
const AtomIndex = @import("zld.zig").AtomIndex;
|
||||
const Atom = @import("ZldAtom.zig");
|
||||
const SymbolWithLoc = @import("zld.zig").SymbolWithLoc;
|
||||
const UnwindInfo = @import("UnwindInfo.zig");
|
||||
const Zld = @import("zld.zig").Zld;
|
||||
|
||||
pub fn scanRelocs(zld: *Zld) !void {
|
||||
const gpa = zld.gpa;
|
||||
|
||||
for (zld.objects.items) |*object, object_id| {
|
||||
var cies = std.AutoHashMap(u32, void).init(gpa);
|
||||
defer cies.deinit();
|
||||
|
||||
var it = object.getEhFrameRecordsIterator();
|
||||
|
||||
for (object.exec_atoms.items) |atom_index| {
|
||||
const fde_offset = object.eh_frame_records_lookup.get(atom_index) orelse continue;
|
||||
if (object.eh_frame_relocs_lookup.get(fde_offset).?.dead) continue;
|
||||
it.seekTo(fde_offset);
|
||||
const fde = (try it.next()).?;
|
||||
|
||||
const cie_ptr = fde.getCiePointer();
|
||||
const cie_offset = fde_offset + 4 - cie_ptr;
|
||||
|
||||
if (!cies.contains(cie_offset)) {
|
||||
try cies.putNoClobber(cie_offset, {});
|
||||
it.seekTo(cie_offset);
|
||||
const cie = (try it.next()).?;
|
||||
try cie.scanRelocs(zld, @intCast(u32, object_id), cie_offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn calcSectionSize(zld: *Zld, unwind_info: *const UnwindInfo) !void {
|
||||
const sect_id = zld.getSectionByName("__TEXT", "__eh_frame") orelse return;
|
||||
const sect = &zld.sections.items(.header)[sect_id];
|
||||
sect.@"align" = 3;
|
||||
sect.size = 0;
|
||||
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
const gpa = zld.gpa;
|
||||
var size: u32 = 0;
|
||||
|
||||
for (zld.objects.items) |*object| {
|
||||
var cies = std.AutoHashMap(u32, u32).init(gpa);
|
||||
defer cies.deinit();
|
||||
|
||||
var eh_it = object.getEhFrameRecordsIterator();
|
||||
|
||||
for (object.exec_atoms.items) |atom_index| {
|
||||
const fde_record_offset = object.eh_frame_records_lookup.get(atom_index) orelse continue;
|
||||
if (object.eh_frame_relocs_lookup.get(fde_record_offset).?.dead) continue;
|
||||
|
||||
const record_id = unwind_info.records_lookup.get(atom_index) orelse continue;
|
||||
const record = unwind_info.records.items[record_id];
|
||||
|
||||
// TODO skip this check if no __compact_unwind is present
|
||||
const is_dwarf = UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch);
|
||||
if (!is_dwarf) continue;
|
||||
|
||||
eh_it.seekTo(fde_record_offset);
|
||||
const source_fde_record = (try eh_it.next()).?;
|
||||
|
||||
const cie_ptr = source_fde_record.getCiePointer();
|
||||
const cie_offset = fde_record_offset + 4 - cie_ptr;
|
||||
|
||||
const gop = try cies.getOrPut(cie_offset);
|
||||
if (!gop.found_existing) {
|
||||
eh_it.seekTo(cie_offset);
|
||||
const source_cie_record = (try eh_it.next()).?;
|
||||
gop.value_ptr.* = size;
|
||||
size += source_cie_record.getSize();
|
||||
}
|
||||
|
||||
size += source_fde_record.getSize();
|
||||
}
|
||||
}
|
||||
|
||||
sect.size = size;
|
||||
}
|
||||
|
||||
pub fn write(zld: *Zld, unwind_info: *UnwindInfo) !void {
|
||||
const sect_id = zld.getSectionByName("__TEXT", "__eh_frame") orelse return;
|
||||
const sect = zld.sections.items(.header)[sect_id];
|
||||
const seg_id = zld.sections.items(.segment_index)[sect_id];
|
||||
const seg = zld.segments.items[seg_id];
|
||||
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
const gpa = zld.gpa;
|
||||
|
||||
var eh_records = std.AutoArrayHashMap(u32, EhFrameRecord(true)).init(gpa);
|
||||
defer {
|
||||
for (eh_records.values()) |*rec| {
|
||||
rec.deinit(gpa);
|
||||
}
|
||||
eh_records.deinit();
|
||||
}
|
||||
|
||||
var eh_frame_offset: u32 = 0;
|
||||
|
||||
for (zld.objects.items) |*object, object_id| {
|
||||
try eh_records.ensureUnusedCapacity(2 * @intCast(u32, object.exec_atoms.items.len));
|
||||
|
||||
var cies = std.AutoHashMap(u32, u32).init(gpa);
|
||||
defer cies.deinit();
|
||||
|
||||
var eh_it = object.getEhFrameRecordsIterator();
|
||||
|
||||
for (object.exec_atoms.items) |atom_index| {
|
||||
const fde_record_offset = object.eh_frame_records_lookup.get(atom_index) orelse continue;
|
||||
if (object.eh_frame_relocs_lookup.get(fde_record_offset).?.dead) continue;
|
||||
|
||||
const record_id = unwind_info.records_lookup.get(atom_index) orelse continue;
|
||||
const record = &unwind_info.records.items[record_id];
|
||||
|
||||
// TODO skip this check if no __compact_unwind is present
|
||||
const is_dwarf = UnwindInfo.UnwindEncoding.isDwarf(record.compactUnwindEncoding, cpu_arch);
|
||||
if (!is_dwarf) continue;
|
||||
|
||||
eh_it.seekTo(fde_record_offset);
|
||||
const source_fde_record = (try eh_it.next()).?;
|
||||
|
||||
const cie_ptr = source_fde_record.getCiePointer();
|
||||
const cie_offset = fde_record_offset + 4 - cie_ptr;
|
||||
|
||||
const gop = try cies.getOrPut(cie_offset);
|
||||
if (!gop.found_existing) {
|
||||
eh_it.seekTo(cie_offset);
|
||||
const source_cie_record = (try eh_it.next()).?;
|
||||
var cie_record = try source_cie_record.toOwned(gpa);
|
||||
try cie_record.relocate(zld, @intCast(u32, object_id), .{
|
||||
.source_offset = cie_offset,
|
||||
.out_offset = eh_frame_offset,
|
||||
.sect_addr = sect.addr,
|
||||
});
|
||||
eh_records.putAssumeCapacityNoClobber(eh_frame_offset, cie_record);
|
||||
gop.value_ptr.* = eh_frame_offset;
|
||||
eh_frame_offset += cie_record.getSize();
|
||||
}
|
||||
|
||||
var fde_record = try source_fde_record.toOwned(gpa);
|
||||
fde_record.setCiePointer(eh_frame_offset + 4 - gop.value_ptr.*);
|
||||
try fde_record.relocate(zld, @intCast(u32, object_id), .{
|
||||
.source_offset = fde_record_offset,
|
||||
.out_offset = eh_frame_offset,
|
||||
.sect_addr = sect.addr,
|
||||
});
|
||||
|
||||
switch (cpu_arch) {
|
||||
.aarch64 => {}, // relocs take care of LSDA pointers
|
||||
.x86_64 => {
|
||||
// We need to parse LSDA pointer and relocate ourselves.
|
||||
const cie_record = eh_records.get(
|
||||
eh_frame_offset + 4 - fde_record.getCiePointer(),
|
||||
).?;
|
||||
const source_lsda_ptr = try fde_record.getLsdaPointer(cie_record, .{
|
||||
.base_addr = object.eh_frame_sect.?.addr,
|
||||
.base_offset = fde_record_offset,
|
||||
});
|
||||
if (source_lsda_ptr) |ptr| {
|
||||
const sym_index = object.getSymbolByAddress(ptr, null);
|
||||
const sym = object.symtab[sym_index];
|
||||
try fde_record.setLsdaPointer(cie_record, sym.n_value, .{
|
||||
.base_addr = sect.addr,
|
||||
.base_offset = eh_frame_offset,
|
||||
});
|
||||
}
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
|
||||
eh_records.putAssumeCapacityNoClobber(eh_frame_offset, fde_record);
|
||||
|
||||
UnwindInfo.UnwindEncoding.setDwarfSectionOffset(
|
||||
&record.compactUnwindEncoding,
|
||||
cpu_arch,
|
||||
@intCast(u24, eh_frame_offset),
|
||||
);
|
||||
|
||||
const cie_record = eh_records.get(
|
||||
eh_frame_offset + 4 - fde_record.getCiePointer(),
|
||||
).?;
|
||||
const lsda_ptr = try fde_record.getLsdaPointer(cie_record, .{
|
||||
.base_addr = sect.addr,
|
||||
.base_offset = eh_frame_offset,
|
||||
});
|
||||
if (lsda_ptr) |ptr| {
|
||||
record.lsda = ptr - seg.vmaddr;
|
||||
}
|
||||
|
||||
eh_frame_offset += fde_record.getSize();
|
||||
}
|
||||
}
|
||||
|
||||
var buffer = std.ArrayList(u8).init(gpa);
|
||||
defer buffer.deinit();
|
||||
const writer = buffer.writer();
|
||||
|
||||
for (eh_records.values()) |record| {
|
||||
try writer.writeIntLittle(u32, record.size);
|
||||
try buffer.appendSlice(record.data);
|
||||
}
|
||||
|
||||
try zld.file.pwriteAll(buffer.items, sect.offset);
|
||||
}
|
||||
const EhFrameRecordTag = enum { cie, fde };
|
||||
|
||||
pub fn EhFrameRecord(comptime is_mutable: bool) type {
|
||||
return struct {
|
||||
tag: EhFrameRecordTag,
|
||||
size: u32,
|
||||
data: if (is_mutable) []u8 else []const u8,
|
||||
|
||||
const Record = @This();
|
||||
|
||||
pub fn deinit(rec: *Record, gpa: Allocator) void {
|
||||
comptime assert(is_mutable);
|
||||
gpa.free(rec.data);
|
||||
}
|
||||
|
||||
pub fn toOwned(rec: Record, gpa: Allocator) Allocator.Error!EhFrameRecord(true) {
|
||||
const data = try gpa.dupe(u8, rec.data);
|
||||
return EhFrameRecord(true){
|
||||
.tag = rec.tag,
|
||||
.size = rec.size,
|
||||
.data = data,
|
||||
};
|
||||
}
|
||||
|
||||
pub inline fn getSize(rec: Record) u32 {
|
||||
return 4 + rec.size;
|
||||
}
|
||||
|
||||
pub fn scanRelocs(
|
||||
rec: Record,
|
||||
zld: *Zld,
|
||||
object_id: u32,
|
||||
source_offset: u32,
|
||||
) !void {
|
||||
if (rec.getPersonalityPointerReloc(zld, object_id, source_offset)) |target| {
|
||||
try Atom.addGotEntry(zld, target);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn getTargetSymbolAddress(rec: Record, ctx: struct {
|
||||
base_addr: u64,
|
||||
base_offset: u64,
|
||||
}) u64 {
|
||||
assert(rec.tag == .fde);
|
||||
const addend = mem.readIntLittle(i64, rec.data[4..][0..8]);
|
||||
return @intCast(u64, @intCast(i64, ctx.base_addr + ctx.base_offset + 8) + addend);
|
||||
}
|
||||
|
||||
pub fn setTargetSymbolAddress(rec: *Record, value: u64, ctx: struct {
|
||||
base_addr: u64,
|
||||
base_offset: u64,
|
||||
}) !void {
|
||||
assert(rec.tag == .fde);
|
||||
const addend = @intCast(i64, value) - @intCast(i64, ctx.base_addr + ctx.base_offset + 8);
|
||||
mem.writeIntLittle(i64, addend, rec.data[4..][0..8]);
|
||||
}
|
||||
|
||||
pub fn getPersonalityPointerReloc(
|
||||
rec: Record,
|
||||
zld: *Zld,
|
||||
object_id: u32,
|
||||
source_offset: u32,
|
||||
) ?SymbolWithLoc {
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
const relocs = getRelocs(zld, object_id, source_offset);
|
||||
for (relocs) |rel| {
|
||||
switch (cpu_arch) {
|
||||
.aarch64 => {
|
||||
const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type);
|
||||
switch (rel_type) {
|
||||
.ARM64_RELOC_SUBTRACTOR,
|
||||
.ARM64_RELOC_UNSIGNED,
|
||||
=> continue,
|
||||
.ARM64_RELOC_POINTER_TO_GOT => {},
|
||||
else => unreachable,
|
||||
}
|
||||
},
|
||||
.x86_64 => {
|
||||
const rel_type = @intToEnum(macho.reloc_type_x86_64, rel.r_type);
|
||||
switch (rel_type) {
|
||||
.X86_64_RELOC_GOT => {},
|
||||
else => unreachable,
|
||||
}
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
const target = UnwindInfo.parseRelocTarget(
|
||||
zld,
|
||||
object_id,
|
||||
rel,
|
||||
rec.data,
|
||||
@intCast(i32, source_offset) + 4,
|
||||
);
|
||||
return target;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
pub fn relocate(rec: *Record, zld: *Zld, object_id: u32, ctx: struct {
|
||||
source_offset: u32,
|
||||
out_offset: u32,
|
||||
sect_addr: u64,
|
||||
}) !void {
|
||||
comptime assert(is_mutable);
|
||||
|
||||
const cpu_arch = zld.options.target.cpu.arch;
|
||||
const relocs = getRelocs(zld, object_id, ctx.source_offset);
|
||||
|
||||
for (relocs) |rel| {
|
||||
const target = UnwindInfo.parseRelocTarget(
|
||||
zld,
|
||||
object_id,
|
||||
rel,
|
||||
rec.data,
|
||||
@intCast(i32, ctx.source_offset) + 4,
|
||||
);
|
||||
const rel_offset = @intCast(u32, rel.r_address - @intCast(i32, ctx.source_offset) - 4);
|
||||
const source_addr = ctx.sect_addr + rel_offset + ctx.out_offset + 4;
|
||||
|
||||
switch (cpu_arch) {
|
||||
.aarch64 => {
|
||||
const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type);
|
||||
switch (rel_type) {
|
||||
.ARM64_RELOC_SUBTRACTOR => {
|
||||
// Address of the __eh_frame in the source object file
|
||||
},
|
||||
.ARM64_RELOC_POINTER_TO_GOT => {
|
||||
const target_addr = try Atom.getRelocTargetAddress(zld, target, true, false);
|
||||
const result = math.cast(i32, @intCast(i64, target_addr) - @intCast(i64, source_addr)) orelse
|
||||
return error.Overflow;
|
||||
mem.writeIntLittle(i32, rec.data[rel_offset..][0..4], result);
|
||||
},
|
||||
.ARM64_RELOC_UNSIGNED => {
|
||||
assert(rel.r_extern == 1);
|
||||
const target_addr = try Atom.getRelocTargetAddress(zld, target, false, false);
|
||||
const result = @intCast(i64, target_addr) - @intCast(i64, source_addr);
|
||||
mem.writeIntLittle(i64, rec.data[rel_offset..][0..8], @intCast(i64, result));
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
},
|
||||
.x86_64 => {
|
||||
const rel_type = @intToEnum(macho.reloc_type_x86_64, rel.r_type);
|
||||
switch (rel_type) {
|
||||
.X86_64_RELOC_GOT => {
|
||||
const target_addr = try Atom.getRelocTargetAddress(zld, target, true, false);
|
||||
const addend = mem.readIntLittle(i32, rec.data[rel_offset..][0..4]);
|
||||
const adjusted_target_addr = @intCast(u64, @intCast(i64, target_addr) + addend);
|
||||
const disp = try Atom.calcPcRelativeDisplacementX86(source_addr, adjusted_target_addr, 0);
|
||||
mem.writeIntLittle(i32, rec.data[rel_offset..][0..4], disp);
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn getCiePointer(rec: Record) u32 {
|
||||
assert(rec.tag == .fde);
|
||||
return mem.readIntLittle(u32, rec.data[0..4]);
|
||||
}
|
||||
|
||||
pub fn setCiePointer(rec: *Record, ptr: u32) void {
|
||||
assert(rec.tag == .fde);
|
||||
mem.writeIntLittle(u32, rec.data[0..4], ptr);
|
||||
}
|
||||
|
||||
pub fn getAugmentationString(rec: Record) []const u8 {
|
||||
assert(rec.tag == .cie);
|
||||
return mem.sliceTo(@ptrCast([*:0]const u8, rec.data.ptr + 5), 0);
|
||||
}
|
||||
|
||||
pub fn getPersonalityPointer(rec: Record, ctx: struct {
|
||||
base_addr: u64,
|
||||
base_offset: u64,
|
||||
}) !?u64 {
|
||||
assert(rec.tag == .cie);
|
||||
const aug_str = rec.getAugmentationString();
|
||||
|
||||
var stream = std.io.fixedBufferStream(rec.data[9 + aug_str.len ..]);
|
||||
var creader = std.io.countingReader(stream.reader());
|
||||
const reader = creader.reader();
|
||||
|
||||
for (aug_str) |ch, i| switch (ch) {
|
||||
'z' => if (i > 0) {
|
||||
return error.BadDwarfCfi;
|
||||
} else {
|
||||
_ = try leb.readULEB128(u64, reader);
|
||||
},
|
||||
'R' => {
|
||||
_ = try reader.readByte();
|
||||
},
|
||||
'P' => {
|
||||
const enc = try reader.readByte();
|
||||
const offset = ctx.base_offset + 13 + aug_str.len + creader.bytes_read;
|
||||
const ptr = try getEncodedPointer(enc, @intCast(i64, ctx.base_addr + offset), reader);
|
||||
return ptr;
|
||||
},
|
||||
'L' => {
|
||||
_ = try reader.readByte();
|
||||
},
|
||||
'S', 'B', 'G' => {},
|
||||
else => return error.BadDwarfCfi,
|
||||
};
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
pub fn getLsdaPointer(rec: Record, cie: Record, ctx: struct {
|
||||
base_addr: u64,
|
||||
base_offset: u64,
|
||||
}) !?u64 {
|
||||
assert(rec.tag == .fde);
|
||||
const enc = (try cie.getLsdaEncoding()) orelse return null;
|
||||
var stream = std.io.fixedBufferStream(rec.data[20..]);
|
||||
const reader = stream.reader();
|
||||
_ = try reader.readByte();
|
||||
const offset = ctx.base_offset + 25;
|
||||
const ptr = try getEncodedPointer(enc, @intCast(i64, ctx.base_addr + offset), reader);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
pub fn setLsdaPointer(rec: *Record, cie: Record, value: u64, ctx: struct {
|
||||
base_addr: u64,
|
||||
base_offset: u64,
|
||||
}) !void {
|
||||
assert(rec.tag == .fde);
|
||||
const enc = (try cie.getLsdaEncoding()) orelse unreachable;
|
||||
var stream = std.io.fixedBufferStream(rec.data[21..]);
|
||||
const writer = stream.writer();
|
||||
const offset = ctx.base_offset + 25;
|
||||
try setEncodedPointer(enc, @intCast(i64, ctx.base_addr + offset), value, writer);
|
||||
}
|
||||
|
||||
fn getLsdaEncoding(rec: Record) !?u8 {
|
||||
assert(rec.tag == .cie);
|
||||
const aug_str = rec.getAugmentationString();
|
||||
|
||||
const base_offset = 9 + aug_str.len;
|
||||
var stream = std.io.fixedBufferStream(rec.data[base_offset..]);
|
||||
var creader = std.io.countingReader(stream.reader());
|
||||
const reader = creader.reader();
|
||||
|
||||
for (aug_str) |ch, i| switch (ch) {
|
||||
'z' => if (i > 0) {
|
||||
return error.BadDwarfCfi;
|
||||
} else {
|
||||
_ = try leb.readULEB128(u64, reader);
|
||||
},
|
||||
'R' => {
|
||||
_ = try reader.readByte();
|
||||
},
|
||||
'P' => {
|
||||
const enc = try reader.readByte();
|
||||
_ = try getEncodedPointer(enc, 0, reader);
|
||||
},
|
||||
'L' => {
|
||||
const enc = try reader.readByte();
|
||||
return enc;
|
||||
},
|
||||
'S', 'B', 'G' => {},
|
||||
else => return error.BadDwarfCfi,
|
||||
};
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
fn getEncodedPointer(enc: u8, pcrel_offset: i64, reader: anytype) !?u64 {
|
||||
if (enc == EH_PE.omit) return null;
|
||||
|
||||
var ptr: i64 = switch (enc & 0x0F) {
|
||||
EH_PE.absptr => @bitCast(i64, try reader.readIntLittle(u64)),
|
||||
EH_PE.udata2 => @bitCast(i16, try reader.readIntLittle(u16)),
|
||||
EH_PE.udata4 => @bitCast(i32, try reader.readIntLittle(u32)),
|
||||
EH_PE.udata8 => @bitCast(i64, try reader.readIntLittle(u64)),
|
||||
EH_PE.uleb128 => @bitCast(i64, try leb.readULEB128(u64, reader)),
|
||||
EH_PE.sdata2 => try reader.readIntLittle(i16),
|
||||
EH_PE.sdata4 => try reader.readIntLittle(i32),
|
||||
EH_PE.sdata8 => try reader.readIntLittle(i64),
|
||||
EH_PE.sleb128 => try leb.readILEB128(i64, reader),
|
||||
else => return null,
|
||||
};
|
||||
|
||||
switch (enc & 0x70) {
|
||||
EH_PE.absptr => {},
|
||||
EH_PE.pcrel => ptr += pcrel_offset,
|
||||
EH_PE.datarel,
|
||||
EH_PE.textrel,
|
||||
EH_PE.funcrel,
|
||||
EH_PE.aligned,
|
||||
=> return null,
|
||||
else => return null,
|
||||
}
|
||||
|
||||
return @bitCast(u64, ptr);
|
||||
}
|
||||
|
||||
fn setEncodedPointer(enc: u8, pcrel_offset: i64, value: u64, writer: anytype) !void {
|
||||
if (enc == EH_PE.omit) return;
|
||||
|
||||
var actual = @intCast(i64, value);
|
||||
|
||||
switch (enc & 0x70) {
|
||||
EH_PE.absptr => {},
|
||||
EH_PE.pcrel => actual -= pcrel_offset,
|
||||
EH_PE.datarel,
|
||||
EH_PE.textrel,
|
||||
EH_PE.funcrel,
|
||||
EH_PE.aligned,
|
||||
=> unreachable,
|
||||
else => unreachable,
|
||||
}
|
||||
|
||||
switch (enc & 0x0F) {
|
||||
EH_PE.absptr => try writer.writeIntLittle(u64, @bitCast(u64, actual)),
|
||||
EH_PE.udata2 => try writer.writeIntLittle(u16, @bitCast(u16, @intCast(i16, actual))),
|
||||
EH_PE.udata4 => try writer.writeIntLittle(u32, @bitCast(u32, @intCast(i32, actual))),
|
||||
EH_PE.udata8 => try writer.writeIntLittle(u64, @bitCast(u64, actual)),
|
||||
EH_PE.uleb128 => try leb.writeULEB128(writer, @bitCast(u64, actual)),
|
||||
EH_PE.sdata2 => try writer.writeIntLittle(i16, @intCast(i16, actual)),
|
||||
EH_PE.sdata4 => try writer.writeIntLittle(i32, @intCast(i32, actual)),
|
||||
EH_PE.sdata8 => try writer.writeIntLittle(i64, actual),
|
||||
EH_PE.sleb128 => try leb.writeILEB128(writer, actual),
|
||||
else => unreachable,
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub fn getRelocs(
|
||||
zld: *Zld,
|
||||
object_id: u32,
|
||||
source_offset: u32,
|
||||
) []align(1) const macho.relocation_info {
|
||||
const object = &zld.objects.items[object_id];
|
||||
assert(object.hasEhFrameRecords());
|
||||
const urel = object.eh_frame_relocs_lookup.get(source_offset) orelse
|
||||
return &[0]macho.relocation_info{};
|
||||
const all_relocs = object.getRelocs(object.eh_frame_sect.?);
|
||||
return all_relocs[urel.reloc.start..][0..urel.reloc.len];
|
||||
}
|
||||
|
||||
pub const Iterator = struct {
|
||||
data: []const u8,
|
||||
pos: u32 = 0,
|
||||
|
||||
pub fn next(it: *Iterator) !?EhFrameRecord(false) {
|
||||
if (it.pos >= it.data.len) return null;
|
||||
|
||||
var stream = std.io.fixedBufferStream(it.data[it.pos..]);
|
||||
const reader = stream.reader();
|
||||
|
||||
var size = try reader.readIntLittle(u32);
|
||||
if (size == 0xFFFFFFFF) {
|
||||
log.err("MachO doesn't support 64bit DWARF CFI __eh_frame records", .{});
|
||||
return error.BadDwarfCfi;
|
||||
}
|
||||
|
||||
const id = try reader.readIntLittle(u32);
|
||||
const tag: EhFrameRecordTag = if (id == 0) .cie else .fde;
|
||||
const offset: u32 = 4;
|
||||
const record = EhFrameRecord(false){
|
||||
.tag = tag,
|
||||
.size = size,
|
||||
.data = it.data[it.pos + offset ..][0..size],
|
||||
};
|
||||
|
||||
it.pos += size + offset;
|
||||
|
||||
return record;
|
||||
}
|
||||
|
||||
pub fn reset(it: *Iterator) void {
|
||||
it.pos = 0;
|
||||
}
|
||||
|
||||
pub fn seekTo(it: *Iterator, pos: u32) void {
|
||||
assert(pos >= 0 and pos < it.data.len);
|
||||
it.pos = pos;
|
||||
}
|
||||
};
|
||||
|
||||
pub const EH_PE = struct {
|
||||
pub const absptr = 0x00;
|
||||
pub const uleb128 = 0x01;
|
||||
pub const udata2 = 0x02;
|
||||
pub const udata4 = 0x03;
|
||||
pub const udata8 = 0x04;
|
||||
pub const sleb128 = 0x09;
|
||||
pub const sdata2 = 0x0A;
|
||||
pub const sdata4 = 0x0B;
|
||||
pub const sdata8 = 0x0C;
|
||||
pub const pcrel = 0x10;
|
||||
pub const textrel = 0x20;
|
||||
pub const datarel = 0x30;
|
||||
pub const funcrel = 0x40;
|
||||
pub const aligned = 0x50;
|
||||
pub const indirect = 0x80;
|
||||
pub const omit = 0xFF;
|
||||
};
|
||||
@ -68,7 +68,7 @@ pub const Thunk = struct {
|
||||
}
|
||||
};
|
||||
|
||||
pub fn createThunks(zld: *Zld, sect_id: u8, reverse_lookups: [][]u32) !void {
|
||||
pub fn createThunks(zld: *Zld, sect_id: u8) !void {
|
||||
const header = &zld.sections.items(.header)[sect_id];
|
||||
if (header.size == 0) return;
|
||||
|
||||
@ -140,7 +140,6 @@ pub fn createThunks(zld: *Zld, sect_id: u8, reverse_lookups: [][]u32) !void {
|
||||
try scanRelocs(
|
||||
zld,
|
||||
atom_index,
|
||||
reverse_lookups[atom.getFile().?],
|
||||
allocated,
|
||||
thunk_index,
|
||||
group_end,
|
||||
@ -214,7 +213,6 @@ fn allocateThunk(
|
||||
fn scanRelocs(
|
||||
zld: *Zld,
|
||||
atom_index: AtomIndex,
|
||||
reverse_lookup: []u32,
|
||||
allocated: std.AutoHashMap(AtomIndex, void),
|
||||
thunk_index: ThunkIndex,
|
||||
group_end: AtomIndex,
|
||||
@ -231,7 +229,7 @@ fn scanRelocs(
|
||||
for (relocs) |rel| {
|
||||
if (!relocNeedsThunk(rel)) continue;
|
||||
|
||||
const target = Atom.parseRelocTarget(zld, atom_index, rel, reverse_lookup);
|
||||
const target = Atom.parseRelocTarget(zld, atom_index, rel);
|
||||
if (isReachable(zld, atom_index, rel, base_offset, target, allocated)) continue;
|
||||
|
||||
log.debug("{x}: source = {s}@{x}, target = {s}@{x} unreachable", .{
|
||||
@ -308,7 +306,8 @@ fn isReachable(
|
||||
if (!allocated.contains(target_atom_index)) return false;
|
||||
|
||||
const source_addr = source_sym.n_value + @intCast(u32, rel.r_address - base_offset);
|
||||
const target_addr = Atom.getRelocTargetAddress(zld, rel, target, false) catch unreachable;
|
||||
const is_via_got = Atom.relocRequiresGot(zld, rel);
|
||||
const target_addr = Atom.getRelocTargetAddress(zld, target, is_via_got, false) catch unreachable;
|
||||
_ = Atom.calcPcRelativeDisplacementArm64(source_addr, target_addr) catch
|
||||
return false;
|
||||
|
||||
|
||||
@ -10,6 +10,7 @@ const mem = std.mem;
|
||||
|
||||
const aarch64 = @import("../../arch/aarch64/bits.zig");
|
||||
const dead_strip = @import("dead_strip.zig");
|
||||
const eh_frame = @import("eh_frame.zig");
|
||||
const fat = @import("fat.zig");
|
||||
const link = @import("../../link.zig");
|
||||
const load_commands = @import("load_commands.zig");
|
||||
@ -30,6 +31,7 @@ const LibStub = @import("../tapi.zig").LibStub;
|
||||
const Object = @import("Object.zig");
|
||||
const StringTable = @import("../strtab.zig").StringTable;
|
||||
const Trie = @import("Trie.zig");
|
||||
const UnwindInfo = @import("UnwindInfo.zig");
|
||||
|
||||
const Bind = @import("dyld_info/bind.zig").Bind(*const Zld, SymbolWithLoc);
|
||||
const LazyBind = @import("dyld_info/bind.zig").LazyBind(*const Zld, SymbolWithLoc);
|
||||
@ -389,6 +391,14 @@ pub const Zld = struct {
|
||||
break :blk null;
|
||||
}
|
||||
|
||||
// We handle unwind info separately.
|
||||
if (mem.eql(u8, "__TEXT", segname) and mem.eql(u8, "__eh_frame", sectname)) {
|
||||
break :blk null;
|
||||
}
|
||||
if (mem.eql(u8, "__LD", segname) and mem.eql(u8, "__compact_unwind", sectname)) {
|
||||
break :blk null;
|
||||
}
|
||||
|
||||
if (sect.isCode()) {
|
||||
break :blk self.getSectionByName("__TEXT", "__text") orelse try self.initSection(
|
||||
"__TEXT",
|
||||
@ -402,12 +412,6 @@ pub const Zld = struct {
|
||||
}
|
||||
|
||||
if (sect.isDebug()) {
|
||||
// TODO debug attributes
|
||||
if (mem.eql(u8, "__LD", segname) and mem.eql(u8, "__compact_unwind", sectname)) {
|
||||
log.debug("TODO compact unwind section: type 0x{x}, name '{s},{s}'", .{
|
||||
sect.flags, segname, sectname,
|
||||
});
|
||||
}
|
||||
break :blk null;
|
||||
}
|
||||
|
||||
@ -459,13 +463,6 @@ pub const Zld = struct {
|
||||
);
|
||||
},
|
||||
macho.S_COALESCED => {
|
||||
// TODO unwind info
|
||||
if (mem.eql(u8, "__TEXT", segname) and mem.eql(u8, "__eh_frame", sectname)) {
|
||||
log.debug("TODO eh frame section: type 0x{x}, name '{s},{s}'", .{
|
||||
sect.flags, segname, sectname,
|
||||
});
|
||||
break :blk null;
|
||||
}
|
||||
break :blk self.getSectionByName(segname, sectname) orelse try self.initSection(
|
||||
segname,
|
||||
sectname,
|
||||
@ -937,7 +934,7 @@ pub const Zld = struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn resolveSymbolsInObject(self: *Zld, object_id: u16, resolver: *SymbolResolver) !void {
|
||||
fn resolveSymbolsInObject(self: *Zld, object_id: u32, resolver: *SymbolResolver) !void {
|
||||
const object = &self.objects.items[object_id];
|
||||
const in_symtab = object.in_symtab orelse return;
|
||||
|
||||
@ -977,7 +974,7 @@ pub const Zld = struct {
|
||||
continue;
|
||||
}
|
||||
|
||||
const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = object_id };
|
||||
const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = object_id + 1 };
|
||||
|
||||
const global_index = resolver.table.get(sym_name) orelse {
|
||||
const gpa = self.gpa;
|
||||
@ -1378,7 +1375,7 @@ pub const Zld = struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn writeAtoms(self: *Zld, reverse_lookups: [][]u32) !void {
|
||||
fn writeAtoms(self: *Zld) !void {
|
||||
const gpa = self.gpa;
|
||||
const slice = self.sections.slice();
|
||||
|
||||
@ -1386,6 +1383,7 @@ pub const Zld = struct {
|
||||
const header = slice.items(.header)[sect_id];
|
||||
var atom_index = first_atom_index;
|
||||
|
||||
if (atom_index == 0) continue;
|
||||
if (header.isZerofill()) continue;
|
||||
|
||||
var buffer = std.ArrayList(u8).init(gpa);
|
||||
@ -1407,7 +1405,7 @@ pub const Zld = struct {
|
||||
log.debug(" (adding ATOM(%{d}, '{s}') from object({?}) to buffer)", .{
|
||||
atom.sym_index,
|
||||
self.getSymbolName(atom.getSymbolWithLoc()),
|
||||
atom.file,
|
||||
atom.getFile(),
|
||||
});
|
||||
if (padding_size > 0) {
|
||||
log.debug(" (with padding {x})", .{padding_size});
|
||||
@ -1460,7 +1458,6 @@ pub const Zld = struct {
|
||||
atom_index,
|
||||
buffer.items[offset..][0..size],
|
||||
relocs,
|
||||
reverse_lookups[atom.getFile().?],
|
||||
);
|
||||
}
|
||||
|
||||
@ -1501,9 +1498,10 @@ pub const Zld = struct {
|
||||
while (i < slice.len) : (i += 1) {
|
||||
const section = self.sections.get(i);
|
||||
if (section.header.size == 0) {
|
||||
log.debug("pruning section {s},{s}", .{
|
||||
log.debug("pruning section {s},{s} {d}", .{
|
||||
section.header.segName(),
|
||||
section.header.sectName(),
|
||||
section.first_atom_index,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
@ -1519,7 +1517,7 @@ pub const Zld = struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn calcSectionSizes(self: *Zld, reverse_lookups: [][]u32) !void {
|
||||
fn calcSectionSizes(self: *Zld) !void {
|
||||
const slice = self.sections.slice();
|
||||
for (slice.items(.header)) |*header, sect_id| {
|
||||
if (header.size == 0) continue;
|
||||
@ -1528,6 +1526,8 @@ pub const Zld = struct {
|
||||
}
|
||||
|
||||
var atom_index = slice.items(.first_atom_index)[sect_id];
|
||||
if (atom_index == 0) continue;
|
||||
|
||||
header.size = 0;
|
||||
header.@"align" = 0;
|
||||
|
||||
@ -1556,7 +1556,7 @@ pub const Zld = struct {
|
||||
if (mem.eql(u8, header.sectName(), "__stub_helper")) continue;
|
||||
|
||||
// Create jump/branch range extenders if needed.
|
||||
try thunks.createThunks(self, @intCast(u8, sect_id), reverse_lookups);
|
||||
try thunks.createThunks(self, @intCast(u8, sect_id));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1601,8 +1601,6 @@ pub const Zld = struct {
|
||||
|
||||
const slice = self.sections.slice();
|
||||
for (slice.items(.header)[indexes.start..indexes.end]) |*header, sect_id| {
|
||||
var atom_index = slice.items(.first_atom_index)[indexes.start + sect_id];
|
||||
|
||||
const alignment = try math.powi(u32, 2, header.@"align");
|
||||
const start_aligned = mem.alignForwardGeneric(u64, start, alignment);
|
||||
const n_sect = @intCast(u8, indexes.start + sect_id + 1);
|
||||
@ -1613,48 +1611,51 @@ pub const Zld = struct {
|
||||
@intCast(u32, segment.fileoff + start_aligned);
|
||||
header.addr = segment.vmaddr + start_aligned;
|
||||
|
||||
log.debug("allocating local symbols in sect({d}, '{s},{s}')", .{
|
||||
n_sect,
|
||||
header.segName(),
|
||||
header.sectName(),
|
||||
});
|
||||
|
||||
while (true) {
|
||||
const atom = self.getAtom(atom_index);
|
||||
const sym = self.getSymbolPtr(atom.getSymbolWithLoc());
|
||||
sym.n_value += header.addr;
|
||||
sym.n_sect = n_sect;
|
||||
|
||||
log.debug(" ATOM(%{d}, '{s}') @{x}", .{
|
||||
atom.sym_index,
|
||||
self.getSymbolName(atom.getSymbolWithLoc()),
|
||||
sym.n_value,
|
||||
var atom_index = slice.items(.first_atom_index)[indexes.start + sect_id];
|
||||
if (atom_index > 0) {
|
||||
log.debug("allocating local symbols in sect({d}, '{s},{s}')", .{
|
||||
n_sect,
|
||||
header.segName(),
|
||||
header.sectName(),
|
||||
});
|
||||
|
||||
if (atom.getFile() != null) {
|
||||
// Update each symbol contained within the atom
|
||||
var it = Atom.getInnerSymbolsIterator(self, atom_index);
|
||||
while (it.next()) |sym_loc| {
|
||||
const inner_sym = self.getSymbolPtr(sym_loc);
|
||||
inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset(
|
||||
self,
|
||||
atom_index,
|
||||
sym_loc.sym_index,
|
||||
);
|
||||
inner_sym.n_sect = n_sect;
|
||||
while (true) {
|
||||
const atom = self.getAtom(atom_index);
|
||||
const sym = self.getSymbolPtr(atom.getSymbolWithLoc());
|
||||
sym.n_value += header.addr;
|
||||
sym.n_sect = n_sect;
|
||||
|
||||
log.debug(" ATOM(%{d}, '{s}') @{x}", .{
|
||||
atom.sym_index,
|
||||
self.getSymbolName(atom.getSymbolWithLoc()),
|
||||
sym.n_value,
|
||||
});
|
||||
|
||||
if (atom.getFile() != null) {
|
||||
// Update each symbol contained within the atom
|
||||
var it = Atom.getInnerSymbolsIterator(self, atom_index);
|
||||
while (it.next()) |sym_loc| {
|
||||
const inner_sym = self.getSymbolPtr(sym_loc);
|
||||
inner_sym.n_value = sym.n_value + Atom.calcInnerSymbolOffset(
|
||||
self,
|
||||
atom_index,
|
||||
sym_loc.sym_index,
|
||||
);
|
||||
inner_sym.n_sect = n_sect;
|
||||
}
|
||||
|
||||
// If there is a section alias, update it now too
|
||||
if (Atom.getSectionAlias(self, atom_index)) |sym_loc| {
|
||||
const alias = self.getSymbolPtr(sym_loc);
|
||||
alias.n_value = sym.n_value;
|
||||
alias.n_sect = n_sect;
|
||||
}
|
||||
}
|
||||
|
||||
// If there is a section alias, update it now too
|
||||
if (Atom.getSectionAlias(self, atom_index)) |sym_loc| {
|
||||
const alias = self.getSymbolPtr(sym_loc);
|
||||
alias.n_value = sym.n_value;
|
||||
alias.n_sect = n_sect;
|
||||
}
|
||||
if (atom.next_index) |next_index| {
|
||||
atom_index = next_index;
|
||||
} else break;
|
||||
}
|
||||
|
||||
if (atom.next_index) |next_index| {
|
||||
atom_index = next_index;
|
||||
} else break;
|
||||
}
|
||||
|
||||
start = start_aligned + header.size;
|
||||
@ -1675,7 +1676,7 @@ pub const Zld = struct {
|
||||
reserved2: u32 = 0,
|
||||
};
|
||||
|
||||
fn initSection(
|
||||
pub fn initSection(
|
||||
self: *Zld,
|
||||
segname: []const u8,
|
||||
sectname: []const u8,
|
||||
@ -1685,7 +1686,7 @@ pub const Zld = struct {
|
||||
log.debug("creating section '{s},{s}'", .{ segname, sectname });
|
||||
const index = @intCast(u8, self.sections.slice().len);
|
||||
try self.sections.append(gpa, .{
|
||||
.segment_index = undefined,
|
||||
.segment_index = undefined, // Segments will be created automatically later down the pipeline
|
||||
.header = .{
|
||||
.sectname = makeStaticString(sectname),
|
||||
.segname = makeStaticString(segname),
|
||||
@ -1693,13 +1694,13 @@ pub const Zld = struct {
|
||||
.reserved1 = opts.reserved1,
|
||||
.reserved2 = opts.reserved2,
|
||||
},
|
||||
.first_atom_index = undefined,
|
||||
.last_atom_index = undefined,
|
||||
.first_atom_index = 0,
|
||||
.last_atom_index = 0,
|
||||
});
|
||||
return index;
|
||||
}
|
||||
|
||||
inline fn getSegmentPrecedence(segname: []const u8) u4 {
|
||||
fn getSegmentPrecedence(segname: []const u8) u4 {
|
||||
if (mem.eql(u8, segname, "__PAGEZERO")) return 0x0;
|
||||
if (mem.eql(u8, segname, "__TEXT")) return 0x1;
|
||||
if (mem.eql(u8, segname, "__DATA_CONST")) return 0x2;
|
||||
@ -1708,14 +1709,14 @@ pub const Zld = struct {
|
||||
return 0x4;
|
||||
}
|
||||
|
||||
inline fn getSegmentMemoryProtection(segname: []const u8) macho.vm_prot_t {
|
||||
fn getSegmentMemoryProtection(segname: []const u8) macho.vm_prot_t {
|
||||
if (mem.eql(u8, segname, "__PAGEZERO")) return macho.PROT.NONE;
|
||||
if (mem.eql(u8, segname, "__TEXT")) return macho.PROT.READ | macho.PROT.EXEC;
|
||||
if (mem.eql(u8, segname, "__LINKEDIT")) return macho.PROT.READ;
|
||||
return macho.PROT.READ | macho.PROT.WRITE;
|
||||
}
|
||||
|
||||
inline fn getSectionPrecedence(header: macho.section_64) u8 {
|
||||
fn getSectionPrecedence(header: macho.section_64) u8 {
|
||||
const segment_precedence: u4 = getSegmentPrecedence(header.segName());
|
||||
const section_precedence: u4 = blk: {
|
||||
if (header.isCode()) {
|
||||
@ -1732,10 +1733,11 @@ pub const Zld = struct {
|
||||
macho.S_ZEROFILL => break :blk 0xf,
|
||||
macho.S_THREAD_LOCAL_REGULAR => break :blk 0xd,
|
||||
macho.S_THREAD_LOCAL_ZEROFILL => break :blk 0xe,
|
||||
else => if (mem.eql(u8, "__eh_frame", header.sectName()))
|
||||
break :blk 0xf
|
||||
else
|
||||
break :blk 0x3,
|
||||
else => {
|
||||
if (mem.eql(u8, "__unwind_info", header.sectName())) break :blk 0xe;
|
||||
if (mem.eql(u8, "__eh_frame", header.sectName())) break :blk 0xf;
|
||||
break :blk 0x3;
|
||||
},
|
||||
}
|
||||
};
|
||||
return (@intCast(u8, segment_precedence) << 4) + section_precedence;
|
||||
@ -1768,8 +1770,8 @@ pub const Zld = struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn writeLinkeditSegmentData(self: *Zld, reverse_lookups: [][]u32) !void {
|
||||
try self.writeDyldInfoData(reverse_lookups);
|
||||
fn writeLinkeditSegmentData(self: *Zld) !void {
|
||||
try self.writeDyldInfoData();
|
||||
try self.writeFunctionStarts();
|
||||
try self.writeDataInCode();
|
||||
try self.writeSymtabs();
|
||||
@ -1806,7 +1808,7 @@ pub const Zld = struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn collectRebaseData(self: *Zld, rebase: *Rebase, reverse_lookups: [][]u32) !void {
|
||||
fn collectRebaseData(self: *Zld, rebase: *Rebase) !void {
|
||||
log.debug("collecting rebase data", .{});
|
||||
|
||||
// First, unpack GOT entries
|
||||
@ -1862,6 +1864,7 @@ pub const Zld = struct {
|
||||
|
||||
const cpu_arch = self.options.target.cpu.arch;
|
||||
var atom_index = slice.items(.first_atom_index)[sect_id];
|
||||
if (atom_index == 0) continue;
|
||||
|
||||
while (true) {
|
||||
const atom = self.getAtom(atom_index);
|
||||
@ -1899,7 +1902,7 @@ pub const Zld = struct {
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
const target = Atom.parseRelocTarget(self, atom_index, rel, reverse_lookups[atom.getFile().?]);
|
||||
const target = Atom.parseRelocTarget(self, atom_index, rel);
|
||||
const target_sym = self.getSymbol(target);
|
||||
if (target_sym.undf()) continue;
|
||||
|
||||
@ -1962,7 +1965,10 @@ pub const Zld = struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn collectBindData(self: *Zld, bind: *Bind, reverse_lookups: [][]u32) !void {
|
||||
fn collectBindData(
|
||||
self: *Zld,
|
||||
bind: *Bind,
|
||||
) !void {
|
||||
log.debug("collecting bind data", .{});
|
||||
|
||||
// First, unpack GOT section
|
||||
@ -1993,6 +1999,7 @@ pub const Zld = struct {
|
||||
|
||||
const cpu_arch = self.options.target.cpu.arch;
|
||||
var atom_index = slice.items(.first_atom_index)[sect_id];
|
||||
if (atom_index == 0) continue;
|
||||
|
||||
log.debug("{s},{s}", .{ header.segName(), header.sectName() });
|
||||
|
||||
@ -2033,7 +2040,7 @@ pub const Zld = struct {
|
||||
else => unreachable,
|
||||
}
|
||||
|
||||
const global = Atom.parseRelocTarget(self, atom_index, rel, reverse_lookups[atom.getFile().?]);
|
||||
const global = Atom.parseRelocTarget(self, atom_index, rel);
|
||||
const bind_sym_name = self.getSymbolName(global);
|
||||
const bind_sym = self.getSymbol(global);
|
||||
if (!bind_sym.undf()) continue;
|
||||
@ -2164,16 +2171,18 @@ pub const Zld = struct {
|
||||
try trie.finalize(gpa);
|
||||
}
|
||||
|
||||
fn writeDyldInfoData(self: *Zld, reverse_lookups: [][]u32) !void {
|
||||
fn writeDyldInfoData(
|
||||
self: *Zld,
|
||||
) !void {
|
||||
const gpa = self.gpa;
|
||||
|
||||
var rebase = Rebase{};
|
||||
defer rebase.deinit(gpa);
|
||||
try self.collectRebaseData(&rebase, reverse_lookups);
|
||||
try self.collectRebaseData(&rebase);
|
||||
|
||||
var bind = Bind{};
|
||||
defer bind.deinit(gpa);
|
||||
try self.collectBindData(&bind, reverse_lookups);
|
||||
try self.collectBindData(&bind);
|
||||
|
||||
var lazy_bind = LazyBind{};
|
||||
defer lazy_bind.deinit(gpa);
|
||||
@ -2873,12 +2882,12 @@ pub const Zld = struct {
|
||||
return buf;
|
||||
}
|
||||
|
||||
pub inline fn getAtomPtr(self: *Zld, atom_index: AtomIndex) *Atom {
|
||||
pub fn getAtomPtr(self: *Zld, atom_index: AtomIndex) *Atom {
|
||||
assert(atom_index < self.atoms.items.len);
|
||||
return &self.atoms.items[atom_index];
|
||||
}
|
||||
|
||||
pub inline fn getAtom(self: Zld, atom_index: AtomIndex) Atom {
|
||||
pub fn getAtom(self: Zld, atom_index: AtomIndex) Atom {
|
||||
assert(atom_index < self.atoms.items.len);
|
||||
return self.atoms.items[atom_index];
|
||||
}
|
||||
@ -2889,17 +2898,17 @@ pub const Zld = struct {
|
||||
} else return null;
|
||||
}
|
||||
|
||||
pub inline fn getSegment(self: Zld, sect_id: u8) macho.segment_command_64 {
|
||||
pub fn getSegment(self: Zld, sect_id: u8) macho.segment_command_64 {
|
||||
const index = self.sections.items(.segment_index)[sect_id];
|
||||
return self.segments.items[index];
|
||||
}
|
||||
|
||||
pub inline fn getSegmentPtr(self: *Zld, sect_id: u8) *macho.segment_command_64 {
|
||||
pub fn getSegmentPtr(self: *Zld, sect_id: u8) *macho.segment_command_64 {
|
||||
const index = self.sections.items(.segment_index)[sect_id];
|
||||
return &self.segments.items[index];
|
||||
}
|
||||
|
||||
pub inline fn getLinkeditSegmentPtr(self: *Zld) *macho.segment_command_64 {
|
||||
pub fn getLinkeditSegmentPtr(self: *Zld) *macho.segment_command_64 {
|
||||
assert(self.segments.items.len > 0);
|
||||
const seg = &self.segments.items[self.segments.items.len - 1];
|
||||
assert(mem.eql(u8, seg.segName(), "__LINKEDIT"));
|
||||
@ -3384,6 +3393,8 @@ pub const Zld = struct {
|
||||
const slice = self.sections.slice();
|
||||
for (slice.items(.first_atom_index)) |first_atom_index, sect_id| {
|
||||
var atom_index = first_atom_index;
|
||||
if (atom_index == 0) continue;
|
||||
|
||||
const header = slice.items(.header)[sect_id];
|
||||
|
||||
log.debug("{s},{s}", .{ header.segName(), header.sectName() });
|
||||
@ -3412,7 +3423,7 @@ pub const Zld = struct {
|
||||
sym.n_value,
|
||||
atom.size,
|
||||
atom.alignment,
|
||||
atom.file,
|
||||
atom.getFile(),
|
||||
sym.n_sect,
|
||||
});
|
||||
|
||||
@ -3475,19 +3486,19 @@ const IndirectPointer = struct {
|
||||
}
|
||||
};
|
||||
|
||||
pub const SymbolWithLoc = struct {
|
||||
pub const SymbolWithLoc = extern struct {
|
||||
// Index into the respective symbol table.
|
||||
sym_index: u32,
|
||||
|
||||
// -1 means it's a synthetic global.
|
||||
file: i32 = -1,
|
||||
// 0 means it's a synthetic global.
|
||||
file: u32 = 0,
|
||||
|
||||
pub inline fn getFile(self: SymbolWithLoc) ?u31 {
|
||||
if (self.file == -1) return null;
|
||||
return @intCast(u31, self.file);
|
||||
pub fn getFile(self: SymbolWithLoc) ?u32 {
|
||||
if (self.file == 0) return null;
|
||||
return self.file - 1;
|
||||
}
|
||||
|
||||
pub inline fn eql(self: SymbolWithLoc, other: SymbolWithLoc) bool {
|
||||
pub fn eql(self: SymbolWithLoc, other: SymbolWithLoc) bool {
|
||||
return self.file == other.file and self.sym_index == other.sym_index;
|
||||
}
|
||||
};
|
||||
@ -3965,7 +3976,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
|
||||
};
|
||||
|
||||
for (zld.objects.items) |_, object_id| {
|
||||
try zld.resolveSymbolsInObject(@intCast(u16, object_id), &resolver);
|
||||
try zld.resolveSymbolsInObject(@intCast(u32, object_id), &resolver);
|
||||
}
|
||||
|
||||
try zld.resolveSymbolsInArchives(&resolver);
|
||||
@ -3995,16 +4006,11 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
|
||||
}
|
||||
|
||||
for (zld.objects.items) |*object, object_id| {
|
||||
try object.splitIntoAtoms(&zld, @intCast(u31, object_id));
|
||||
}
|
||||
|
||||
var reverse_lookups: [][]u32 = try arena.alloc([]u32, zld.objects.items.len);
|
||||
for (zld.objects.items) |object, i| {
|
||||
reverse_lookups[i] = try object.createReverseSymbolLookup(arena);
|
||||
try object.splitIntoAtoms(&zld, @intCast(u32, object_id));
|
||||
}
|
||||
|
||||
if (gc_sections) {
|
||||
try dead_strip.gcAtoms(&zld, reverse_lookups);
|
||||
try dead_strip.gcAtoms(&zld);
|
||||
}
|
||||
|
||||
try zld.createDyldPrivateAtom();
|
||||
@ -4019,13 +4025,24 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
|
||||
if (header.isZerofill()) continue;
|
||||
|
||||
const relocs = Atom.getAtomRelocs(&zld, atom_index);
|
||||
try Atom.scanAtomRelocs(&zld, atom_index, relocs, reverse_lookups[atom.getFile().?]);
|
||||
try Atom.scanAtomRelocs(&zld, atom_index, relocs);
|
||||
}
|
||||
}
|
||||
|
||||
try eh_frame.scanRelocs(&zld);
|
||||
try UnwindInfo.scanRelocs(&zld);
|
||||
|
||||
try zld.createDyldStubBinderGotAtom();
|
||||
|
||||
try zld.calcSectionSizes(reverse_lookups);
|
||||
try zld.calcSectionSizes();
|
||||
|
||||
var unwind_info = UnwindInfo{ .gpa = zld.gpa };
|
||||
defer unwind_info.deinit();
|
||||
try unwind_info.collect(&zld);
|
||||
|
||||
try eh_frame.calcSectionSize(&zld, &unwind_info);
|
||||
try unwind_info.calcSectionSize(&zld);
|
||||
|
||||
try zld.pruneAndSortSections();
|
||||
try zld.createSegments();
|
||||
try zld.allocateSegments();
|
||||
@ -4039,8 +4056,10 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
|
||||
zld.logAtoms();
|
||||
}
|
||||
|
||||
try zld.writeAtoms(reverse_lookups);
|
||||
try zld.writeLinkeditSegmentData(reverse_lookups);
|
||||
try zld.writeAtoms();
|
||||
try eh_frame.write(&zld, &unwind_info);
|
||||
try unwind_info.write(&zld);
|
||||
try zld.writeLinkeditSegmentData();
|
||||
|
||||
// If the last section of __DATA segment is zerofill section, we need to ensure
|
||||
// that the free space between the end of the last non-zerofill section of __DATA
|
||||
|
||||
Loading…
Reference in New Issue
Block a user