srctree

if (self.base.isStaticLib()) return relocatable.flushStaticLib(self, comp, module_obj_path);

if (self.base.isObject()) return relocatable.flushObject(self, comp, module_obj_path);

self.markImportsAndExports();

if (build_options.enable_logging) {

state_log.debug("{}", .{self.dumpState()});

}

pub const ParseError = error{

pub fn parseFatLibrary(self: *MachO, path: []const u8) !fat.Arch {

if (self.getZigObject()) |zo| {

try zo.asFile().claimUnresolved(self);

}

for (self.objects.items) |index| {

try self.getFile(index).?.claimUnresolved(self);

fn markImportsAndExports(self: *MachO) void {

if (self.getZigObject()) |zo| {

zo.asFile().markImportsExports(self);

}

for (self.objects.items) |index| {

self.getFile(index).?.markImportsExports(self);

pub fn isArchive(path: []const u8, fat_arch: ?fat.Arch) !bool {

const file = try std.fs.cwd().openFile(path, .{});

defer file.close();

if (fat_arch) |arch| {

try file.seekTo(arch.offset);

}

const magic = file.reader().readBytesNoEof(SARMAG) catch return false;

if (!mem.eql(u8, &magic, ARMAG)) return false;

return true;

}

 

pub fn deinit(self: *Archive, allocator: Allocator) void {

self.objects.deinit(allocator);

}

 

pub fn parse(self: *Archive, macho_file: *MachO, path: []const u8, handle_index: File.HandleIndex, fat_arch: ?fat.Arch) !void {

const gpa = macho_file.base.comp.gpa;

 

var arena = std.heap.ArenaAllocator.init(gpa);

defer arena.deinit();

 

const handle = macho_file.getFileHandle(handle_index);

const offset = if (fat_arch) |ar| ar.offset else 0;

const size = if (fat_arch) |ar| ar.size else (try handle.stat()).size;

try handle.seekTo(offset);

 

const reader = handle.reader();

_ = try reader.readBytesNoEof(SARMAG);

 

var pos: usize = SARMAG;

while (true) {

if (pos >= size) break;

if (!mem.isAligned(pos, 2)) {

try handle.seekBy(1);

pos += 1;

}

 

const hdr = try reader.readStruct(ar_hdr);

pos += @sizeOf(ar_hdr);

 

if (!mem.eql(u8, &hdr.ar_fmag, ARFMAG)) {

try macho_file.reportParseError(path, "invalid header delimiter: expected '{s}', found '{s}'", .{

std.fmt.fmtSliceEscapeLower(ARFMAG), std.fmt.fmtSliceEscapeLower(&hdr.ar_fmag),

});

return error.MalformedArchive;

}

 

var hdr_size = try hdr.size();

const name = name: {

if (hdr.name()) |n| break :name n;

if (try hdr.nameLength()) |len| {

hdr_size -= len;

const buf = try arena.allocator().alloc(u8, len);

try reader.readNoEof(buf);

pos += len;

const actual_len = mem.indexOfScalar(u8, buf, @as(u8, 0)) orelse len;

break :name buf[0..actual_len];

}

unreachable;

};

defer {

_ = handle.seekBy(hdr_size) catch {};

pos += hdr_size;

}

 

if (mem.eql(u8, name, SYMDEF) or

mem.eql(u8, name, SYMDEF64) or

mem.eql(u8, name, SYMDEF_SORTED) or

mem.eql(u8, name, SYMDEF64_SORTED)) continue;

 

const object = Object{

.archive = .{

.path = try gpa.dupe(u8, path),

.offset = offset + pos,

},

.path = try gpa.dupe(u8, name),

.file_handle = handle_index,

.index = undefined,

.alive = false,

.mtime = hdr.date() catch 0,

};

 

log.debug("extracting object '{s}' from archive '{s}'", .{ object.path, path });

 

try self.objects.append(gpa, object);

}

}

 

pub fn writeHeader(

object_name: []const u8,

object_size: usize,

format: Format,

writer: anytype,

) !void {

var hdr: ar_hdr = .{

.ar_name = undefined,

.ar_date = undefined,

.ar_uid = undefined,

.ar_gid = undefined,

.ar_mode = undefined,

.ar_size = undefined,

.ar_fmag = undefined,

};

@memset(mem.asBytes(&hdr), 0x20);

inline for (@typeInfo(ar_hdr).Struct.fields) |field| {

var stream = std.io.fixedBufferStream(&@field(hdr, field.name));

stream.writer().print("0", .{}) catch unreachable;

}

@memcpy(&hdr.ar_fmag, ARFMAG);

 

const object_name_len = mem.alignForward(usize, object_name.len + 1, ptrWidth(format));

const total_object_size = object_size + object_name_len;

 

{

var stream = std.io.fixedBufferStream(&hdr.ar_name);

stream.writer().print("#1/{d}", .{object_name_len}) catch unreachable;

}

{

var stream = std.io.fixedBufferStream(&hdr.ar_size);

stream.writer().print("{d}", .{total_object_size}) catch unreachable;

}

 

try writer.writeAll(mem.asBytes(&hdr));

try writer.print("{s}\x00", .{object_name});

 

const padding = object_name_len - object_name.len - 1;

if (padding > 0) {

try writer.writeByteNTimes(0, padding);

}

}

 

pub const SYMDEF = "__.SYMDEF";

pub const SYMDEF64 = "__.SYMDEF_64";

pub const SYMDEF_SORTED = "__.SYMDEF SORTED";

pub const SYMDEF64_SORTED = "__.SYMDEF_64 SORTED";

 

pub const ar_hdr = extern struct {

pub const ArSymtab = struct {

entries: std.ArrayListUnmanaged(Entry) = .{},

strtab: StringTable = .{},

 

pub fn deinit(ar: *ArSymtab, allocator: Allocator) void {

ar.entries.deinit(allocator);

ar.strtab.deinit(allocator);

 

pub fn sort(ar: *ArSymtab) void {

mem.sort(Entry, ar.entries.items, {}, Entry.lessThan);

}

 

pub fn size(ar: ArSymtab, format: Format) usize {

const ptr_width = ptrWidth(format);

return ptr_width + ar.entries.items.len * 2 * ptr_width + ptr_width + mem.alignForward(usize, ar.strtab.buffer.items.len, ptr_width);

}

 

pub fn write(ar: ArSymtab, format: Format, macho_file: *MachO, writer: anytype) !void {

const ptr_width = ptrWidth(format);

// Header

try writeHeader(SYMDEF, ar.size(format), format, writer);

// Symtab size

try writeInt(format, ar.entries.items.len * 2 * ptr_width, writer);

// Symtab entries

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

const file_off = switch (macho_file.getFile(entry.file).?) {

.zig_object => |x| x.output_ar_state.file_off,

.object => |x| x.output_ar_state.file_off,

else => unreachable,

};

// Name offset

try writeInt(format, entry.off, writer);

// File offset

try writeInt(format, file_off, writer);

}

// Strtab size

const strtab_size = mem.alignForward(usize, ar.strtab.buffer.items.len, ptr_width);

const padding = strtab_size - ar.strtab.buffer.items.len;

try writeInt(format, strtab_size, writer);

// Strtab

try writer.writeAll(ar.strtab.buffer.items);

if (padding > 0) {

try writer.writeByteNTimes(0, padding);

}

}

 

const FormatContext = struct {

ar: ArSymtab,

macho_file: *MachO,

};

 

pub fn fmt(ar: ArSymtab, macho_file: *MachO) std.fmt.Formatter(format2) {

return .{ .data = .{ .ar = ar, .macho_file = macho_file } };

}

 

fn format2(

ctx: FormatContext,

comptime unused_fmt_string: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

_ = unused_fmt_string;

_ = options;

const ar = ctx.ar;

const macho_file = ctx.macho_file;

for (ar.entries.items, 0..) |entry, i| {

const name = ar.strtab.getAssumeExists(entry.off);

const file = macho_file.getFile(entry.file).?;

try writer.print(" {d}: {s} in file({d})({})\n", .{ i, name, entry.file, file.fmtPath() });

}

}

 

const Entry = struct {

/// Symbol name offset

off: u32,

/// Exporting file

file: File.Index,

 

pub fn lessThan(ctx: void, lhs: Entry, rhs: Entry) bool {

_ = ctx;

if (lhs.off == rhs.off) return lhs.file < rhs.file;

return lhs.off < rhs.off;

}

};

};

 

pub const Format = enum {

p32,

p64,

};

 

pub fn ptrWidth(format: Format) usize {

return switch (format) {

.p32 => @as(usize, 4),

.p64 => 8,

};

pub fn writeInt(format: Format, value: u64, writer: anytype) !void {

switch (format) {

.p32 => try writer.writeInt(u32, std.math.cast(u32, value) orelse return error.Overflow, .little),

.p64 => try writer.writeInt(u64, value, .little),

pub const ArState = struct {

/// File offset of the ar_hdr describing the contributing

/// object in the archive.

file_off: u64 = 0,

 

/// Total size of the contributing object (excludes ar_hdr and long name with padding).

size: u64 = 0,

};

 

const link = @import("../../link.zig");

const StringTable = @import("../StringTable.zig");

archive: ?InArchive = null,

output_ar_state: Archive.ArState = .{},

const InArchive = struct {

pub fn parseAr(self: *Object, macho_file: *MachO) !void {

const tracy = trace(@src());

defer tracy.end();

 

const gpa = macho_file.base.comp.gpa;

const offset = if (self.archive) |ar| ar.offset else 0;

const handle = macho_file.getFileHandle(self.file_handle);

 

var header_buffer: [@sizeOf(macho.mach_header_64)]u8 = undefined;

{

const amt = try handle.preadAll(&header_buffer, offset);

if (amt != @sizeOf(macho.mach_header_64)) return error.InputOutput;

}

self.header = @as(*align(1) const macho.mach_header_64, @ptrCast(&header_buffer)).*;

 

const this_cpu_arch: std.Target.Cpu.Arch = switch (self.header.?.cputype) {

macho.CPU_TYPE_ARM64 => .aarch64,

macho.CPU_TYPE_X86_64 => .x86_64,

else => |x| {

try macho_file.reportParseError2(self.index, "unknown cpu architecture: {d}", .{x});

return error.InvalidCpuArch;

},

};

if (macho_file.getTarget().cpu.arch != this_cpu_arch) {

try macho_file.reportParseError2(self.index, "invalid cpu architecture: {s}", .{@tagName(this_cpu_arch)});

return error.InvalidCpuArch;

}

 

const lc_buffer = try gpa.alloc(u8, self.header.?.sizeofcmds);

defer gpa.free(lc_buffer);

{

const amt = try handle.preadAll(lc_buffer, offset + @sizeOf(macho.mach_header_64));

if (amt != self.header.?.sizeofcmds) return error.InputOutput;

}

 

var it = LoadCommandIterator{

.ncmds = self.header.?.ncmds,

.buffer = lc_buffer,

};

while (it.next()) |lc| switch (lc.cmd()) {

.SYMTAB => {

const cmd = lc.cast(macho.symtab_command).?;

try self.strtab.resize(gpa, cmd.strsize);

{

const amt = try handle.preadAll(self.strtab.items, cmd.stroff + offset);

if (amt != self.strtab.items.len) return error.InputOutput;

}

 

const symtab_buffer = try gpa.alloc(u8, cmd.nsyms * @sizeOf(macho.nlist_64));

defer gpa.free(symtab_buffer);

{

const amt = try handle.preadAll(symtab_buffer, cmd.symoff + offset);

if (amt != symtab_buffer.len) return error.InputOutput;

}

const symtab = @as([*]align(1) const macho.nlist_64, @ptrCast(symtab_buffer.ptr))[0..cmd.nsyms];

try self.symtab.ensureUnusedCapacity(gpa, symtab.len);

for (symtab) |nlist| {

self.symtab.appendAssumeCapacity(.{

.nlist = nlist,

.atom = 0,

.size = 0,

});

}

},

.BUILD_VERSION,

.VERSION_MIN_MACOSX,

.VERSION_MIN_IPHONEOS,

.VERSION_MIN_TVOS,

.VERSION_MIN_WATCHOS,

=> if (self.platform == null) {

self.platform = MachO.Platform.fromLoadCommand(lc);

},

else => {},

};

}

 

pub fn updateArSymtab(self: Object, ar_symtab: *Archive.ArSymtab, macho_file: *MachO) error{OutOfMemory}!void {

const gpa = macho_file.base.comp.gpa;

for (self.symtab.items(.nlist)) |nlist| {

if (!nlist.ext() or (nlist.undf() and !nlist.tentative())) continue;

const off = try ar_symtab.strtab.insert(gpa, self.getString(nlist.n_strx));

try ar_symtab.entries.append(gpa, .{ .off = off, .file = self.index });

}

}

 

pub fn updateArSize(self: *Object, macho_file: *MachO) !void {

const file = macho_file.getFileHandle(self.file_handle);

const size = (try file.stat()).size;

self.output_ar_state.size = size;

}

 

pub fn writeAr(self: Object, ar_format: Archive.Format, macho_file: *MachO, writer: anytype) !void {

// Header

const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;

try Archive.writeHeader(self.path, size, ar_format, writer);

// Data

const file = macho_file.getFileHandle(self.file_handle);

// TODO try using copyRangeAll

const gpa = macho_file.base.comp.gpa;

const data = try gpa.alloc(u8, size);

defer gpa.free(data);

const amt = try file.preadAll(data, 0);

if (amt != size) return error.InputOutput;

try writer.writeAll(data);

}

 

const Archive = @import("Archive.zig");

data: std.ArrayListUnmanaged(u8) = .{},

output_ar_state: Archive.ArState = .{},

self.data.deinit(allocator);

/// This is just a temporary helper function that allows us to re-read what we wrote to file into a buffer.

/// We need this so that we can write to an archive.

/// TODO implement writing ZigObject data directly to a buffer instead.

pub fn readFileContents(self: *ZigObject, size: usize, macho_file: *MachO) !void {

const gpa = macho_file.base.comp.gpa;

try self.data.resize(gpa, size);

const amt = try macho_file.base.file.?.preadAll(self.data.items, 0);

if (amt != size) return error.InputOutput;

}

 

pub fn updateArSymtab(self: ZigObject, ar_symtab: *Archive.ArSymtab, macho_file: *MachO) error{OutOfMemory}!void {

const gpa = macho_file.base.comp.gpa;

for (self.symbols.items) |sym_index| {

const sym = macho_file.getSymbol(sym_index);

const file = sym.getFile(macho_file).?;

assert(file.getIndex() == self.index);

if (!sym.flags.@"export") continue;

const off = try ar_symtab.strtab.insert(gpa, sym.getName(macho_file));

try ar_symtab.entries.append(gpa, .{ .off = off, .file = self.index });

}

}

 

pub fn updateArSize(self: *ZigObject) void {

self.output_ar_state.size = self.data.items.len;

}

 

pub fn writeAr(self: ZigObject, ar_format: Archive.Format, writer: anytype) !void {

// Header

const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;

try Archive.writeHeader(self.path, size, ar_format, writer);

// Data

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

}

 

pub fn claimUnresolved(file: File, macho_file: *MachO) error{OutOfMemory}!void {

assert(file == .object or file == .zig_object);

 

for (file.getSymbols(), 0..) |sym_index, i| {

const nlist_idx = @as(Symbol.Index, @intCast(i));

const nlist = switch (file) {

.object => |x| x.symtab.items(.nlist)[nlist_idx],

.zig_object => |x| x.symtab.items(.nlist)[nlist_idx],

else => unreachable,

};

if (!nlist.ext()) continue;

if (!nlist.undf()) continue;

 

const sym = macho_file.getSymbol(sym_index);

if (sym.getFile(macho_file) != null) continue;

 

const is_import = switch (macho_file.undefined_treatment) {

.@"error" => false,

.warn, .suppress => nlist.weakRef(),

.dynamic_lookup => true,

};

if (is_import) {

sym.value = 0;

sym.atom = 0;

sym.nlist_idx = 0;

sym.file = macho_file.internal_object.?;

sym.flags.weak = false;

sym.flags.weak_ref = nlist.weakRef();

sym.flags.import = is_import;

sym.visibility = .global;

try macho_file.getInternalObject().?.symbols.append(macho_file.base.comp.gpa, sym_index);

}

}

}

 

pub fn claimUnresolvedRelocatable(file: File, macho_file: *MachO) void {

assert(file == .object or file == .zig_object);

 

for (file.getSymbols(), 0..) |sym_index, i| {

const nlist_idx = @as(Symbol.Index, @intCast(i));

const nlist = switch (file) {

.object => |x| x.symtab.items(.nlist)[nlist_idx],

.zig_object => |x| x.symtab.items(.nlist)[nlist_idx],

else => unreachable,

};

if (!nlist.ext()) continue;

if (!nlist.undf()) continue;

 

const sym = macho_file.getSymbol(sym_index);

if (sym.getFile(macho_file) != null) continue;

 

sym.value = 0;

sym.atom = 0;

sym.nlist_idx = nlist_idx;

sym.file = file.getIndex();

sym.flags.weak_ref = nlist.weakRef();

sym.flags.import = true;

sym.visibility = .global;

}

}

 

pub fn markImportsExports(file: File, macho_file: *MachO) void {

assert(file == .object or file == .zig_object);

 

for (file.getSymbols()) |sym_index| {

const sym = macho_file.getSymbol(sym_index);

const other_file = sym.getFile(macho_file) orelse continue;

if (sym.visibility != .global) continue;

if (other_file == .dylib and !sym.flags.abs) {

sym.flags.import = true;

continue;

}

if (other_file.getIndex() == file.getIndex()) {

sym.flags.@"export" = true;

}

}

}

 

pub fn markExportsRelocatable(file: File, macho_file: *MachO) void {

assert(file == .object or file == .zig_object);

 

for (file.getSymbols()) |sym_index| {

const sym = macho_file.getSymbol(sym_index);

const other_file = sym.getFile(macho_file) orelse continue;

if (sym.visibility != .global) continue;

if (other_file.getIndex() == file.getIndex()) {

sym.flags.@"export" = true;

}

}

}

 

pub fn updateArSymtab(file: File, ar_symtab: *Archive.ArSymtab, macho_file: *MachO) error{OutOfMemory}!void {

return switch (file) {

.dylib, .internal => unreachable,

inline else => |x| x.updateArSymtab(ar_symtab, macho_file),

};

}

 

pub fn updateArSize(file: File, macho_file: *MachO) !void {

return switch (file) {

.dylib, .internal => unreachable,

.zig_object => |x| x.updateArSize(),

.object => |x| x.updateArSize(macho_file),

};

}

 

pub fn writeAr(file: File, ar_format: Archive.Format, macho_file: *MachO, writer: anytype) !void {

return switch (file) {

.dylib, .internal => unreachable,

.zig_object => |x| x.writeAr(ar_format, writer),

.object => |x| x.writeAr(ar_format, macho_file, writer),

};

}

 

const assert = std.debug.assert;

const Archive = @import("Archive.zig");

pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {

markExports(macho_file);

claimUnresolved(macho_file);

if (build_options.enable_logging) {

state_log.debug("{}", .{macho_file.dumpState()});

}

pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {

const gpa = comp.gpa;

var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);

defer positionals.deinit();

 

try positionals.ensureUnusedCapacity(comp.objects.len);

positionals.appendSliceAssumeCapacity(comp.objects);

 

for (comp.c_object_table.keys()) |key| {

try positionals.append(.{ .path = key.status.success.object_path });

}

 

if (module_obj_path) |path| try positionals.append(.{ .path = path });

 

for (positionals.items) |obj| {

parsePositional(macho_file, obj.path) catch |err| switch (err) {

error.MalformedObject,

error.MalformedArchive,

error.InvalidCpuArch,

error.InvalidTarget,

=> continue, // already reported

error.UnknownFileType => try macho_file.reportParseError(obj.path, "unknown file type for an object file", .{}),

else => |e| try macho_file.reportParseError(

obj.path,

"unexpected error: parsing input file failed with error {s}",

.{@errorName(e)},

),

};

}

 

if (comp.link_errors.items.len > 0) return error.FlushFailure;

 

// First, we flush relocatable object file generated with our backends.

if (macho_file.getZigObject()) |zo| {

zo.resolveSymbols(macho_file);

zo.asFile().markExportsRelocatable(macho_file);

zo.asFile().claimUnresolvedRelocatable(macho_file);

try macho_file.sortSections();

try macho_file.addAtomsToSections();

try calcSectionSizes(macho_file);

try createSegment(macho_file);

try allocateSections(macho_file);

allocateSegment(macho_file);

 

var off = off: {

const seg = macho_file.segments.items[0];

const off = math.cast(u32, seg.fileoff + seg.filesize) orelse return error.Overflow;

break :off mem.alignForward(u32, off, @alignOf(macho.relocation_info));

};

off = allocateSectionsRelocs(macho_file, off);

 

if (build_options.enable_logging) {

state_log.debug("{}", .{macho_file.dumpState()});

 

try macho_file.calcSymtabSize();

try writeAtoms(macho_file);

 

off = mem.alignForward(u32, off, @alignOf(u64));

off = try macho_file.writeDataInCode(0, off);

off = mem.alignForward(u32, off, @alignOf(u64));

off = try macho_file.writeSymtab(off);

off = mem.alignForward(u32, off, @alignOf(u64));

off = try macho_file.writeStrtab(off);

 

// In order to please Apple ld (and possibly other MachO linkers in the wild),

// we will now sanitize segment names of Zig-specific segments.

sanitizeZigSections(macho_file);

 

const ncmds, const sizeofcmds = try writeLoadCommands(macho_file);

try writeHeader(macho_file, ncmds, sizeofcmds);

 

// TODO we can avoid reading in the file contents we just wrote if we give the linker

// ability to write directly to a buffer.

try zo.readFileContents(off, macho_file);

}

 

var files = std.ArrayList(File.Index).init(gpa);

defer files.deinit();

try files.ensureTotalCapacityPrecise(macho_file.objects.items.len + 1);

if (macho_file.getZigObject()) |zo| files.appendAssumeCapacity(zo.index);

for (macho_file.objects.items) |index| files.appendAssumeCapacity(index);

 

const format: Archive.Format = .p32;

const ptr_width = Archive.ptrWidth(format);

 

// Update ar symtab from parsed objects

var ar_symtab: Archive.ArSymtab = .{};

defer ar_symtab.deinit(gpa);

 

for (files.items) |index| {

try macho_file.getFile(index).?.updateArSymtab(&ar_symtab, macho_file);

}

 

ar_symtab.sort();

 

// Update sizes of contributing objects

for (files.items) |index| {

try macho_file.getFile(index).?.updateArSize(macho_file);

}

 

// Update file offsets of contributing objects

const total_size: usize = blk: {

var pos: usize = Archive.SARMAG;

pos += @sizeOf(Archive.ar_hdr) + Archive.SYMDEF.len + 1;

pos = mem.alignForward(usize, pos, ptr_width);

pos += ar_symtab.size(format);

 

for (files.items) |index| {

const file = macho_file.getFile(index).?;

const state = switch (file) {

.zig_object => |x| &x.output_ar_state,

.object => |x| &x.output_ar_state,

else => unreachable,

};

const path = switch (file) {

.zig_object => |x| x.path,

.object => |x| x.path,

else => unreachable,

};

pos = mem.alignForward(usize, pos, ptr_width);

state.file_off = pos;

pos += @sizeOf(Archive.ar_hdr) + path.len + 1;

pos = mem.alignForward(usize, pos, ptr_width);

pos += math.cast(usize, state.size) orelse return error.Overflow;

}

 

break :blk pos;

};

 

if (build_options.enable_logging) {

state_log.debug("ar_symtab\n{}\n", .{ar_symtab.fmt(macho_file)});

}

 

var buffer = std.ArrayList(u8).init(gpa);

defer buffer.deinit();

try buffer.ensureTotalCapacityPrecise(total_size);

const writer = buffer.writer();

 

// Write magic

try writer.writeAll(Archive.ARMAG);

 

// Write symtab

try ar_symtab.write(format, macho_file, writer);

 

// Write object files

for (files.items) |index| {

const aligned = mem.alignForward(usize, buffer.items.len, ptr_width);

const padding = aligned - buffer.items.len;

if (padding > 0) {

try writer.writeByteNTimes(0, padding);

}

try macho_file.getFile(index).?.writeAr(format, macho_file, writer);

}

 

assert(buffer.items.len == total_size);

 

try macho_file.base.file.?.setEndPos(total_size);

try macho_file.base.file.?.pwriteAll(buffer.items, 0);

 

if (comp.link_errors.items.len > 0) return error.FlushFailure;

}

 

fn parsePositional(macho_file: *MachO, path: []const u8) MachO.ParseError!void {

const tracy = trace(@src());

defer tracy.end();

if (try Object.isObject(path)) {

try parseObject(macho_file, path);

} else if (try fat.isFatLibrary(path)) {

const fat_arch = try macho_file.parseFatLibrary(path);

if (try Archive.isArchive(path, fat_arch)) {

try parseArchive(macho_file, path, fat_arch);

} else return error.UnknownFileType;

} else if (try Archive.isArchive(path, null)) {

try parseArchive(macho_file, path, null);

} else return error.UnknownFileType;

}

 

fn parseObject(macho_file: *MachO, path: []const u8) MachO.ParseError!void {

const tracy = trace(@src());

defer tracy.end();

 

const gpa = macho_file.base.comp.gpa;

const file = try std.fs.cwd().openFile(path, .{});

errdefer file.close();

const handle = try macho_file.addFileHandle(file);

const mtime: u64 = mtime: {

const stat = file.stat() catch break :mtime 0;

break :mtime @as(u64, @intCast(@divFloor(stat.mtime, 1_000_000_000)));

};

const index = @as(File.Index, @intCast(try macho_file.files.addOne(gpa)));

macho_file.files.set(index, .{ .object = .{

.path = try gpa.dupe(u8, path),

.file_handle = handle,

.mtime = mtime,

.index = index,

} });

try macho_file.objects.append(gpa, index);

 

const object = macho_file.getFile(index).?.object;

try object.parseAr(macho_file);

}

 

fn parseArchive(macho_file: *MachO, path: []const u8, fat_arch: ?fat.Arch) MachO.ParseError!void {

const tracy = trace(@src());

defer tracy.end();

 

const gpa = macho_file.base.comp.gpa;

 

const file = try std.fs.cwd().openFile(path, .{});

errdefer file.close();

const handle = try macho_file.addFileHandle(file);

 

var archive = Archive{};

defer archive.deinit(gpa);

try archive.parse(macho_file, path, handle, fat_arch);

 

var has_parse_error = false;

for (archive.objects.items) |extracted| {

const index = @as(File.Index, @intCast(try macho_file.files.addOne(gpa)));

macho_file.files.set(index, .{ .object = extracted });

const object = &macho_file.files.items(.data)[index].object;

object.index = index;

object.parseAr(macho_file) catch |err| switch (err) {

error.InvalidCpuArch => has_parse_error = true,

else => |e| return e,

};

try macho_file.objects.append(gpa, index);

}

if (has_parse_error) return error.MalformedArchive;

}

 

fn markExports(macho_file: *MachO) void {

if (macho_file.getZigObject()) |zo| {

zo.asFile().markExportsRelocatable(macho_file);

}

for (macho_file.objects.items) |index| {

macho_file.getFile(index).?.markExportsRelocatable(macho_file);

pub fn claimUnresolved(macho_file: *MachO) void {

if (macho_file.getZigObject()) |zo| {

zo.asFile().claimUnresolvedRelocatable(macho_file);

}

for (macho_file.objects.items) |index| {

macho_file.getFile(index).?.claimUnresolvedRelocatable(macho_file);

const build_options = @import("build_options");

const fat = @import("fat.zig");

const Archive = @import("Archive.zig");

const Object = @import("Object.zig");