srctree

Jacob Young parent 955fd65c 0b7af256
MachO: fix `calcLoadCommandsSize` computation

Closes #19026

inline split

src/link/MachO.zig added: 40, removed: 51, total 0

@@ -2250,7 +2250,7 @@ fn initSegments(self: *MachO) !void {

}

fn allocateSections(self: *MachO) !void {

const headerpad = load_commands.calcMinHeaderPadSize(self);

const headerpad = try load_commands.calcMinHeaderPadSize(self);

var vmaddr: u64 = if (self.pagezero_seg_index) |index|

self.segments.items[index].vmaddr + self.segments.items[index].vmsize

else

@@ -2904,13 +2904,12 @@ pub fn writeStrtab(self: *MachO, off: u32) !u32 {

fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {

const gpa = self.base.comp.gpa;

const needed_size = load_commands.calcLoadCommandsSize(self, false);

const needed_size = try load_commands.calcLoadCommandsSize(self, false);

const buffer = try gpa.alloc(u8, needed_size);

defer gpa.free(buffer);

var stream = std.io.fixedBufferStream(buffer);

var cwriter = std.io.countingWriter(stream.writer());

const writer = cwriter.writer();

const writer = stream.writer();

var ncmds: usize = 0;

@@ -2974,7 +2973,7 @@ fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {

ncmds += 1;

}

const uuid_cmd_offset = @sizeOf(macho.mach_header_64) + cwriter.bytes_written;

const uuid_cmd_offset = @sizeOf(macho.mach_header_64) + stream.pos;

try writer.writeStruct(self.uuid_cmd);

ncmds += 1;

@@ -3002,7 +3001,7 @@ fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {

ncmds += 1;

}

assert(cwriter.bytes_written == needed_size);

assert(stream.pos == needed_size);

try self.base.file.?.pwriteAll(buffer, @sizeOf(macho.mach_header_64));

src/link/MachO/DebugSymbols.zig added: 40, removed: 51, total 0

@@ -269,8 +269,7 @@ fn writeLoadCommands(self: *DebugSymbols, macho_file: *MachO) !struct { usize, u

defer gpa.free(buffer);

var stream = std.io.fixedBufferStream(buffer);

var cwriter = std.io.countingWriter(stream.writer());

const writer = cwriter.writer();

const writer = stream.writer();

var ncmds: usize = 0;

@@ -314,7 +313,7 @@ fn writeLoadCommands(self: *DebugSymbols, macho_file: *MachO) !struct { usize, u

try writer.writeStruct(self.symtab_cmd);

ncmds += 1;

assert(cwriter.bytes_written == needed_size);

assert(stream.pos == needed_size);

try self.file.pwriteAll(buffer, @sizeOf(macho.mach_header_64));

src/link/MachO/UnwindInfo.zig added: 40, removed: 51, total 0

@@ -271,8 +271,7 @@ pub fn write(info: UnwindInfo, macho_file: *MachO, buffer: []u8) !void {

const header = macho_file.sections.items(.header)[macho_file.unwind_info_sect_index.?];

var stream = std.io.fixedBufferStream(buffer);

var cwriter = std.io.countingWriter(stream.writer());

const writer = cwriter.writer();

const writer = stream.writer();

const common_encodings_offset: u32 = @sizeOf(macho.unwind_info_section_header);

const common_encodings_count: u32 = info.common_encodings_count;

@@ -329,20 +328,16 @@ pub fn write(info: UnwindInfo, macho_file: *MachO, buffer: []u8) !void {

}

for (info.pages.items) |page| {

const start = cwriter.bytes_written;

const start = stream.pos;

try page.write(info, macho_file, writer);

const nwritten = cwriter.bytes_written - start;

const nwritten = stream.pos - start;

if (nwritten < second_level_page_bytes) {

const padding = math.cast(usize, second_level_page_bytes - nwritten) orelse return error.Overflow;

try writer.writeByteNTimes(0, padding);

}

const padding = buffer.len - cwriter.bytes_written;

if (padding > 0) {

const off = math.cast(usize, cwriter.bytes_written) orelse return error.Overflow;

@memset(buffer[off..], 0);

}

@memset(buffer[stream.pos..], 0);

}

fn getOrPutPersonalityFunction(info: *UnwindInfo, sym_index: Symbol.Index) error{TooManyPersonalities}!u2 {

src/link/MachO/dyld_info/bind.zig added: 40, removed: 51, total 0

@@ -40,7 +40,7 @@ pub const Bind = struct {

}

pub fn size(self: Self) u64 {

return @as(u64, @intCast(self.buffer.items.len));

return @intCast(self.buffer.items.len);

}

pub fn finalize(self: *Self, gpa: Allocator, ctx: *MachO) !void {

@@ -124,7 +124,7 @@ pub const Bind = struct {

switch (state) {

.start => {

if (current.offset < offset) {

try addAddr(@as(u64, @bitCast(@as(i64, @intCast(current.offset)) - @as(i64, @intCast(offset)))), writer);

try addAddr(@bitCast(@as(i64, @intCast(current.offset)) - @as(i64, @intCast(offset))), writer);

offset = offset - (offset - current.offset);

} else if (current.offset > offset) {

const delta = current.offset - offset;

@@ -195,7 +195,7 @@ pub const WeakBind = struct {

}

pub fn size(self: Self) u64 {

return @as(u64, @intCast(self.buffer.items.len));

return @intCast(self.buffer.items.len);

}

pub fn finalize(self: *Self, gpa: Allocator, ctx: *MachO) !void {

@@ -286,7 +286,7 @@ pub const WeakBind = struct {

} else if (current.offset > offset) {

const delta = current.offset - offset;

state = .bind_times_skip;

skip = @as(u64, @intCast(delta));

skip = @intCast(delta);

offset += skip;

} else unreachable;

i -= 1;

@@ -341,23 +341,20 @@ pub const LazyBind = struct {

}

pub fn size(self: Self) u64 {

return @as(u64, @intCast(self.buffer.items.len));

return @intCast(self.buffer.items.len);

}

pub fn finalize(self: *Self, gpa: Allocator, ctx: *MachO) !void {

if (self.entries.items.len == 0) return;

try self.offsets.ensureTotalCapacityPrecise(gpa, self.entries.items.len);

var cwriter = std.io.countingWriter(self.buffer.writer(gpa));

const writer = cwriter.writer();

const writer = self.buffer.writer(gpa);

log.debug("lazy bind opcodes", .{});

var addend: i64 = 0;

for (self.entries.items) |entry| {

self.offsets.appendAssumeCapacity(@as(u32, @intCast(cwriter.bytes_written)));

self.offsets.appendAssumeCapacity(@intCast(self.buffer.items.len));

const sym = ctx.getSymbol(entry.target);

const name = sym.getName(ctx);

@@ -388,7 +385,6 @@ pub const LazyBind = struct {

}

pub fn write(self: Self, writer: anytype) !void {

if (self.size() == 0) return;

try writer.writeAll(self.buffer.items);

}

};

src/link/MachO/load_commands.zig added: 40, removed: 51, total 0

@@ -17,7 +17,7 @@ fn calcInstallNameLen(cmd_size: u64, name: []const u8, assume_max_path_len: bool

return mem.alignForward(u64, cmd_size + name_len, @alignOf(u64));

}

pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) u32 {

pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) !u32 {

var sizeofcmds: u64 = 0;

// LC_SEGMENT_64

@@ -48,15 +48,16 @@ pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) u32 {

}

// LC_ID_DYLIB

if (macho_file.base.isDynLib()) {

sizeofcmds += blk: {

const emit = macho_file.base.emit;

const install_name = macho_file.install_name orelse emit.sub_path;

break :blk calcInstallNameLen(

@sizeOf(macho.dylib_command),

install_name,

assume_max_path_len,

);

};

const gpa = macho_file.base.comp.gpa;

const emit = macho_file.base.emit;

const install_name = macho_file.install_name orelse

try emit.directory.join(gpa, &.{emit.sub_path});

defer if (macho_file.install_name == null) gpa.free(install_name);

sizeofcmds += calcInstallNameLen(

@sizeOf(macho.dylib_command),

install_name,

assume_max_path_len,

);

}

// LC_RPATH

{

@@ -148,12 +149,12 @@ pub fn calcLoadCommandsSizeObject(macho_file: *MachO) u32 {

return @as(u32, @intCast(sizeofcmds));

}

pub fn calcMinHeaderPadSize(macho_file: *MachO) u32 {

var padding: u32 = calcLoadCommandsSize(macho_file, false) + (macho_file.headerpad_size orelse 0);

pub fn calcMinHeaderPadSize(macho_file: *MachO) !u32 {

var padding: u32 = (try calcLoadCommandsSize(macho_file, false)) + (macho_file.headerpad_size orelse 0);

log.debug("minimum requested headerpad size 0x{x}", .{padding + @sizeOf(macho.mach_header_64)});

if (macho_file.headerpad_max_install_names) {

const min_headerpad_size: u32 = calcLoadCommandsSize(macho_file, true);

const min_headerpad_size: u32 = try calcLoadCommandsSize(macho_file, true);

log.debug("headerpad_max_install_names minimum headerpad size 0x{x}", .{

min_headerpad_size + @sizeOf(macho.mach_header_64),

});

src/link/MachO/relocatable.zig added: 40, removed: 51, total 0

@@ -748,8 +748,7 @@ fn writeLoadCommands(macho_file: *MachO) !struct { usize, usize } {

defer gpa.free(buffer);

var stream = std.io.fixedBufferStream(buffer);

var cwriter = std.io.countingWriter(stream.writer());

const writer = cwriter.writer();

const writer = stream.writer();

var ncmds: usize = 0;

@@ -779,7 +778,7 @@ fn writeLoadCommands(macho_file: *MachO) !struct { usize, usize } {

ncmds += 1;

}

assert(cwriter.bytes_written == needed_size);

assert(stream.pos == needed_size);

try macho_file.base.file.?.pwriteAll(buffer, @sizeOf(macho.mach_header_64));