srctree

pub const ParseError = error{

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

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 => {},

};

}

 

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)},

),

};

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;

}

 

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

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