mirror of
https://github.com/ziglang/zig.git
synced 2026-02-13 04:48:20 +00:00
macho: change all occurrences of TextBlock into Atom
and unify allocateAtom with allocateTextBlock.
This commit is contained in:
Jakub Konka
parent
6e0c3950b8
commit
31dcb0dde7
@ -158,8 +158,8 @@ stub_preamble_sym_index: ?u32 = null,
|
||||
strtab: std.ArrayListUnmanaged(u8) = .{},
|
||||
strtab_dir: std.HashMapUnmanaged(u32, u32, StringIndexContext, std.hash_map.default_max_load_percentage) = .{},
|
||||
|
||||
got_entries_map: std.AutoArrayHashMapUnmanaged(GotIndirectionKey, *TextBlock) = .{},
|
||||
stubs_map: std.AutoArrayHashMapUnmanaged(u32, *TextBlock) = .{},
|
||||
got_entries_map: std.AutoArrayHashMapUnmanaged(GotIndirectionKey, *Atom) = .{},
|
||||
stubs_map: std.AutoArrayHashMapUnmanaged(u32, *Atom) = .{},
|
||||
|
||||
error_flags: File.ErrorFlags = File.ErrorFlags{},
|
||||
|
||||
@ -171,12 +171,12 @@ has_stabs: bool = false,
|
||||
|
||||
section_ordinals: std.AutoArrayHashMapUnmanaged(MatchingSection, void) = .{},
|
||||
|
||||
/// A list of text blocks that have surplus capacity. This list can have false
|
||||
/// A list of atoms that have surplus capacity. This list can have false
|
||||
/// positives, as functions grow and shrink over time, only sometimes being added
|
||||
/// or removed from the freelist.
|
||||
///
|
||||
/// A text block has surplus capacity when its overcapacity value is greater than
|
||||
/// padToIdeal(minimum_text_block_size). That is, when it has so
|
||||
/// An atom has surplus capacity when its overcapacity value is greater than
|
||||
/// padToIdeal(minimum_atom_size). That is, when it has so
|
||||
/// much extra capacity, that we could fit a small new symbol in it, itself with
|
||||
/// ideal_capacity or more.
|
||||
///
|
||||
@ -184,23 +184,23 @@ section_ordinals: std.AutoArrayHashMapUnmanaged(MatchingSection, void) = .{},
|
||||
///
|
||||
/// Overcapacity is measured by actual_capacity - ideal_capacity. Note that
|
||||
/// overcapacity can be negative. A simple way to have negative overcapacity is to
|
||||
/// allocate a fresh text block, which will have ideal capacity, and then grow it
|
||||
/// allocate a fresh atom, which will have ideal capacity, and then grow it
|
||||
/// by 1 byte. It will then have -1 overcapacity.
|
||||
block_free_lists: std.AutoHashMapUnmanaged(MatchingSection, std.ArrayListUnmanaged(*TextBlock)) = .{},
|
||||
atom_free_lists: std.AutoHashMapUnmanaged(MatchingSection, std.ArrayListUnmanaged(*Atom)) = .{},
|
||||
|
||||
/// Pointer to the last allocated text block
|
||||
blocks: std.AutoHashMapUnmanaged(MatchingSection, *TextBlock) = .{},
|
||||
/// Pointer to the last allocated atom
|
||||
atoms: std.AutoHashMapUnmanaged(MatchingSection, *Atom) = .{},
|
||||
|
||||
/// List of TextBlocks that are owned directly by the linker.
|
||||
/// Currently these are only TextBlocks that are the result of linking
|
||||
/// object files. TextBlock which take part in incremental linking are
|
||||
/// List of atoms that are owned directly by the linker.
|
||||
/// Currently these are only atoms that are the result of linking
|
||||
/// object files. Atoms which take part in incremental linking are
|
||||
/// at present owned by Module.Decl.
|
||||
/// TODO consolidate this.
|
||||
managed_blocks: std.ArrayListUnmanaged(*TextBlock) = .{},
|
||||
managed_atoms: std.ArrayListUnmanaged(*Atom) = .{},
|
||||
|
||||
/// Table of Decls that are currently alive.
|
||||
/// We store them here so that we can properly dispose of any allocated
|
||||
/// memory within the TextBlock in the incremental linker.
|
||||
/// memory within the atom in the incremental linker.
|
||||
/// TODO consolidate this.
|
||||
decls: std.AutoArrayHashMapUnmanaged(*Module.Decl, void) = .{},
|
||||
|
||||
@ -768,31 +768,8 @@ pub fn flush(self: *MachO, comp: *Compilation) !void {
|
||||
try self.addDataInCodeLC();
|
||||
try self.addCodeSignatureLC();
|
||||
|
||||
try self.parseTextBlocks();
|
||||
try self.parseObjectsIntoAtoms();
|
||||
try self.allocateGlobalSymbols();
|
||||
{
|
||||
log.debug("locals:", .{});
|
||||
for (self.locals.items) |sym| {
|
||||
log.debug(" {s}: {}", .{ self.getString(sym.n_strx), sym });
|
||||
}
|
||||
log.debug("globals:", .{});
|
||||
for (self.globals.items) |sym| {
|
||||
log.debug(" {s}: {}", .{ self.getString(sym.n_strx), sym });
|
||||
}
|
||||
log.debug("undefs:", .{});
|
||||
for (self.undefs.items) |sym| {
|
||||
log.debug(" {s}: {}", .{ self.getString(sym.n_strx), sym });
|
||||
}
|
||||
log.debug("unresolved:", .{});
|
||||
for (self.unresolved.keys()) |key| {
|
||||
log.debug(" {d} => {s}", .{ key, self.unresolved.get(key).? });
|
||||
}
|
||||
log.debug("resolved:", .{});
|
||||
var it = self.symbol_resolver.iterator();
|
||||
while (it.next()) |entry| {
|
||||
log.debug(" {s} => {}", .{ self.getString(entry.key_ptr.*), entry.value_ptr.* });
|
||||
}
|
||||
}
|
||||
try self.writeAtoms();
|
||||
|
||||
if (self.bss_section_index) |idx| {
|
||||
@ -1637,87 +1614,24 @@ pub fn getMatchingSection(self: *MachO, sect: macho.section_64) !?MatchingSectio
|
||||
return res;
|
||||
}
|
||||
|
||||
pub fn createEmptyAtom(self: *MachO, local_sym_index: u32, size: u64, alignment: u32) !*TextBlock {
|
||||
pub fn createEmptyAtom(self: *MachO, local_sym_index: u32, size: u64, alignment: u32) !*Atom {
|
||||
const code = try self.base.allocator.alloc(u8, size);
|
||||
defer self.base.allocator.free(code);
|
||||
mem.set(u8, code, 0);
|
||||
|
||||
const atom = try self.base.allocator.create(TextBlock);
|
||||
const atom = try self.base.allocator.create(Atom);
|
||||
errdefer self.base.allocator.destroy(atom);
|
||||
atom.* = TextBlock.empty;
|
||||
atom.* = Atom.empty;
|
||||
atom.local_sym_index = local_sym_index;
|
||||
atom.size = size;
|
||||
atom.alignment = alignment;
|
||||
try atom.code.appendSlice(self.base.allocator, code);
|
||||
try self.managed_blocks.append(self.base.allocator, atom);
|
||||
try self.managed_atoms.append(self.base.allocator, atom);
|
||||
|
||||
return atom;
|
||||
}
|
||||
|
||||
pub fn allocateAtom(self: *MachO, atom: *TextBlock, match: MatchingSection) !u64 {
|
||||
const seg = &self.load_commands.items[match.seg].Segment;
|
||||
const sect = &seg.sections.items[match.sect];
|
||||
|
||||
const sym = &self.locals.items[atom.local_sym_index];
|
||||
const needs_padding = match.seg == self.text_segment_cmd_index.? and match.sect == self.text_section_index.?;
|
||||
|
||||
var atom_placement: ?*TextBlock = null;
|
||||
const atom_alignment = try math.powi(u32, 2, atom.alignment);
|
||||
|
||||
// TODO converge with `allocateTextBlock` and handle free list
|
||||
var vaddr = if (self.blocks.get(match)) |last| blk: {
|
||||
const last_atom_sym = self.locals.items[last.local_sym_index];
|
||||
const ideal_capacity = if (needs_padding) padToIdeal(last.size) else last.size;
|
||||
const ideal_capacity_end_vaddr = last_atom_sym.n_value + ideal_capacity;
|
||||
const new_start_vaddr = mem.alignForwardGeneric(u64, ideal_capacity_end_vaddr, atom_alignment);
|
||||
atom_placement = last;
|
||||
break :blk new_start_vaddr;
|
||||
} else mem.alignForwardGeneric(u64, sect.addr, atom_alignment);
|
||||
|
||||
// TODO what if the section which was preallocated is not aligned to the maximum (section) alignment?
|
||||
// Should we move the section?
|
||||
|
||||
log.debug("allocating atom for symbol {s} at address 0x{x}", .{ self.getString(sym.n_strx), vaddr });
|
||||
|
||||
const expand_section = atom_placement == null or atom_placement.?.next == null;
|
||||
if (expand_section) {
|
||||
const needed_size = @intCast(u32, (vaddr + atom.size) - sect.addr);
|
||||
try self.growSection(match, needed_size);
|
||||
sect.size = needed_size;
|
||||
self.load_commands_dirty = true;
|
||||
}
|
||||
sect.@"align" = math.max(sect.@"align", atom.alignment);
|
||||
|
||||
const n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
|
||||
sym.n_value = vaddr;
|
||||
sym.n_sect = n_sect;
|
||||
|
||||
// Update each alias (if any)
|
||||
for (atom.aliases.items) |index| {
|
||||
const alias_sym = &self.locals.items[index];
|
||||
alias_sym.n_value = vaddr;
|
||||
alias_sym.n_sect = n_sect;
|
||||
}
|
||||
|
||||
// Update each symbol contained within the TextBlock
|
||||
for (atom.contained.items) |sym_at_off| {
|
||||
const contained_sym = &self.locals.items[sym_at_off.local_sym_index];
|
||||
contained_sym.n_value = vaddr + sym_at_off.offset;
|
||||
contained_sym.n_sect = n_sect;
|
||||
}
|
||||
|
||||
if (self.blocks.getPtr(match)) |last| {
|
||||
last.*.next = atom;
|
||||
atom.prev = last.*;
|
||||
last.* = atom;
|
||||
} else {
|
||||
try self.blocks.putNoClobber(self.base.allocator, match, atom);
|
||||
}
|
||||
|
||||
return vaddr;
|
||||
}
|
||||
|
||||
pub fn writeAtom(self: *MachO, atom: *TextBlock, match: MatchingSection) !void {
|
||||
pub fn writeAtom(self: *MachO, atom: *Atom, match: MatchingSection) !void {
|
||||
const seg = self.load_commands.items[match.seg].Segment;
|
||||
const sect = seg.sections.items[match.sect];
|
||||
const sym = self.locals.items[atom.local_sym_index];
|
||||
@ -1728,7 +1642,7 @@ pub fn writeAtom(self: *MachO, atom: *TextBlock, match: MatchingSection) !void {
|
||||
}
|
||||
|
||||
fn allocateLocalSymbols(self: *MachO, match: MatchingSection, offset: i64) !void {
|
||||
var atom = self.blocks.get(match) orelse return;
|
||||
var atom = self.atoms.get(match) orelse return;
|
||||
|
||||
while (true) {
|
||||
const atom_sym = &self.locals.items[atom.local_sym_index];
|
||||
@ -1751,8 +1665,6 @@ fn allocateLocalSymbols(self: *MachO, match: MatchingSection, offset: i64) !void
|
||||
}
|
||||
|
||||
fn allocateGlobalSymbols(self: *MachO) !void {
|
||||
// TODO should we do this in `allocateAtom` (or similar)? Then, we would need to
|
||||
// store the link atom -> globals somewhere.
|
||||
var sym_it = self.symbol_resolver.valueIterator();
|
||||
while (sym_it.next()) |resolv| {
|
||||
if (resolv.where != .global) continue;
|
||||
@ -1770,12 +1682,14 @@ fn writeAtoms(self: *MachO) !void {
|
||||
defer buffer.deinit();
|
||||
var file_offset: ?u64 = null;
|
||||
|
||||
var it = self.blocks.iterator();
|
||||
var it = self.atoms.iterator();
|
||||
while (it.next()) |entry| {
|
||||
const match = entry.key_ptr.*;
|
||||
const seg = self.load_commands.items[match.seg].Segment;
|
||||
const sect = seg.sections.items[match.sect];
|
||||
var atom: *TextBlock = entry.value_ptr.*;
|
||||
var atom: *Atom = entry.value_ptr.*;
|
||||
|
||||
log.debug("writing atoms in {s},{s}", .{ commands.segmentName(sect), commands.sectionName(sect) });
|
||||
|
||||
while (atom.prev) |prev| {
|
||||
atom = prev;
|
||||
@ -1789,6 +1703,8 @@ fn writeAtoms(self: *MachO) !void {
|
||||
break :blk next_sym.n_value - (atom_sym.n_value + atom.size);
|
||||
} else 0;
|
||||
|
||||
log.debug(" (adding atom {s} to buffer: {})", .{ self.getString(atom_sym.n_strx), atom_sym });
|
||||
|
||||
try atom.resolveRelocs(self);
|
||||
try buffer.appendSlice(atom.code.items);
|
||||
try buffer.ensureUnusedCapacity(padding_size);
|
||||
@ -1824,7 +1740,7 @@ fn writeAtoms(self: *MachO) !void {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn createGotAtom(self: *MachO, key: GotIndirectionKey) !*TextBlock {
|
||||
pub fn createGotAtom(self: *MachO, key: GotIndirectionKey) !*Atom {
|
||||
const local_sym_index = @intCast(u32, self.locals.items.len);
|
||||
try self.locals.append(self.base.allocator, .{
|
||||
.n_strx = try self.makeString("l_zld_got_entry"),
|
||||
@ -1860,7 +1776,7 @@ pub fn createGotAtom(self: *MachO, key: GotIndirectionKey) !*TextBlock {
|
||||
return atom;
|
||||
}
|
||||
|
||||
fn createDyldPrivateAtom(self: *MachO) !*TextBlock {
|
||||
fn createDyldPrivateAtom(self: *MachO) !*Atom {
|
||||
const local_sym_index = @intCast(u32, self.locals.items.len);
|
||||
try self.locals.append(self.base.allocator, .{
|
||||
.n_strx = try self.makeString("l_zld_dyld_private"),
|
||||
@ -1873,7 +1789,7 @@ fn createDyldPrivateAtom(self: *MachO) !*TextBlock {
|
||||
return self.createEmptyAtom(local_sym_index, @sizeOf(u64), 3);
|
||||
}
|
||||
|
||||
fn createStubHelperPreambleAtom(self: *MachO) !*TextBlock {
|
||||
fn createStubHelperPreambleAtom(self: *MachO) !*Atom {
|
||||
const arch = self.base.options.target.cpu.arch;
|
||||
const size: u64 = switch (arch) {
|
||||
.x86_64 => 15,
|
||||
@ -2006,7 +1922,7 @@ fn createStubHelperPreambleAtom(self: *MachO) !*TextBlock {
|
||||
return atom;
|
||||
}
|
||||
|
||||
pub fn createStubHelperAtom(self: *MachO) !*TextBlock {
|
||||
pub fn createStubHelperAtom(self: *MachO) !*Atom {
|
||||
const arch = self.base.options.target.cpu.arch;
|
||||
const stub_size: u4 = switch (arch) {
|
||||
.x86_64 => 10,
|
||||
@ -2072,7 +1988,7 @@ pub fn createStubHelperAtom(self: *MachO) !*TextBlock {
|
||||
return atom;
|
||||
}
|
||||
|
||||
pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, lazy_binding_sym_index: u32) !*TextBlock {
|
||||
pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, lazy_binding_sym_index: u32) !*Atom {
|
||||
const local_sym_index = @intCast(u32, self.locals.items.len);
|
||||
try self.locals.append(self.base.allocator, .{
|
||||
.n_strx = try self.makeString("l_zld_lazy_ptr"),
|
||||
@ -2102,7 +2018,7 @@ pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, lazy_binding_sym
|
||||
return atom;
|
||||
}
|
||||
|
||||
pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*TextBlock {
|
||||
pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom {
|
||||
const arch = self.base.options.target.cpu.arch;
|
||||
const alignment: u2 = switch (arch) {
|
||||
.x86_64 => 0,
|
||||
@ -2273,14 +2189,6 @@ fn resolveSymbolsInObject(
|
||||
continue;
|
||||
},
|
||||
.undef => {
|
||||
// const undef = &self.undefs.items[resolv.where_index];
|
||||
// undef.* = .{
|
||||
// .n_strx = 0,
|
||||
// .n_type = macho.N_UNDF,
|
||||
// .n_sect = 0,
|
||||
// .n_desc = 0,
|
||||
// .n_value = 0,
|
||||
// };
|
||||
_ = self.unresolved.fetchSwapRemove(resolv.where_index);
|
||||
},
|
||||
}
|
||||
@ -2437,23 +2345,36 @@ fn resolveSymbols(self: *MachO) !void {
|
||||
resolv.local_sym_index = local_sym_index;
|
||||
|
||||
const atom = try self.createEmptyAtom(local_sym_index, size, alignment);
|
||||
_ = try self.allocateAtom(atom, match);
|
||||
const alignment_pow_2 = try math.powi(u32, 2, alignment);
|
||||
const vaddr = try self.allocateAtom(atom, size, alignment_pow_2, match);
|
||||
sym.n_value = vaddr;
|
||||
}
|
||||
|
||||
try self.resolveDyldStubBinder();
|
||||
{
|
||||
const atom = try self.createDyldPrivateAtom();
|
||||
_ = try self.allocateAtom(atom, .{
|
||||
const match = MatchingSection{
|
||||
.seg = self.data_segment_cmd_index.?,
|
||||
.sect = self.data_section_index.?,
|
||||
});
|
||||
};
|
||||
const atom = try self.createDyldPrivateAtom();
|
||||
const sym = &self.locals.items[atom.local_sym_index];
|
||||
const vaddr = try self.allocateAtom(atom, @sizeOf(u64), 8, match);
|
||||
sym.n_value = vaddr;
|
||||
sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
|
||||
log.debug("allocated {s} atom at 0x{x}", .{ self.getString(sym.n_strx), vaddr });
|
||||
}
|
||||
{
|
||||
const atom = try self.createStubHelperPreambleAtom();
|
||||
_ = try self.allocateAtom(atom, .{
|
||||
const match = MatchingSection{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.stub_helper_section_index.?,
|
||||
});
|
||||
};
|
||||
const atom = try self.createStubHelperPreambleAtom();
|
||||
const sym = &self.locals.items[atom.local_sym_index];
|
||||
const alignment = try math.powi(u32, 2, atom.alignment);
|
||||
const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
|
||||
sym.n_value = vaddr;
|
||||
sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
|
||||
log.debug("allocated {s} atom at 0x{x}", .{ self.getString(sym.n_strx), vaddr });
|
||||
}
|
||||
|
||||
// Third pass, resolve symbols in dynamic libraries.
|
||||
@ -2483,30 +2404,45 @@ fn resolveSymbols(self: *MachO) !void {
|
||||
.stub => {
|
||||
if (self.stubs_map.contains(resolv.where_index)) break :outer_blk;
|
||||
const stub_helper_atom = blk: {
|
||||
const atom = try self.createStubHelperAtom();
|
||||
_ = try self.allocateAtom(atom, .{
|
||||
const match = MatchingSection{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.stub_helper_section_index.?,
|
||||
});
|
||||
};
|
||||
const atom = try self.createStubHelperAtom();
|
||||
const atom_sym = &self.locals.items[atom.local_sym_index];
|
||||
const alignment = try math.powi(u32, 2, atom.alignment);
|
||||
const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
|
||||
atom_sym.n_value = vaddr;
|
||||
atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
|
||||
break :blk atom;
|
||||
};
|
||||
const laptr_atom = blk: {
|
||||
const match = MatchingSection{
|
||||
.seg = self.data_segment_cmd_index.?,
|
||||
.sect = self.la_symbol_ptr_section_index.?,
|
||||
};
|
||||
const atom = try self.createLazyPointerAtom(
|
||||
stub_helper_atom.local_sym_index,
|
||||
resolv.where_index,
|
||||
);
|
||||
_ = try self.allocateAtom(atom, .{
|
||||
.seg = self.data_segment_cmd_index.?,
|
||||
.sect = self.la_symbol_ptr_section_index.?,
|
||||
});
|
||||
const atom_sym = &self.locals.items[atom.local_sym_index];
|
||||
const alignment = try math.powi(u32, 2, atom.alignment);
|
||||
const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
|
||||
atom_sym.n_value = vaddr;
|
||||
atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
|
||||
break :blk atom;
|
||||
};
|
||||
const stub_atom = blk: {
|
||||
const atom = try self.createStubAtom(laptr_atom.local_sym_index);
|
||||
_ = try self.allocateAtom(atom, .{
|
||||
const match = MatchingSection{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.stubs_section_index.?,
|
||||
});
|
||||
};
|
||||
const atom = try self.createStubAtom(laptr_atom.local_sym_index);
|
||||
const atom_sym = &self.locals.items[atom.local_sym_index];
|
||||
const alignment = try math.powi(u32, 2, atom.alignment);
|
||||
const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
|
||||
atom_sym.n_value = vaddr;
|
||||
atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
|
||||
break :blk atom;
|
||||
};
|
||||
try self.stubs_map.putNoClobber(self.base.allocator, resolv.where_index, stub_atom);
|
||||
@ -2565,7 +2501,10 @@ fn resolveSymbols(self: *MachO) !void {
|
||||
// TODO perhaps we should special-case special symbols? Create a separate
|
||||
// linked list of atoms?
|
||||
const atom = try self.createEmptyAtom(local_sym_index, 0, 0);
|
||||
_ = try self.allocateAtom(atom, match);
|
||||
const sym = &self.locals.items[local_sym_index];
|
||||
const vaddr = try self.allocateAtom(atom, 0, 1, match);
|
||||
sym.n_value = vaddr;
|
||||
atom.dirty = false; // We don't really want to write it to file.
|
||||
}
|
||||
|
||||
for (self.unresolved.keys()) |index| {
|
||||
@ -2632,10 +2571,14 @@ fn resolveDyldStubBinder(self: *MachO) !void {
|
||||
.seg = self.data_const_segment_cmd_index.?,
|
||||
.sect = self.got_section_index.?,
|
||||
};
|
||||
_ = try self.allocateAtom(atom, match);
|
||||
const atom_sym = &self.locals.items[atom.local_sym_index];
|
||||
const vaddr = try self.allocateAtom(atom, @sizeOf(u64), 8, match);
|
||||
atom_sym.n_value = vaddr;
|
||||
atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
|
||||
log.debug("allocated {s} atom at 0x{x}", .{ self.getString(sym.n_strx), vaddr });
|
||||
}
|
||||
|
||||
fn parseTextBlocks(self: *MachO) !void {
|
||||
fn parseObjectsIntoAtoms(self: *MachO) !void {
|
||||
var parsed_atoms = Object.ParsedAtoms.init(self.base.allocator);
|
||||
defer parsed_atoms.deinit();
|
||||
|
||||
@ -2710,7 +2653,7 @@ fn parseTextBlocks(self: *MachO) !void {
|
||||
metadata.alignment,
|
||||
});
|
||||
|
||||
const sect_size = if (self.blocks.get(match)) |last| blk: {
|
||||
const sect_size = if (self.atoms.get(match)) |last| blk: {
|
||||
const last_atom_sym = self.locals.items[last.local_sym_index];
|
||||
break :blk last_atom_sym.n_value + last.size - sect.addr;
|
||||
} else 0;
|
||||
@ -2720,7 +2663,7 @@ fn parseTextBlocks(self: *MachO) !void {
|
||||
try self.growSection(match, needed_size);
|
||||
sect.size = needed_size;
|
||||
|
||||
var base_vaddr = if (self.blocks.get(match)) |last| blk: {
|
||||
var base_vaddr = if (self.atoms.get(match)) |last| blk: {
|
||||
const last_atom_sym = self.locals.items[last.local_sym_index];
|
||||
break :blk last_atom_sym.n_value + last.size;
|
||||
} else sect.addr;
|
||||
@ -2750,7 +2693,7 @@ fn parseTextBlocks(self: *MachO) !void {
|
||||
alias_sym.n_sect = n_sect;
|
||||
}
|
||||
|
||||
// Update each symbol contained within the TextBlock
|
||||
// Update each symbol contained within the atom
|
||||
for (atom.contained.items) |sym_at_off| {
|
||||
const contained_sym = &self.locals.items[sym_at_off.local_sym_index];
|
||||
contained_sym.n_value = base_vaddr + sym_at_off.offset;
|
||||
@ -2764,13 +2707,13 @@ fn parseTextBlocks(self: *MachO) !void {
|
||||
} else break;
|
||||
}
|
||||
|
||||
if (self.blocks.getPtr(match)) |last| {
|
||||
if (self.atoms.getPtr(match)) |last| {
|
||||
const first_atom = first_atoms.get(match).?;
|
||||
last.*.next = first_atom;
|
||||
first_atom.prev = last.*;
|
||||
last.* = first_atom;
|
||||
}
|
||||
_ = try self.blocks.put(self.base.allocator, match, parsed_atoms.get(match).?);
|
||||
_ = try self.atoms.put(self.base.allocator, match, parsed_atoms.get(match).?);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2905,18 +2848,18 @@ pub fn deinit(self: *MachO) void {
|
||||
}
|
||||
self.load_commands.deinit(self.base.allocator);
|
||||
|
||||
for (self.managed_blocks.items) |block| {
|
||||
block.deinit(self.base.allocator);
|
||||
self.base.allocator.destroy(block);
|
||||
for (self.managed_atoms.items) |atom| {
|
||||
atom.deinit(self.base.allocator);
|
||||
self.base.allocator.destroy(atom);
|
||||
}
|
||||
self.managed_blocks.deinit(self.base.allocator);
|
||||
self.blocks.deinit(self.base.allocator);
|
||||
self.managed_atoms.deinit(self.base.allocator);
|
||||
self.atoms.deinit(self.base.allocator);
|
||||
{
|
||||
var it = self.block_free_lists.valueIterator();
|
||||
var it = self.atom_free_lists.valueIterator();
|
||||
while (it.next()) |free_list| {
|
||||
free_list.deinit(self.base.allocator);
|
||||
}
|
||||
self.block_free_lists.deinit(self.base.allocator);
|
||||
self.atom_free_lists.deinit(self.base.allocator);
|
||||
}
|
||||
for (self.decls.keys()) |decl| {
|
||||
decl.link.macho.deinit(self.base.allocator);
|
||||
@ -2936,25 +2879,21 @@ pub fn closeFiles(self: MachO) void {
|
||||
}
|
||||
}
|
||||
|
||||
fn freeTextBlock(self: *MachO, text_block: *TextBlock) void {
|
||||
log.debug("freeTextBlock {*}", .{text_block});
|
||||
text_block.deinit(self.base.allocator);
|
||||
fn freeAtom(self: *MachO, atom: *Atom, match: MatchingSection) void {
|
||||
log.debug("freeAtom {*}", .{atom});
|
||||
atom.deinit(self.base.allocator);
|
||||
|
||||
const match = MatchingSection{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.text_section_index.?,
|
||||
};
|
||||
const text_block_free_list = self.block_free_lists.getPtr(match).?;
|
||||
const free_list = self.atom_free_lists.getPtr(match).?;
|
||||
var already_have_free_list_node = false;
|
||||
{
|
||||
var i: usize = 0;
|
||||
// TODO turn text_block_free_list into a hash map
|
||||
while (i < text_block_free_list.items.len) {
|
||||
if (text_block_free_list.items[i] == text_block) {
|
||||
_ = text_block_free_list.swapRemove(i);
|
||||
// TODO turn free_list into a hash map
|
||||
while (i < free_list.items.len) {
|
||||
if (free_list.items[i] == atom) {
|
||||
_ = free_list.swapRemove(i);
|
||||
continue;
|
||||
}
|
||||
if (text_block_free_list.items[i] == text_block.prev) {
|
||||
if (free_list.items[i] == atom.prev) {
|
||||
already_have_free_list_node = true;
|
||||
}
|
||||
i += 1;
|
||||
@ -2962,72 +2901,73 @@ fn freeTextBlock(self: *MachO, text_block: *TextBlock) void {
|
||||
}
|
||||
// TODO process free list for dbg info just like we do above for vaddrs
|
||||
|
||||
if (self.blocks.getPtr(match)) |last_text_block| {
|
||||
if (last_text_block.* == text_block) {
|
||||
if (text_block.prev) |prev| {
|
||||
// TODO shrink the __text section size here
|
||||
last_text_block.* = prev;
|
||||
if (self.atoms.getPtr(match)) |last_atom| {
|
||||
if (last_atom.* == atom) {
|
||||
if (atom.prev) |prev| {
|
||||
// TODO shrink the section size here
|
||||
last_atom.* = prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (self.d_sym) |*ds| {
|
||||
if (ds.dbg_info_decl_first == text_block) {
|
||||
ds.dbg_info_decl_first = text_block.dbg_info_next;
|
||||
if (ds.dbg_info_decl_first == atom) {
|
||||
ds.dbg_info_decl_first = atom.dbg_info_next;
|
||||
}
|
||||
if (ds.dbg_info_decl_last == text_block) {
|
||||
if (ds.dbg_info_decl_last == atom) {
|
||||
// TODO shrink the .debug_info section size here
|
||||
ds.dbg_info_decl_last = text_block.dbg_info_prev;
|
||||
ds.dbg_info_decl_last = atom.dbg_info_prev;
|
||||
}
|
||||
}
|
||||
|
||||
if (text_block.prev) |prev| {
|
||||
prev.next = text_block.next;
|
||||
if (atom.prev) |prev| {
|
||||
prev.next = atom.next;
|
||||
|
||||
if (!already_have_free_list_node and prev.freeListEligible(self.*)) {
|
||||
// The free list is heuristics, it doesn't have to be perfect, so we can ignore
|
||||
// the OOM here.
|
||||
text_block_free_list.append(self.base.allocator, prev) catch {};
|
||||
free_list.append(self.base.allocator, prev) catch {};
|
||||
}
|
||||
} else {
|
||||
text_block.prev = null;
|
||||
atom.prev = null;
|
||||
}
|
||||
|
||||
if (text_block.next) |next| {
|
||||
next.prev = text_block.prev;
|
||||
if (atom.next) |next| {
|
||||
next.prev = atom.prev;
|
||||
} else {
|
||||
text_block.next = null;
|
||||
atom.next = null;
|
||||
}
|
||||
|
||||
if (text_block.dbg_info_prev) |prev| {
|
||||
prev.dbg_info_next = text_block.dbg_info_next;
|
||||
if (atom.dbg_info_prev) |prev| {
|
||||
prev.dbg_info_next = atom.dbg_info_next;
|
||||
|
||||
// TODO the free list logic like we do for text blocks above
|
||||
// TODO the free list logic like we do for atoms above
|
||||
} else {
|
||||
text_block.dbg_info_prev = null;
|
||||
atom.dbg_info_prev = null;
|
||||
}
|
||||
|
||||
if (text_block.dbg_info_next) |next| {
|
||||
next.dbg_info_prev = text_block.dbg_info_prev;
|
||||
if (atom.dbg_info_next) |next| {
|
||||
next.dbg_info_prev = atom.dbg_info_prev;
|
||||
} else {
|
||||
text_block.dbg_info_next = null;
|
||||
atom.dbg_info_next = null;
|
||||
}
|
||||
}
|
||||
|
||||
fn shrinkTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64) void {
|
||||
fn shrinkAtom(self: *MachO, atom: *Atom, new_block_size: u64, match: MatchingSection) void {
|
||||
_ = self;
|
||||
_ = text_block;
|
||||
_ = atom;
|
||||
_ = new_block_size;
|
||||
_ = match;
|
||||
// TODO check the new capacity, and if it crosses the size threshold into a big enough
|
||||
// capacity, insert a free list node for it.
|
||||
}
|
||||
|
||||
fn growTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
|
||||
const sym = self.locals.items[text_block.local_sym_index];
|
||||
fn growAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64, match: MatchingSection) !u64 {
|
||||
const sym = self.locals.items[atom.local_sym_index];
|
||||
const align_ok = mem.alignBackwardGeneric(u64, sym.n_value, alignment) == sym.n_value;
|
||||
const need_realloc = !align_ok or new_block_size > text_block.capacity(self.*);
|
||||
const need_realloc = !align_ok or new_atom_size > atom.capacity(self.*);
|
||||
if (!need_realloc) return sym.n_value;
|
||||
return self.allocateTextBlock(text_block, new_block_size, alignment);
|
||||
return self.allocateAtom(atom, new_atom_size, alignment, match);
|
||||
}
|
||||
|
||||
pub fn allocateDeclIndexes(self: *MachO, decl: *Module.Decl) !void {
|
||||
@ -3112,7 +3052,7 @@ pub fn updateFunc(self: *MachO, module: *Module, func: *Module.Fn, air: Air, liv
|
||||
// in a different, smarter, more automatic way somewhere else, in a more centralised
|
||||
// way than this.
|
||||
// If we don't clear the buffers here, we are up for some nasty surprises when
|
||||
// this TextBlock is reused later on and was not freed by freeTextBlock().
|
||||
// this atom is reused later on and was not freed by freeAtom().
|
||||
decl.link.macho.code.clearAndFree(self.base.allocator);
|
||||
try decl.link.macho.code.appendSlice(self.base.allocator, code_buffer.items);
|
||||
},
|
||||
@ -3202,7 +3142,7 @@ pub fn updateDecl(self: *MachO, module: *Module, decl: *Module.Decl) !void {
|
||||
// in a different, smarter, more automatic way somewhere else, in a more centralised
|
||||
// way than this.
|
||||
// If we don't clear the buffers here, we are up for some nasty surprises when
|
||||
// this TextBlock is reused later on and was not freed by freeTextBlock().
|
||||
// this atom is reused later on and was not freed by freeAtom().
|
||||
decl.link.macho.code.clearAndFree(self.base.allocator);
|
||||
try decl.link.macho.code.appendSlice(self.base.allocator, code_buffer.items);
|
||||
break :blk decl.link.macho.code.items;
|
||||
@ -3231,7 +3171,10 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
|
||||
const capacity = decl.link.macho.capacity(self.*);
|
||||
const need_realloc = code_len > capacity or !mem.isAlignedGeneric(u64, symbol.n_value, required_alignment);
|
||||
if (need_realloc) {
|
||||
const vaddr = try self.growTextBlock(&decl.link.macho, code_len, required_alignment);
|
||||
const vaddr = try self.growAtom(&decl.link.macho, code_len, required_alignment, .{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.text_section_index.?,
|
||||
});
|
||||
|
||||
log.debug("growing {s} and moving from 0x{x} to 0x{x}", .{ decl.name, symbol.n_value, vaddr });
|
||||
|
||||
@ -3241,15 +3184,24 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
|
||||
.where = .local,
|
||||
.where_index = decl.link.macho.local_sym_index,
|
||||
}) orelse unreachable;
|
||||
_ = try self.allocateAtom(got_atom, .{
|
||||
const got_sym = &self.locals.items[got_atom.local_sym_index];
|
||||
const got_vaddr = try self.allocateAtom(got_atom, @sizeOf(u64), 8, .{
|
||||
.seg = self.data_const_segment_cmd_index.?,
|
||||
.sect = self.got_section_index.?,
|
||||
});
|
||||
got_sym.n_value = got_vaddr;
|
||||
got_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(.{
|
||||
.seg = self.data_const_segment_cmd_index.?,
|
||||
.sect = self.got_section_index.?,
|
||||
}).? + 1);
|
||||
}
|
||||
|
||||
symbol.n_value = vaddr;
|
||||
} else if (code_len < decl.link.macho.size) {
|
||||
self.shrinkTextBlock(&decl.link.macho, code_len);
|
||||
self.shrinkAtom(&decl.link.macho, code_len, .{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.text_section_index.?,
|
||||
});
|
||||
}
|
||||
decl.link.macho.size = code_len;
|
||||
|
||||
@ -3265,11 +3217,17 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
|
||||
defer self.base.allocator.free(decl_name);
|
||||
|
||||
const name_str_index = try self.makeString(decl_name);
|
||||
const addr = try self.allocateTextBlock(&decl.link.macho, code_len, required_alignment);
|
||||
const addr = try self.allocateAtom(&decl.link.macho, code_len, required_alignment, .{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.text_section_index.?,
|
||||
});
|
||||
|
||||
log.debug("allocated text block for {s} at 0x{x}", .{ decl_name, addr });
|
||||
log.debug("allocated atom for {s} at 0x{x}", .{ decl_name, addr });
|
||||
|
||||
errdefer self.freeTextBlock(&decl.link.macho);
|
||||
errdefer self.freeAtom(&decl.link.macho, .{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.text_section_index.?,
|
||||
});
|
||||
|
||||
symbol.* = .{
|
||||
.n_strx = name_str_index,
|
||||
@ -3282,10 +3240,16 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
|
||||
.where = .local,
|
||||
.where_index = decl.link.macho.local_sym_index,
|
||||
}) orelse unreachable;
|
||||
_ = try self.allocateAtom(got_atom, .{
|
||||
const got_sym = &self.locals.items[got_atom.local_sym_index];
|
||||
const vaddr = try self.allocateAtom(got_atom, @sizeOf(u64), 8, .{
|
||||
.seg = self.data_const_segment_cmd_index.?,
|
||||
.sect = self.got_section_index.?,
|
||||
});
|
||||
got_sym.n_value = vaddr;
|
||||
got_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(.{
|
||||
.seg = self.data_const_segment_cmd_index.?,
|
||||
.sect = self.got_section_index.?,
|
||||
}).? + 1);
|
||||
}
|
||||
|
||||
return symbol;
|
||||
@ -3402,7 +3366,10 @@ pub fn freeDecl(self: *MachO, decl: *Module.Decl) void {
|
||||
log.debug("freeDecl {*}", .{decl});
|
||||
_ = self.decls.swapRemove(decl);
|
||||
// Appending to free lists is allowed to fail because the free lists are heuristics based anyway.
|
||||
self.freeTextBlock(&decl.link.macho);
|
||||
self.freeAtom(&decl.link.macho, .{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.text_section_index.?,
|
||||
});
|
||||
if (decl.link.macho.local_sym_index != 0) {
|
||||
self.locals_free_list.append(self.base.allocator, decl.link.macho.local_sym_index) catch {};
|
||||
|
||||
@ -3412,7 +3379,7 @@ pub fn freeDecl(self: *MachO, decl: *Module.Decl) void {
|
||||
decl.link.macho.local_sym_index = 0;
|
||||
}
|
||||
if (self.d_sym) |*ds| {
|
||||
// TODO make this logic match freeTextBlock. Maybe abstract the logic
|
||||
// TODO make this logic match freeAtom. Maybe abstract the logic
|
||||
// out since the same thing is desired for both.
|
||||
_ = ds.dbg_line_fn_free_list.remove(&decl.fn_link.macho);
|
||||
if (decl.fn_link.macho.prev) |prev| {
|
||||
@ -3947,7 +3914,7 @@ fn allocateSection(
|
||||
.sect = index,
|
||||
};
|
||||
_ = try self.section_ordinals.getOrPut(self.base.allocator, match);
|
||||
try self.block_free_lists.putNoClobber(self.base.allocator, match, .{});
|
||||
try self.atom_free_lists.putNoClobber(self.base.allocator, match, .{});
|
||||
|
||||
self.load_commands_dirty = true;
|
||||
self.sections_order_dirty = true;
|
||||
@ -4113,106 +4080,105 @@ fn getSectionMaxAlignment(self: *MachO, segment_id: u16, start_sect_id: u16) !u3
|
||||
return max_alignment;
|
||||
}
|
||||
|
||||
fn allocateTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
|
||||
const text_segment = &self.load_commands.items[self.text_segment_cmd_index.?].Segment;
|
||||
const text_section = &text_segment.sections.items[self.text_section_index.?];
|
||||
const match = MatchingSection{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.text_section_index.?,
|
||||
};
|
||||
var text_block_free_list = self.block_free_lists.get(match).?;
|
||||
const new_block_ideal_capacity = padToIdeal(new_block_size);
|
||||
fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64, match: MatchingSection) !u64 {
|
||||
const seg = &self.load_commands.items[match.seg].Segment;
|
||||
const sect = &seg.sections.items[match.sect];
|
||||
var free_list = self.atom_free_lists.get(match).?;
|
||||
const needs_padding = match.seg == self.text_segment_cmd_index.? and match.sect == self.text_section_index.?;
|
||||
const new_atom_ideal_capacity = if (needs_padding) padToIdeal(new_atom_size) else new_atom_size;
|
||||
|
||||
// We use these to indicate our intention to update metadata, placing the new block,
|
||||
// We use these to indicate our intention to update metadata, placing the new atom,
|
||||
// and possibly removing a free list node.
|
||||
// It would be simpler to do it inside the for loop below, but that would cause a
|
||||
// problem if an error was returned later in the function. So this action
|
||||
// is actually carried out at the end of the function, when errors are no longer possible.
|
||||
var block_placement: ?*TextBlock = null;
|
||||
var atom_placement: ?*Atom = null;
|
||||
var free_list_removal: ?usize = null;
|
||||
|
||||
// First we look for an appropriately sized free list node.
|
||||
// The list is unordered. We'll just take the first thing that works.
|
||||
var vaddr = blk: {
|
||||
var i: usize = 0;
|
||||
while (i < text_block_free_list.items.len) {
|
||||
const big_block = text_block_free_list.items[i];
|
||||
// We now have a pointer to a live text block that has too much capacity.
|
||||
// Is it enough that we could fit this new text block?
|
||||
const sym = self.locals.items[big_block.local_sym_index];
|
||||
const capacity = big_block.capacity(self.*);
|
||||
const ideal_capacity = padToIdeal(capacity);
|
||||
while (i < free_list.items.len) {
|
||||
const big_atom = free_list.items[i];
|
||||
// We now have a pointer to a live atom that has too much capacity.
|
||||
// Is it enough that we could fit this new atom?
|
||||
const sym = self.locals.items[big_atom.local_sym_index];
|
||||
const capacity = big_atom.capacity(self.*);
|
||||
const ideal_capacity = if (needs_padding) padToIdeal(capacity) else capacity;
|
||||
const ideal_capacity_end_vaddr = sym.n_value + ideal_capacity;
|
||||
const capacity_end_vaddr = sym.n_value + capacity;
|
||||
const new_start_vaddr_unaligned = capacity_end_vaddr - new_block_ideal_capacity;
|
||||
const new_start_vaddr_unaligned = capacity_end_vaddr - new_atom_ideal_capacity;
|
||||
const new_start_vaddr = mem.alignBackwardGeneric(u64, new_start_vaddr_unaligned, alignment);
|
||||
if (new_start_vaddr < ideal_capacity_end_vaddr) {
|
||||
// Additional bookkeeping here to notice if this free list node
|
||||
// should be deleted because the block that it points to has grown to take up
|
||||
// should be deleted because the atom that it points to has grown to take up
|
||||
// more of the extra capacity.
|
||||
if (!big_block.freeListEligible(self.*)) {
|
||||
const bl = text_block_free_list.swapRemove(i);
|
||||
if (!big_atom.freeListEligible(self.*)) {
|
||||
const bl = free_list.swapRemove(i);
|
||||
bl.deinit(self.base.allocator);
|
||||
} else {
|
||||
i += 1;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// At this point we know that we will place the new block here. But the
|
||||
// At this point we know that we will place the new atom here. But the
|
||||
// remaining question is whether there is still yet enough capacity left
|
||||
// over for there to still be a free list node.
|
||||
const remaining_capacity = new_start_vaddr - ideal_capacity_end_vaddr;
|
||||
const keep_free_list_node = remaining_capacity >= min_text_capacity;
|
||||
|
||||
// Set up the metadata to be updated, after errors are no longer possible.
|
||||
block_placement = big_block;
|
||||
atom_placement = big_atom;
|
||||
if (!keep_free_list_node) {
|
||||
free_list_removal = i;
|
||||
}
|
||||
break :blk new_start_vaddr;
|
||||
} else if (self.blocks.get(match)) |last| {
|
||||
} else if (self.atoms.get(match)) |last| {
|
||||
const last_symbol = self.locals.items[last.local_sym_index];
|
||||
// TODO We should pad out the excess capacity with NOPs. For executables,
|
||||
// no padding seems to be OK, but it will probably not be for objects.
|
||||
const ideal_capacity = padToIdeal(last.size);
|
||||
const ideal_capacity = if (needs_padding) padToIdeal(last.size) else last.size;
|
||||
const ideal_capacity_end_vaddr = last_symbol.n_value + ideal_capacity;
|
||||
const new_start_vaddr = mem.alignForwardGeneric(u64, ideal_capacity_end_vaddr, alignment);
|
||||
block_placement = last;
|
||||
atom_placement = last;
|
||||
break :blk new_start_vaddr;
|
||||
} else {
|
||||
break :blk text_section.addr;
|
||||
break :blk mem.alignForwardGeneric(u64, sect.addr, alignment);
|
||||
}
|
||||
};
|
||||
|
||||
const expand_text_section = block_placement == null or block_placement.?.next == null;
|
||||
if (expand_text_section) {
|
||||
const needed_size = @intCast(u32, (vaddr + new_block_size) - text_section.addr);
|
||||
const expand_section = atom_placement == null or atom_placement.?.next == null;
|
||||
if (expand_section) {
|
||||
const needed_size = @intCast(u32, (vaddr + new_atom_size) - sect.addr);
|
||||
try self.growSection(match, needed_size);
|
||||
_ = try self.blocks.put(self.base.allocator, match, text_block);
|
||||
text_section.size = needed_size;
|
||||
_ = try self.atoms.put(self.base.allocator, match, atom);
|
||||
sect.size = needed_size;
|
||||
self.load_commands_dirty = true;
|
||||
}
|
||||
const align_pow = @intCast(u32, math.log2(alignment));
|
||||
text_section.@"align" = math.max(text_section.@"align", align_pow);
|
||||
text_block.size = new_block_size;
|
||||
|
||||
if (text_block.prev) |prev| {
|
||||
prev.next = text_block.next;
|
||||
if (sect.@"align" < align_pow) {
|
||||
sect.@"align" = align_pow;
|
||||
self.load_commands_dirty = true;
|
||||
}
|
||||
if (text_block.next) |next| {
|
||||
next.prev = text_block.prev;
|
||||
atom.size = new_atom_size;
|
||||
atom.alignment = align_pow;
|
||||
|
||||
if (atom.prev) |prev| {
|
||||
prev.next = atom.next;
|
||||
}
|
||||
if (atom.next) |next| {
|
||||
next.prev = atom.prev;
|
||||
}
|
||||
|
||||
if (block_placement) |big_block| {
|
||||
text_block.prev = big_block;
|
||||
text_block.next = big_block.next;
|
||||
big_block.next = text_block;
|
||||
if (atom_placement) |big_atom| {
|
||||
atom.prev = big_atom;
|
||||
atom.next = big_atom.next;
|
||||
big_atom.next = atom;
|
||||
} else {
|
||||
text_block.prev = null;
|
||||
text_block.next = null;
|
||||
atom.prev = null;
|
||||
atom.next = null;
|
||||
}
|
||||
if (free_list_removal) |i| {
|
||||
_ = text_block_free_list.swapRemove(i);
|
||||
_ = free_list.swapRemove(i);
|
||||
}
|
||||
|
||||
return vaddr;
|
||||
@ -4319,10 +4285,10 @@ fn writeDyldInfoData(self: *MachO) !void {
|
||||
defer lazy_bind_pointers.deinit();
|
||||
|
||||
{
|
||||
var it = self.blocks.iterator();
|
||||
var it = self.atoms.iterator();
|
||||
while (it.next()) |entry| {
|
||||
const match = entry.key_ptr.*;
|
||||
var atom: *TextBlock = entry.value_ptr.*;
|
||||
var atom: *Atom = entry.value_ptr.*;
|
||||
|
||||
if (match.seg == self.text_segment_cmd_index.?) continue; // __TEXT is non-writable
|
||||
|
||||
@ -4444,7 +4410,7 @@ fn writeDyldInfoData(self: *MachO) !void {
|
||||
}
|
||||
|
||||
fn populateLazyBindOffsetsInStubHelper(self: *MachO, buffer: []const u8) !void {
|
||||
const last_atom = self.blocks.get(.{
|
||||
const last_atom = self.atoms.get(.{
|
||||
.seg = self.text_segment_cmd_index.?,
|
||||
.sect = self.stub_helper_section_index.?,
|
||||
}) orelse return;
|
||||
@ -4538,25 +4504,25 @@ fn writeDices(self: *MachO) !void {
|
||||
var buf = std.ArrayList(u8).init(self.base.allocator);
|
||||
defer buf.deinit();
|
||||
|
||||
var block: *TextBlock = self.blocks.get(.{
|
||||
var atom: *Atom = self.atoms.get(.{
|
||||
.seg = self.text_segment_cmd_index orelse return,
|
||||
.sect = self.text_section_index orelse return,
|
||||
}) orelse return;
|
||||
|
||||
while (block.prev) |prev| {
|
||||
block = prev;
|
||||
while (atom.prev) |prev| {
|
||||
atom = prev;
|
||||
}
|
||||
|
||||
const text_seg = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
|
||||
const text_sect = text_seg.sections.items[self.text_section_index.?];
|
||||
|
||||
while (true) {
|
||||
if (block.dices.items.len > 0) {
|
||||
const sym = self.locals.items[block.local_sym_index];
|
||||
if (atom.dices.items.len > 0) {
|
||||
const sym = self.locals.items[atom.local_sym_index];
|
||||
const base_off = try math.cast(u32, sym.n_value - text_sect.addr + text_sect.offset);
|
||||
|
||||
try buf.ensureUnusedCapacity(block.dices.items.len * @sizeOf(macho.data_in_code_entry));
|
||||
for (block.dices.items) |dice| {
|
||||
try buf.ensureUnusedCapacity(atom.dices.items.len * @sizeOf(macho.data_in_code_entry));
|
||||
for (atom.dices.items) |dice| {
|
||||
const rebased_dice = macho.data_in_code_entry{
|
||||
.offset = base_off + dice.offset,
|
||||
.length = dice.length,
|
||||
@ -4566,8 +4532,8 @@ fn writeDices(self: *MachO) !void {
|
||||
}
|
||||
}
|
||||
|
||||
if (block.next) |next| {
|
||||
block = next;
|
||||
if (atom.next) |next| {
|
||||
atom = next;
|
||||
} else break;
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user