authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-08-29 15:27:44+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-08-29 15:27:44+02:00
log79b3285aa216350e0c2ff18436a169af69e4570f
treed4529cb6e9e0c39db171612bc95aa9d8371be98f
parent1cae41bbbb3cb1cf10bfa808ecbe289bfb4d5180

macho: handle mismatched and missing platform errors

6 files changed, 290 insertions(+), 204 deletions(-)

src/link/MachO.zig+172-109
...@@ -396,16 +396,24 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No...@@ -396,16 +396,24 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
396 self.dylibs_map.clearRetainingCapacity();396 self.dylibs_map.clearRetainingCapacity();
397 self.referenced_dylibs.clearRetainingCapacity();397 self.referenced_dylibs.clearRetainingCapacity();
398398
399 const cpu_arch = self.base.options.target.cpu.arch;
400 var dependent_libs = std.fifo.LinearFifo(struct {399 var dependent_libs = std.fifo.LinearFifo(struct {
401 id: Dylib.Id,400 id: Dylib.Id,
402 parent: u16,401 parent: u16,
403 }, .Dynamic).init(arena);402 }, .Dynamic).init(arena);
404403
405 var parse_error_ctx: union {404 var parse_error_ctx: struct {
406 none: void,
407 detected_arch: std.Target.Cpu.Arch,405 detected_arch: std.Target.Cpu.Arch,
408 } = .{ .none = {} };406 detected_platform: ?Platform,
407 detected_stub_targets: []const []const u8,
408 } = .{
409 .detected_arch = undefined,
410 .detected_platform = null,
411 .detected_stub_targets = &[0][]const u8{},
412 };
413 defer {
414 for (parse_error_ctx.detected_stub_targets) |target| self.base.allocator.free(target);
415 self.base.allocator.free(parse_error_ctx.detected_stub_targets);
416 }
409417
410 for (libs.keys(), libs.values()) |path, lib| {418 for (libs.keys(), libs.values()) |path, lib| {
411 const in_file = try std.fs.cwd().openFile(path, .{});419 const in_file = try std.fs.cwd().openFile(path, .{});
...@@ -418,25 +426,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No...@@ -418,25 +426,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
418 false,426 false,
419 &dependent_libs,427 &dependent_libs,
420 &parse_error_ctx,428 &parse_error_ctx,
421 ) catch |err| switch (err) {429 ) catch |err| try self.handleAndReportParseError(path, err, parse_error_ctx);
422 error.DylibAlreadyExists => {},
423 error.UnknownFileType => try self.reportParseError(path, "unknown file type", .{}),
424 error.MissingArchFatLib => try self.reportParseError(
425 path,
426 "missing architecture in universal file, expected '{s}'",
427 .{@tagName(cpu_arch)},
428 ),
429 error.InvalidArch => try self.reportParseError(
430 path,
431 "invalid architecture '{s}', expected '{s}'",
432 .{ @tagName(parse_error_ctx.detected_arch), @tagName(cpu_arch) },
433 ),
434 else => |e| try self.reportParseError(
435 path,
436 "parsing library failed with error '{s}'",
437 .{@errorName(e)},
438 ),
439 };
440 }430 }
441431
442 self.parseDependentLibs(&dependent_libs, &parse_error_ctx) catch |err| {432 self.parseDependentLibs(&dependent_libs, &parse_error_ctx) catch |err| {
...@@ -586,7 +576,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No...@@ -586,7 +576,7 @@ pub fn flushModule(self: *MachO, comp: *Compilation, prog_node: *std.Progress.No
586 .version = 0,576 .version = 0,
587 });577 });
588 {578 {
589 const platform = load_commands.Platform.fromOptions(&self.base.options);579 const platform = Platform.fromTarget(self.base.options.target);
590 const sdk_version: ?std.SemanticVersion = if (self.base.options.sysroot) |path|580 const sdk_version: ?std.SemanticVersion = if (self.base.options.sysroot) |path|
591 load_commands.inferSdkVersionFromSdkPath(path)581 load_commands.inferSdkVersionFromSdkPath(path)
592 else582 else
...@@ -738,7 +728,8 @@ fn resolveLib(...@@ -738,7 +728,8 @@ fn resolveLib(
738const ParseError = error{728const ParseError = error{
739 UnknownFileType,729 UnknownFileType,
740 MissingArchFatLib,730 MissingArchFatLib,
741 InvalidArch,731 InvalidTarget,
732 InvalidLibStubTargets,
742 DylibAlreadyExists,733 DylibAlreadyExists,
743 IncompatibleDylibVersion,734 IncompatibleDylibVersion,
744 OutOfMemory,735 OutOfMemory,
...@@ -798,19 +789,24 @@ fn parseObject(...@@ -798,19 +789,24 @@ fn parseObject(
798 };789 };
799 errdefer object.deinit(gpa);790 errdefer object.deinit(gpa);
800 try object.parse(gpa);791 try object.parse(gpa);
801 try self.objects.append(gpa, object);
802792
803 const cpu_arch: std.Target.Cpu.Arch = switch (object.header.cputype) {793 const cpu_arch: std.Target.Cpu.Arch = switch (object.header.cputype) {
804 macho.CPU_TYPE_ARM64 => .aarch64,794 macho.CPU_TYPE_ARM64 => .aarch64,
805 macho.CPU_TYPE_X86_64 => .x86_64,795 macho.CPU_TYPE_X86_64 => .x86_64,
806 else => unreachable,796 else => unreachable,
807 };797 };
808 const self_cpu_arch = self.base.options.target.cpu.arch;798 error_ctx.detected_arch = cpu_arch;
809799
810 if (self_cpu_arch != cpu_arch) {800 if (object.getPlatform()) |platform| {
811 error_ctx.detected_arch = cpu_arch;801 error_ctx.detected_platform = platform;
812 return error.InvalidArch;802 }
803
804 if (self.base.options.target.cpu.arch != cpu_arch) return error.InvalidTarget;
805 if (error_ctx.detected_platform) |platform| {
806 if (!Platform.fromTarget(self.base.options.target).eqlTarget(platform)) return error.InvalidTarget;
813 }807 }
808
809 try self.objects.append(gpa, object);
814}810}
815811
816pub fn parseLibrary(812pub fn parseLibrary(
...@@ -825,14 +821,12 @@ pub fn parseLibrary(...@@ -825,14 +821,12 @@ pub fn parseLibrary(
825 const tracy = trace(@src());821 const tracy = trace(@src());
826 defer tracy.end();822 defer tracy.end();
827823
828 const cpu_arch = self.base.options.target.cpu.arch;
829
830 if (fat.isFatLibrary(file)) {824 if (fat.isFatLibrary(file)) {
831 const offset = try self.parseFatLibrary(file, cpu_arch);825 const offset = try self.parseFatLibrary(file, self.base.options.target.cpu.arch);
832 try file.seekTo(offset);826 try file.seekTo(offset);
833827
834 if (Archive.isArchive(file, offset)) {828 if (Archive.isArchive(file, offset)) {
835 try self.parseArchive(path, offset, must_link, cpu_arch, error_ctx);829 try self.parseArchive(path, offset, must_link, error_ctx);
836 } else if (Dylib.isDylib(file, offset)) {830 } else if (Dylib.isDylib(file, offset)) {
837 try self.parseDylib(file, path, offset, dependent_libs, .{831 try self.parseDylib(file, path, offset, dependent_libs, .{
838 .needed = lib.needed,832 .needed = lib.needed,
...@@ -840,7 +834,7 @@ pub fn parseLibrary(...@@ -840,7 +834,7 @@ pub fn parseLibrary(
840 }, error_ctx);834 }, error_ctx);
841 } else return error.UnknownFileType;835 } else return error.UnknownFileType;
842 } else if (Archive.isArchive(file, 0)) {836 } else if (Archive.isArchive(file, 0)) {
843 try self.parseArchive(path, 0, must_link, cpu_arch, error_ctx);837 try self.parseArchive(path, 0, must_link, error_ctx);
844 } else if (Dylib.isDylib(file, 0)) {838 } else if (Dylib.isDylib(file, 0)) {
845 try self.parseDylib(file, path, 0, dependent_libs, .{839 try self.parseDylib(file, path, 0, dependent_libs, .{
846 .needed = lib.needed,840 .needed = lib.needed,
...@@ -850,7 +844,7 @@ pub fn parseLibrary(...@@ -850,7 +844,7 @@ pub fn parseLibrary(
850 self.parseLibStub(file, path, dependent_libs, .{844 self.parseLibStub(file, path, dependent_libs, .{
851 .needed = lib.needed,845 .needed = lib.needed,
852 .weak = lib.weak,846 .weak = lib.weak,
853 }) catch |err| switch (err) {847 }, error_ctx) catch |err| switch (err) {
854 error.NotLibStub, error.UnexpectedToken => return error.UnknownFileType,848 error.NotLibStub, error.UnexpectedToken => return error.UnknownFileType,
855 else => |e| return e,849 else => |e| return e,
856 };850 };
...@@ -872,7 +866,6 @@ fn parseArchive(...@@ -872,7 +866,6 @@ fn parseArchive(
872 path: []const u8,866 path: []const u8,
873 fat_offset: u64,867 fat_offset: u64,
874 must_link: bool,868 must_link: bool,
875 cpu_arch: std.Target.Cpu.Arch,
876 error_ctx: anytype,869 error_ctx: anytype,
877) ParseError!void {870) ParseError!void {
878 const gpa = self.base.allocator;871 const gpa = self.base.allocator;
...@@ -899,14 +892,20 @@ fn parseArchive(...@@ -899,14 +892,20 @@ fn parseArchive(
899 var object = try archive.parseObject(gpa, off); // TODO we are doing all this work to pull the header only!892 var object = try archive.parseObject(gpa, off); // TODO we are doing all this work to pull the header only!
900 defer object.deinit(gpa);893 defer object.deinit(gpa);
901894
902 const parsed_cpu_arch: std.Target.Cpu.Arch = switch (object.header.cputype) {895 const cpu_arch: std.Target.Cpu.Arch = switch (object.header.cputype) {
903 macho.CPU_TYPE_ARM64 => .aarch64,896 macho.CPU_TYPE_ARM64 => .aarch64,
904 macho.CPU_TYPE_X86_64 => .x86_64,897 macho.CPU_TYPE_X86_64 => .x86_64,
905 else => unreachable,898 else => unreachable,
906 };899 };
907 if (cpu_arch != parsed_cpu_arch) {900 error_ctx.detected_arch = cpu_arch;
908 error_ctx.detected_arch = parsed_cpu_arch;901
909 return error.InvalidArch;902 if (object.getPlatform()) |platform| {
903 error_ctx.detected_platform = platform;
904 }
905
906 if (self.base.options.target.cpu.arch != cpu_arch) return error.InvalidTarget;
907 if (error_ctx.detected_platform) |platform| {
908 if (!Platform.fromTarget(self.base.options.target).eqlTarget(platform)) return error.InvalidTarget;
910 }909 }
911 }910 }
912911
...@@ -945,8 +944,6 @@ fn parseDylib(...@@ -945,8 +944,6 @@ fn parseDylib(
945 error_ctx: anytype,944 error_ctx: anytype,
946) ParseError!void {945) ParseError!void {
947 const gpa = self.base.allocator;946 const gpa = self.base.allocator;
948 const self_cpu_arch = self.base.options.target.cpu.arch;
949
950 const file_stat = try file.stat();947 const file_stat = try file.stat();
951 const file_size = math.cast(usize, file_stat.size - offset) orelse return error.Overflow;948 const file_size = math.cast(usize, file_stat.size - offset) orelse return error.Overflow;
952949
...@@ -969,12 +966,16 @@ fn parseDylib(...@@ -969,12 +966,16 @@ fn parseDylib(
969 macho.CPU_TYPE_X86_64 => .x86_64,966 macho.CPU_TYPE_X86_64 => .x86_64,
970 else => unreachable,967 else => unreachable,
971 };968 };
972 if (self_cpu_arch != cpu_arch) {969 error_ctx.detected_arch = cpu_arch;
973 error_ctx.detected_arch = cpu_arch;970
974 return error.InvalidArch;971 if (dylib.getPlatform(contents)) |platform| {
972 error_ctx.detected_platform = platform;
975 }973 }
976974
977 // TODO verify platform975 if (self.base.options.target.cpu.arch != cpu_arch) return error.InvalidTarget;
976 if (error_ctx.detected_platform) |platform| {
977 if (!Platform.fromTarget(self.base.options.target).eqlTarget(platform)) return error.InvalidTarget;
978 }
978979
979 try self.addDylib(dylib, .{980 try self.addDylib(dylib, .{
980 .needed = dylib_options.needed,981 .needed = dylib_options.needed,
...@@ -988,6 +989,7 @@ fn parseLibStub(...@@ -988,6 +989,7 @@ fn parseLibStub(
988 path: []const u8,989 path: []const u8,
989 dependent_libs: anytype,990 dependent_libs: anytype,
990 dylib_options: DylibOpts,991 dylib_options: DylibOpts,
992 error_ctx: anytype,
991) ParseError!void {993) ParseError!void {
992 const gpa = self.base.allocator;994 const gpa = self.base.allocator;
993 var lib_stub = try LibStub.loadFromFile(gpa, file);995 var lib_stub = try LibStub.loadFromFile(gpa, file);
...@@ -995,7 +997,20 @@ fn parseLibStub(...@@ -995,7 +997,20 @@ fn parseLibStub(
995997
996 if (lib_stub.inner.len == 0) return error.NotLibStub;998 if (lib_stub.inner.len == 0) return error.NotLibStub;
997999
998 // TODO verify platform1000 // Verify target
1001 {
1002 var matcher = try Dylib.TargetMatcher.init(gpa, self.base.options.target);
1003 defer matcher.deinit();
1004
1005 const first_tbd = lib_stub.inner[0];
1006 const targets = try first_tbd.targets(gpa);
1007 if (!matcher.matchesTarget(targets)) {
1008 error_ctx.detected_stub_targets = targets;
1009 return error.InvalidLibStubTargets;
1010 }
1011 for (targets) |t| gpa.free(t);
1012 gpa.free(targets);
1013 }
9991014
1000 var dylib = Dylib{ .weak = dylib_options.weak };1015 var dylib = Dylib{ .weak = dylib_options.weak };
1001 errdefer dylib.deinit(gpa);1016 errdefer dylib.deinit(gpa);
...@@ -1104,7 +1119,7 @@ pub fn parseDependentLibs(self: *MachO, dependent_libs: anytype, error_ctx: anyt...@@ -1104,7 +1119,7 @@ pub fn parseDependentLibs(self: *MachO, dependent_libs: anytype, error_ctx: anyt
1104 self.parseLibStub(file, full_path, dependent_libs, .{1119 self.parseLibStub(file, full_path, dependent_libs, .{
1105 .dependent = true,1120 .dependent = true,
1106 .weak = weak,1121 .weak = weak,
1107 }) catch |err| switch (err) {1122 }, error_ctx) catch |err| switch (err) {
1108 error.NotLibStub, error.UnexpectedToken => continue,1123 error.NotLibStub, error.UnexpectedToken => continue,
1109 else => |e| return e,1124 else => |e| return e,
1110 };1125 };
...@@ -4830,6 +4845,53 @@ pub fn getSectionPrecedence(header: macho.section_64) u8 {...@@ -4830,6 +4845,53 @@ pub fn getSectionPrecedence(header: macho.section_64) u8 {
4830 return (@as(u8, @intCast(segment_precedence)) << 4) + section_precedence;4845 return (@as(u8, @intCast(segment_precedence)) << 4) + section_precedence;
4831}4846}
48324847
4848pub fn handleAndReportParseError(self: *MachO, path: []const u8, err: ParseError, parse_error_ctx: anytype) !void {
4849 const cpu_arch = self.base.options.target.cpu.arch;
4850 switch (err) {
4851 error.DylibAlreadyExists => {},
4852 error.UnknownFileType => try self.reportParseError(path, "unknown file type", .{}),
4853 error.MissingArchFatLib => try self.reportParseError(
4854 path,
4855 "missing architecture in universal file, expected '{s}'",
4856 .{@tagName(cpu_arch)},
4857 ),
4858 error.InvalidTarget => if (parse_error_ctx.detected_platform) |platform| {
4859 try self.reportParseError(path, "invalid target '{s}-{}', expected '{s}-{}'", .{
4860 @tagName(parse_error_ctx.detected_arch),
4861 platform.fmtTarget(),
4862 @tagName(cpu_arch),
4863 Platform.fromTarget(self.base.options.target).fmtTarget(),
4864 });
4865 } else {
4866 try self.reportParseError(
4867 path,
4868 "invalid architecture '{s}', expected '{s}'",
4869 .{ @tagName(parse_error_ctx.detected_arch), @tagName(cpu_arch) },
4870 );
4871 },
4872 error.InvalidLibStubTargets => {
4873 var targets_string = std.ArrayList(u8).init(self.base.allocator);
4874 defer targets_string.deinit();
4875 try targets_string.writer().writeAll("(");
4876 for (parse_error_ctx.detected_stub_targets) |t| {
4877 try targets_string.writer().print("{s}, ", .{t});
4878 }
4879 try targets_string.resize(targets_string.items.len - 2);
4880 try targets_string.writer().writeAll(")");
4881 try self.reportParseError(path, "invalid targets '{s}', expected '{s}-{}'", .{
4882 targets_string.items,
4883 @tagName(cpu_arch),
4884 Platform.fromTarget(self.base.options.target).fmtTarget(),
4885 });
4886 },
4887 else => |e| try self.reportParseError(
4888 path,
4889 "parsing positional argument failed with error '{s}'",
4890 .{@errorName(e)},
4891 ),
4892 }
4893}
4894
4833pub fn reportParseError(self: *MachO, path: []const u8, comptime format: []const u8, args: anytype) !void {4895pub fn reportParseError(self: *MachO, path: []const u8, comptime format: []const u8, args: anytype) !void {
4834 const gpa = self.base.allocator;4896 const gpa = self.base.allocator;
4835 try self.misc_errors.ensureUnusedCapacity(gpa, 1);4897 try self.misc_errors.ensureUnusedCapacity(gpa, 1);
...@@ -5140,66 +5202,6 @@ pub fn logAtom(self: *MachO, atom_index: Atom.Index, logger: anytype) void {...@@ -5140,66 +5202,6 @@ pub fn logAtom(self: *MachO, atom_index: Atom.Index, logger: anytype) void {
5140 }5202 }
5141}5203}
51425204
5143const MachO = @This();
5144
5145const std = @import("std");
5146const build_options = @import("build_options");
5147const builtin = @import("builtin");
5148const assert = std.debug.assert;
5149const dwarf = std.dwarf;
5150const fs = std.fs;
5151const log = std.log.scoped(.link);
5152const macho = std.macho;
5153const math = std.math;
5154const mem = std.mem;
5155const meta = std.meta;
5156
5157const aarch64 = @import("../arch/aarch64/bits.zig");
5158const calcUuid = @import("MachO/uuid.zig").calcUuid;
5159const codegen = @import("../codegen.zig");
5160const dead_strip = @import("MachO/dead_strip.zig");
5161const fat = @import("MachO/fat.zig");
5162const link = @import("../link.zig");
5163const llvm_backend = @import("../codegen/llvm.zig");
5164const load_commands = @import("MachO/load_commands.zig");
5165const stubs = @import("MachO/stubs.zig");
5166const tapi = @import("tapi.zig");
5167const target_util = @import("../target.zig");
5168const thunks = @import("MachO/thunks.zig");
5169const trace = @import("../tracy.zig").trace;
5170const zld = @import("MachO/zld.zig");
5171
5172const Air = @import("../Air.zig");
5173const Allocator = mem.Allocator;
5174const Archive = @import("MachO/Archive.zig");
5175pub const Atom = @import("MachO/Atom.zig");
5176const Cache = std.Build.Cache;
5177const CodeSignature = @import("MachO/CodeSignature.zig");
5178const Compilation = @import("../Compilation.zig");
5179const Dwarf = File.Dwarf;
5180const DwarfInfo = @import("MachO/DwarfInfo.zig");
5181const Dylib = @import("MachO/Dylib.zig");
5182const File = link.File;
5183const Object = @import("MachO/Object.zig");
5184const LibStub = tapi.LibStub;
5185const Liveness = @import("../Liveness.zig");
5186const LlvmObject = @import("../codegen/llvm.zig").Object;
5187const Md5 = std.crypto.hash.Md5;
5188const Module = @import("../Module.zig");
5189const InternPool = @import("../InternPool.zig");
5190const Relocation = @import("MachO/Relocation.zig");
5191const StringTable = @import("strtab.zig").StringTable;
5192const TableSection = @import("table_section.zig").TableSection;
5193const Trie = @import("MachO/Trie.zig");
5194const Type = @import("../type.zig").Type;
5195const TypedValue = @import("../TypedValue.zig");
5196const Value = @import("../value.zig").Value;
5197
5198pub const DebugSymbols = @import("MachO/DebugSymbols.zig");
5199pub const Bind = @import("MachO/dyld_info/bind.zig").Bind(*const MachO, SymbolWithLoc);
5200pub const LazyBind = @import("MachO/dyld_info/bind.zig").LazyBind(*const MachO, SymbolWithLoc);
5201pub const Rebase = @import("MachO/dyld_info/Rebase.zig");
5202
5203pub const base_tag: File.Tag = File.Tag.macho;5205pub const base_tag: File.Tag = File.Tag.macho;
5204pub const N_DEAD: u16 = @as(u16, @bitCast(@as(i16, -1)));5206pub const N_DEAD: u16 = @as(u16, @bitCast(@as(i16, -1)));
52055207
...@@ -5332,3 +5334,64 @@ pub const default_pagezero_vmsize: u64 = 0x100000000;...@@ -5332,3 +5334,64 @@ pub const default_pagezero_vmsize: u64 = 0x100000000;
5332/// the table of load commands. This should be plenty for any5334/// the table of load commands. This should be plenty for any
5333/// potential future extensions.5335/// potential future extensions.
5334pub const default_headerpad_size: u32 = 0x1000;5336pub const default_headerpad_size: u32 = 0x1000;
5337
5338const MachO = @This();
5339
5340const std = @import("std");
5341const build_options = @import("build_options");
5342const builtin = @import("builtin");
5343const assert = std.debug.assert;
5344const dwarf = std.dwarf;
5345const fs = std.fs;
5346const log = std.log.scoped(.link);
5347const macho = std.macho;
5348const math = std.math;
5349const mem = std.mem;
5350const meta = std.meta;
5351
5352const aarch64 = @import("../arch/aarch64/bits.zig");
5353const calcUuid = @import("MachO/uuid.zig").calcUuid;
5354const codegen = @import("../codegen.zig");
5355const dead_strip = @import("MachO/dead_strip.zig");
5356const fat = @import("MachO/fat.zig");
5357const link = @import("../link.zig");
5358const llvm_backend = @import("../codegen/llvm.zig");
5359const load_commands = @import("MachO/load_commands.zig");
5360const stubs = @import("MachO/stubs.zig");
5361const tapi = @import("tapi.zig");
5362const target_util = @import("../target.zig");
5363const thunks = @import("MachO/thunks.zig");
5364const trace = @import("../tracy.zig").trace;
5365const zld = @import("MachO/zld.zig");
5366
5367const Air = @import("../Air.zig");
5368const Allocator = mem.Allocator;
5369const Archive = @import("MachO/Archive.zig");
5370pub const Atom = @import("MachO/Atom.zig");
5371const Cache = std.Build.Cache;
5372const CodeSignature = @import("MachO/CodeSignature.zig");
5373const Compilation = @import("../Compilation.zig");
5374const Dwarf = File.Dwarf;
5375const DwarfInfo = @import("MachO/DwarfInfo.zig");
5376const Dylib = @import("MachO/Dylib.zig");
5377const File = link.File;
5378const Object = @import("MachO/Object.zig");
5379const LibStub = tapi.LibStub;
5380const Liveness = @import("../Liveness.zig");
5381const LlvmObject = @import("../codegen/llvm.zig").Object;
5382const Md5 = std.crypto.hash.Md5;
5383const Module = @import("../Module.zig");
5384const InternPool = @import("../InternPool.zig");
5385const Platform = load_commands.Platform;
5386const Relocation = @import("MachO/Relocation.zig");
5387const StringTable = @import("strtab.zig").StringTable;
5388const TableSection = @import("table_section.zig").TableSection;
5389const Trie = @import("MachO/Trie.zig");
5390const Type = @import("../type.zig").Type;
5391const TypedValue = @import("../TypedValue.zig");
5392const Value = @import("../value.zig").Value;
5393
5394pub const DebugSymbols = @import("MachO/DebugSymbols.zig");
5395pub const Bind = @import("MachO/dyld_info/bind.zig").Bind(*const MachO, SymbolWithLoc);
5396pub const LazyBind = @import("MachO/dyld_info/bind.zig").LazyBind(*const MachO, SymbolWithLoc);
5397pub const Rebase = @import("MachO/dyld_info/Rebase.zig");
src/link/MachO/Dylib.zig+54-48
...@@ -178,6 +178,26 @@ pub fn parseFromBinary(...@@ -178,6 +178,26 @@ pub fn parseFromBinary(
178 }178 }
179}179}
180180
181/// Returns Platform composed from the first encountered build version type load command:
182/// either LC_BUILD_VERSION or LC_VERSION_MIN_*.
183pub fn getPlatform(self: Dylib, data: []align(@alignOf(u64)) const u8) ?Platform {
184 var it = LoadCommandIterator{
185 .ncmds = self.header.?.ncmds,
186 .buffer = data[@sizeOf(macho.mach_header_64)..][0..self.header.?.sizeofcmds],
187 };
188 while (it.next()) |cmd| {
189 switch (cmd.cmd()) {
190 .BUILD_VERSION,
191 .VERSION_MIN_MACOSX,
192 .VERSION_MIN_IPHONEOS,
193 .VERSION_MIN_TVOS,
194 .VERSION_MIN_WATCHOS,
195 => return Platform.fromLoadCommand(cmd),
196 else => {},
197 }
198 } else return null;
199}
200
181fn addObjCClassSymbol(self: *Dylib, allocator: Allocator, sym_name: []const u8) !void {201fn addObjCClassSymbol(self: *Dylib, allocator: Allocator, sym_name: []const u8) !void {
182 const expanded = &[_][]const u8{202 const expanded = &[_][]const u8{
183 try std.fmt.allocPrint(allocator, "_OBJC_CLASS_$_{s}", .{sym_name}),203 try std.fmt.allocPrint(allocator, "_OBJC_CLASS_$_{s}", .{sym_name}),
...@@ -212,27 +232,27 @@ fn addWeakSymbol(self: *Dylib, allocator: Allocator, sym_name: []const u8) !void...@@ -212,27 +232,27 @@ fn addWeakSymbol(self: *Dylib, allocator: Allocator, sym_name: []const u8) !void
212 try self.symbols.putNoClobber(allocator, try allocator.dupe(u8, sym_name), true);232 try self.symbols.putNoClobber(allocator, try allocator.dupe(u8, sym_name), true);
213}233}
214234
215const TargetMatcher = struct {235pub const TargetMatcher = struct {
216 allocator: Allocator,236 allocator: Allocator,
217 target: CrossTarget,237 cpu_arch: std.Target.Cpu.Arch,
238 os_tag: std.Target.Os.Tag,
239 abi: std.Target.Abi,
218 target_strings: std.ArrayListUnmanaged([]const u8) = .{},240 target_strings: std.ArrayListUnmanaged([]const u8) = .{},
219241
220 pub fn init(allocator: Allocator, target: CrossTarget) !TargetMatcher {242 pub fn init(allocator: Allocator, target: std.Target) !TargetMatcher {
221 var self = TargetMatcher{243 var self = TargetMatcher{
222 .allocator = allocator,244 .allocator = allocator,
223 .target = target,245 .cpu_arch = target.cpu.arch,
246 .os_tag = target.os.tag,
247 .abi = target.abi,
224 };248 };
225 const apple_string = try targetToAppleString(allocator, target);249 const apple_string = try toAppleTargetTriple(allocator, self.cpu_arch, self.os_tag, self.abi);
226 try self.target_strings.append(allocator, apple_string);250 try self.target_strings.append(allocator, apple_string);
227251
228 const abi = target.abi orelse .none;252 if (self.abi == .simulator) {
229 if (abi == .simulator) {
230 // For Apple simulator targets, linking gets tricky as we need to link against the simulator253 // For Apple simulator targets, linking gets tricky as we need to link against the simulator
231 // hosts dylibs too.254 // hosts dylibs too.
232 const host_target = try targetToAppleString(allocator, .{255 const host_target = try toAppleTargetTriple(allocator, self.cpu_arch, .macos, .none);
233 .cpu_arch = target.cpu_arch.?,
234 .os_tag = .macos,
235 });
236 try self.target_strings.append(allocator, host_target);256 try self.target_strings.append(allocator, host_target);
237 }257 }
238258
...@@ -246,7 +266,7 @@ const TargetMatcher = struct {...@@ -246,7 +266,7 @@ const TargetMatcher = struct {
246 self.target_strings.deinit(self.allocator);266 self.target_strings.deinit(self.allocator);
247 }267 }
248268
249 inline fn cpuArchToAppleString(cpu_arch: std.Target.Cpu.Arch) []const u8 {269 inline fn fmtCpuArch(cpu_arch: std.Target.Cpu.Arch) []const u8 {
250 return switch (cpu_arch) {270 return switch (cpu_arch) {
251 .aarch64 => "arm64",271 .aarch64 => "arm64",
252 .x86_64 => "x86_64",272 .x86_64 => "x86_64",
...@@ -254,7 +274,7 @@ const TargetMatcher = struct {...@@ -254,7 +274,7 @@ const TargetMatcher = struct {
254 };274 };
255 }275 }
256276
257 inline fn abiToAppleString(abi: std.Target.Abi) ?[]const u8 {277 inline fn fmtAbi(abi: std.Target.Abi) ?[]const u8 {
258 return switch (abi) {278 return switch (abi) {
259 .none => null,279 .none => null,
260 .simulator => "simulator",280 .simulator => "simulator",
...@@ -263,14 +283,18 @@ const TargetMatcher = struct {...@@ -263,14 +283,18 @@ const TargetMatcher = struct {
263 };283 };
264 }284 }
265285
266 pub fn targetToAppleString(allocator: Allocator, target: CrossTarget) ![]const u8 {286 pub fn toAppleTargetTriple(
267 const cpu_arch = cpuArchToAppleString(target.cpu_arch.?);287 allocator: Allocator,
268 const os_tag = @tagName(target.os_tag.?);288 cpu_arch: std.Target.Cpu.Arch,
269 const target_abi = abiToAppleString(target.abi orelse .none);289 os_tag: std.Target.Os.Tag,
270 if (target_abi) |abi| {290 abi: std.Target.Abi,
271 return std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{ cpu_arch, os_tag, abi });291 ) ![]const u8 {
292 const cpu_arch_s = fmtCpuArch(cpu_arch);
293 const os_tag_s = @tagName(os_tag);
294 if (fmtAbi(abi)) |abi_s| {
295 return std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{ cpu_arch_s, os_tag_s, abi_s });
272 }296 }
273 return std.fmt.allocPrint(allocator, "{s}-{s}", .{ cpu_arch, os_tag });297 return std.fmt.allocPrint(allocator, "{s}-{s}", .{ cpu_arch_s, os_tag_s });
274 }298 }
275299
276 fn hasValue(stack: []const []const u8, needle: []const u8) bool {300 fn hasValue(stack: []const []const u8, needle: []const u8) bool {
...@@ -280,7 +304,7 @@ const TargetMatcher = struct {...@@ -280,7 +304,7 @@ const TargetMatcher = struct {
280 return false;304 return false;
281 }305 }
282306
283 fn matchesTarget(self: TargetMatcher, targets: []const []const u8) bool {307 pub fn matchesTarget(self: TargetMatcher, targets: []const []const u8) bool {
284 for (self.target_strings.items) |t| {308 for (self.target_strings.items) |t| {
285 if (hasValue(targets, t)) return true;309 if (hasValue(targets, t)) return true;
286 }310 }
...@@ -288,26 +312,7 @@ const TargetMatcher = struct {...@@ -288,26 +312,7 @@ const TargetMatcher = struct {
288 }312 }
289313
290 fn matchesArch(self: TargetMatcher, archs: []const []const u8) bool {314 fn matchesArch(self: TargetMatcher, archs: []const []const u8) bool {
291 return hasValue(archs, cpuArchToAppleString(self.target.cpu_arch.?));315 return hasValue(archs, fmtCpuArch(self.cpu_arch));
292 }
293
294 pub fn matchesTargetTbd(self: TargetMatcher, tbd: Tbd) !bool {
295 var arena = std.heap.ArenaAllocator.init(self.allocator);
296 defer arena.deinit();
297
298 const targets = switch (tbd) {
299 .v3 => |v3| blk: {
300 var targets = std.ArrayList([]const u8).init(arena.allocator());
301 for (v3.archs) |arch| {
302 const target = try std.fmt.allocPrint(arena.allocator(), "{s}-{s}", .{ arch, v3.platform });
303 try targets.append(target);
304 }
305 break :blk targets.items;
306 },
307 .v4 => |v4| v4.targets,
308 };
309
310 return self.matchesTarget(targets);
311 }316 }
312};317};
313318
...@@ -342,15 +347,16 @@ pub fn parseFromStub(...@@ -342,15 +347,16 @@ pub fn parseFromStub(
342347
343 log.debug(" (install_name '{s}')", .{umbrella_lib.installName()});348 log.debug(" (install_name '{s}')", .{umbrella_lib.installName()});
344349
345 var matcher = try TargetMatcher.init(allocator, .{350 var matcher = try TargetMatcher.init(allocator, target);
346 .cpu_arch = target.cpu.arch,
347 .os_tag = target.os.tag,
348 .abi = target.abi,
349 });
350 defer matcher.deinit();351 defer matcher.deinit();
351352
352 for (lib_stub.inner, 0..) |elem, stub_index| {353 for (lib_stub.inner, 0..) |elem, stub_index| {
353 if (!(try matcher.matchesTargetTbd(elem))) continue;354 const targets = try elem.targets(allocator);
355 defer {
356 for (targets) |t| allocator.free(t);
357 allocator.free(targets);
358 }
359 if (!matcher.matchesTarget(targets)) continue;
354360
355 if (stub_index > 0) {361 if (stub_index > 0) {
356 // TODO I thought that we could switch on presence of `parent-umbrella` map;362 // TODO I thought that we could switch on presence of `parent-umbrella` map;
...@@ -541,8 +547,8 @@ const fat = @import("fat.zig");...@@ -541,8 +547,8 @@ const fat = @import("fat.zig");
541const tapi = @import("../tapi.zig");547const tapi = @import("../tapi.zig");
542548
543const Allocator = mem.Allocator;549const Allocator = mem.Allocator;
544const CrossTarget = std.zig.CrossTarget;
545const LibStub = tapi.LibStub;550const LibStub = tapi.LibStub;
546const LoadCommandIterator = macho.LoadCommandIterator;551const LoadCommandIterator = macho.LoadCommandIterator;
547const MachO = @import("../MachO.zig");552const MachO = @import("../MachO.zig");
553const Platform = @import("load_commands.zig").Platform;
548const Tbd = tapi.Tbd;554const Tbd = tapi.Tbd;
src/link/MachO/Object.zig+1-1
...@@ -940,7 +940,7 @@ pub fn parseDwarfInfo(self: Object) DwarfInfo {...@@ -940,7 +940,7 @@ pub fn parseDwarfInfo(self: Object) DwarfInfo {
940 return di;940 return di;
941}941}
942942
943/// Returns Options.Platform composed from the first encountered build version type load command:943/// Returns Platform composed from the first encountered build version type load command:
944/// either LC_BUILD_VERSION or LC_VERSION_MIN_*.944/// either LC_BUILD_VERSION or LC_VERSION_MIN_*.
945pub fn getPlatform(self: Object) ?Platform {945pub fn getPlatform(self: Object) ?Platform {
946 var it = LoadCommandIterator{946 var it = LoadCommandIterator{
src/link/MachO/load_commands.zig+27-5
...@@ -77,7 +77,7 @@ fn calcLCsSize(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx...@@ -77,7 +77,7 @@ fn calcLCsSize(gpa: Allocator, options: *const link.Options, ctx: CalcLCsSizeCtx
77 // LC_SOURCE_VERSION77 // LC_SOURCE_VERSION
78 sizeofcmds += @sizeOf(macho.source_version_command);78 sizeofcmds += @sizeOf(macho.source_version_command);
79 // LC_BUILD_VERSION or LC_VERSION_MIN_79 // LC_BUILD_VERSION or LC_VERSION_MIN_
80 if (Platform.fromOptions(options).isBuildVersionCompatible()) {80 if (Platform.fromTarget(options.target).isBuildVersionCompatible()) {
81 // LC_BUILD_VERSION81 // LC_BUILD_VERSION
82 sizeofcmds += @sizeOf(macho.build_version_command) + @sizeOf(macho.build_tool_version);82 sizeofcmds += @sizeOf(macho.build_version_command) + @sizeOf(macho.build_tool_version);
83 } else {83 } else {
...@@ -353,11 +353,11 @@ pub const Platform = struct {...@@ -353,11 +353,11 @@ pub const Platform = struct {
353 }353 }
354 }354 }
355355
356 pub fn fromOptions(options: *const link.Options) Platform {356 pub fn fromTarget(target: std.Target) Platform {
357 return .{357 return .{
358 .os_tag = options.target.os.tag,358 .os_tag = target.os.tag,
359 .abi = options.target.abi,359 .abi = target.abi,
360 .version = options.target.os.version_range.semver.min,360 .version = target.os.version_range.semver.min,
361 };361 };
362 }362 }
363363
...@@ -383,6 +383,28 @@ pub const Platform = struct {...@@ -383,6 +383,28 @@ pub const Platform = struct {
383 }383 }
384 return false;384 return false;
385 }385 }
386
387 pub fn fmtTarget(plat: Platform) std.fmt.Formatter(formatTarget) {
388 return .{ .data = plat };
389 }
390
391 pub fn formatTarget(
392 plat: Platform,
393 comptime unused_fmt_string: []const u8,
394 options: std.fmt.FormatOptions,
395 writer: anytype,
396 ) !void {
397 _ = unused_fmt_string;
398 _ = options;
399 try writer.print("{s}", .{@tagName(plat.os_tag)});
400 if (plat.abi != .none) {
401 try writer.print("-{s}", .{@tagName(plat.abi)});
402 }
403 }
404
405 pub fn eqlTarget(plat: Platform, other: Platform) bool {
406 return plat.os_tag == other.os_tag and plat.abi == other.abi;
407 }
386};408};
387409
388const SupportedPlatforms = struct {410const SupportedPlatforms = struct {
src/link/MachO/zld.zig+12-41
...@@ -347,11 +347,17 @@ pub fn linkWithZld(...@@ -347,11 +347,17 @@ pub fn linkWithZld(
347347
348 var parse_error_ctx: struct {348 var parse_error_ctx: struct {
349 detected_arch: std.Target.Cpu.Arch,349 detected_arch: std.Target.Cpu.Arch,
350 detected_os: std.Target.Os.Tag,350 detected_platform: ?Platform,
351 detected_stub_targets: []const []const u8,
351 } = .{352 } = .{
352 .detected_arch = undefined,353 .detected_arch = undefined,
353 .detected_os = undefined,354 .detected_platform = null,
355 .detected_stub_targets = &[0][]const u8{},
354 };356 };
357 defer {
358 for (parse_error_ctx.detected_stub_targets) |t| gpa.free(t);
359 gpa.free(parse_error_ctx.detected_stub_targets);
360 }
355361
356 for (positionals.items) |obj| {362 for (positionals.items) |obj| {
357 const in_file = try std.fs.cwd().openFile(obj.path, .{});363 const in_file = try std.fs.cwd().openFile(obj.path, .{});
...@@ -363,25 +369,7 @@ pub fn linkWithZld(...@@ -363,25 +369,7 @@ pub fn linkWithZld(
363 obj.must_link,369 obj.must_link,
364 &dependent_libs,370 &dependent_libs,
365 &parse_error_ctx,371 &parse_error_ctx,
366 ) catch |err| switch (err) {372 ) catch |err| try macho_file.handleAndReportParseError(obj.path, err, parse_error_ctx);
367 error.DylibAlreadyExists => {},
368 error.UnknownFileType => try macho_file.reportParseError(obj.path, "unknown file type", .{}),
369 error.MissingArchFatLib => try macho_file.reportParseError(
370 obj.path,
371 "missing architecture in universal file, expected '{s}'",
372 .{@tagName(cpu_arch)},
373 ),
374 error.InvalidArch => try macho_file.reportParseError(
375 obj.path,
376 "invalid architecture '{s}', expected '{s}'",
377 .{ @tagName(parse_error_ctx.detected_arch), @tagName(cpu_arch) },
378 ),
379 else => |e| try macho_file.reportParseError(
380 obj.path,
381 "parsing positional argument failed with error '{s}'",
382 .{@errorName(e)},
383 ),
384 };
385 }373 }
386374
387 for (libs.keys(), libs.values()) |path, lib| {375 for (libs.keys(), libs.values()) |path, lib| {
...@@ -395,25 +383,7 @@ pub fn linkWithZld(...@@ -395,25 +383,7 @@ pub fn linkWithZld(
395 false,383 false,
396 &dependent_libs,384 &dependent_libs,
397 &parse_error_ctx,385 &parse_error_ctx,
398 ) catch |err| switch (err) {386 ) catch |err| try macho_file.handleAndReportParseError(path, err, parse_error_ctx);
399 error.DylibAlreadyExists => {},
400 error.UnknownFileType => try macho_file.reportParseError(path, "unknown file type", .{}),
401 error.MissingArchFatLib => try macho_file.reportParseError(
402 path,
403 "missing architecture in universal file, expected '{s}'",
404 .{@tagName(cpu_arch)},
405 ),
406 error.InvalidArch => try macho_file.reportParseError(
407 path,
408 "invalid architecture '{s}', expected '{s}'",
409 .{ @tagName(parse_error_ctx.detected_arch), @tagName(cpu_arch) },
410 ),
411 else => |e| try macho_file.reportParseError(
412 path,
413 "parsing library failed with error '{s}'",
414 .{@errorName(e)},
415 ),
416 };
417 }387 }
418388
419 macho_file.parseDependentLibs(&dependent_libs, &parse_error_ctx) catch |err| {389 macho_file.parseDependentLibs(&dependent_libs, &parse_error_ctx) catch |err| {
...@@ -590,7 +560,7 @@ pub fn linkWithZld(...@@ -590,7 +560,7 @@ pub fn linkWithZld(
590 .version = 0,560 .version = 0,
591 });561 });
592 {562 {
593 const platform = load_commands.Platform.fromOptions(&macho_file.base.options);563 const platform = Platform.fromTarget(macho_file.base.options.target);
594 const sdk_version: ?std.SemanticVersion = if (macho_file.base.options.sysroot) |path|564 const sdk_version: ?std.SemanticVersion = if (macho_file.base.options.sysroot) |path|
595 load_commands.inferSdkVersionFromSdkPath(path)565 load_commands.inferSdkVersionFromSdkPath(path)
596 else566 else
...@@ -1252,6 +1222,7 @@ const MachO = @import("../MachO.zig");...@@ -1252,6 +1222,7 @@ const MachO = @import("../MachO.zig");
1252const Md5 = std.crypto.hash.Md5;1222const Md5 = std.crypto.hash.Md5;
1253const LibStub = @import("../tapi.zig").LibStub;1223const LibStub = @import("../tapi.zig").LibStub;
1254const Object = @import("Object.zig");1224const Object = @import("Object.zig");
1225const Platform = load_commands.Platform;
1255const Section = MachO.Section;1226const Section = MachO.Section;
1256const StringTable = @import("../strtab.zig").StringTable;1227const StringTable = @import("../strtab.zig").StringTable;
1257const SymbolWithLoc = MachO.SymbolWithLoc;1228const SymbolWithLoc = MachO.SymbolWithLoc;
src/link/tapi.zig+24
...@@ -81,6 +81,30 @@ pub const Tbd = union(enum) {...@@ -81,6 +81,30 @@ pub const Tbd = union(enum) {
81 v3: TbdV3,81 v3: TbdV3,
82 v4: TbdV4,82 v4: TbdV4,
8383
84 /// Caller owns memory.
85 pub fn targets(self: Tbd, gpa: Allocator) error{OutOfMemory}![]const []const u8 {
86 var out = std.ArrayList([]const u8).init(gpa);
87 defer out.deinit();
88
89 switch (self) {
90 .v3 => |v3| {
91 try out.ensureTotalCapacityPrecise(v3.archs.len);
92 for (v3.archs) |arch| {
93 const target = try std.fmt.allocPrint(gpa, "{s}-{s}", .{ arch, v3.platform });
94 out.appendAssumeCapacity(target);
95 }
96 },
97 .v4 => |v4| {
98 try out.ensureTotalCapacityPrecise(v4.targets.len);
99 for (v4.targets) |t| {
100 out.appendAssumeCapacity(try gpa.dupe(u8, t));
101 }
102 },
103 }
104
105 return out.toOwnedSlice();
106 }
107
84 pub fn currentVersion(self: Tbd) ?VersionField {108 pub fn currentVersion(self: Tbd) ?VersionField {
85 return switch (self) {109 return switch (self) {
86 .v3 => |v3| v3.current_version,110 .v3 => |v3| v3.current_version,