Commit 72e09893686613bd65369faf9272171d272fbee3 | zig

author	Alex Rønne Petersen <alex@alexrp.com> 2026-07-25 01:16:19+02:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-07-25 01:17:21+02:00
log	72e09893686613bd65369faf9272171d272fbee3
tree	af35966b4a2a6fee13cad0aa755d2feb2ddc4bec
parent	2ae38cbd2599af06beebc4ae9e3cdbbbc6cefc89
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

link.MachO: add LC_ENCRYPTION_INFO_64 for non-sim ios/tvos/visionos/watchos

closes https://codeberg.org/ziglang/zig/issues/36285

2 files changed, 45 insertions(+), 8 deletions(-)

src
- link
  - MachO.zig
  - MachO
    load_commands.zig

src/link/MachO.zig+23-3

 @@ -24,6 +24,8 @@ dylibs: std.ArrayList(File.Index) = .empty,
 segments: std.ArrayList(macho.segment_command_64) = .empty,
 sections: std.MultiArrayList(Section) = .{},
+/// Populated by `allocateSections`.
+header_size: ?u32 = null,
 resolver: SymbolResolver = .{},
 /// This table will be populated after `scanRelocs` has run.
 @@ -2209,13 +2211,14 @@ fn initSegments(self: *MachO) !void {
 }
 fn allocateSections(self: *MachO) !void {
-    const headerpad = try load_commands.calcMinHeaderPadSize(self);
+    const header_size = try load_commands.calcMinHeaderSize(self);
+    self.header_size = header_size;
     var vmaddr: u64 = if (self.pagezero_seg_index) |index|
         self.segments.items[index].vmaddr + self.segments.items[index].vmsize
     else
         0;
-    vmaddr += headerpad;
+    vmaddr += header_size;
-    var fileoff = headerpad;
+    var fileoff = header_size;
     var prev_seg_id: u8 = if (self.pagezero_seg_index) |index| index + 1 else 0;
     const page_size = self.getPageSize();
 @@ -2895,6 +2898,11 @@ fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {
         ncmds += 1;
     }
+    if (self.needsEncryptionInfo()) {
+        try load_commands.writeEncryptionInfoLC(self, &writer);
+        ncmds += 1;
+    }
     for (self.rpath_list) |rpath| {
         try load_commands.writeRpathLC(rpath, &writer);
         ncmds += 1;
 @@ -5410,6 +5418,18 @@ pub fn alignPow(macho_file: *MachO, x: u32) error{AlreadyReported}!u32 {
     return result;
 }
+pub fn needsEncryptionInfo(macho_file: *MachO) bool {
+    const target = macho_file.getTarget();
+    return switch (target.os.tag) {
+        .ios,
+        .tvos,
+        .visionos,
+        .watchos,
+        => target.abi != .simulator,
+        else => false,
+    };
+}
 /// Branch instruction has 26 bits immediate but is 4 byte aligned.
 const jump_bits = @bitSizeOf(i28);
 const max_distance = (1 << (jump_bits - 1));

src/link/MachO/load_commands.zig+22-5

 @@ -62,6 +62,10 @@ pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) !u32
             assume_max_path_len,
         );
     }
+    // LC_ENCRYPTION_INFO_64
+    if (macho_file.needsEncryptionInfo()) {
+        sizeofcmds += @sizeOf(macho.encryption_info_command_64);
+    }
     // LC_RPATH
     {
         for (macho_file.rpath_list) |rpath| {
 @@ -163,23 +167,29 @@ pub fn calcLoadCommandsSizeObject(macho_file: *MachO) u32 {
     return @as(u32, @intCast(sizeofcmds));
 }
-pub fn calcMinHeaderPadSize(macho_file: *MachO) !u32 {
+pub fn calcMinHeaderSize(macho_file: *MachO) !u32 {
     var padding: u32 = (try calcLoadCommandsSize(macho_file, false)) +
         (macho_file.headerpad_size orelse MachO.default_headerpad_size);
-    log.debug("minimum requested headerpad size 0x{x}", .{padding + @sizeOf(macho.mach_header_64)});
+    log.debug("minimum requested header + padding size 0x{x}", .{padding + @sizeOf(macho.mach_header_64)});
     if (macho_file.headerpad_max_install_names) {
         const min_headerpad_size: u32 = try calcLoadCommandsSize(macho_file, true);
-        log.debug("headerpad_max_install_names minimum headerpad size 0x{x}", .{
+        log.debug("headerpad_max_install_names minimum header + padding size 0x{x}", .{
             min_headerpad_size + @sizeOf(macho.mach_header_64),
         });
         padding = @max(padding, min_headerpad_size);
     }
     const offset = @sizeOf(macho.mach_header_64) + padding;
-    log.debug("actual headerpad size 0x{x}", .{offset});
+    log.debug("actual header + padding size 0x{x}", .{offset});
-    return offset;
+    // Encryption is done at page granularity, so if the output needs a load
+    // command for encryption info, ensure that the header + load commands have
+    // at least one full, unencrypted page.
+    return if (macho_file.needsEncryptionInfo())
+        mem.alignForward(u32, offset, macho_file.getPageSize())
+    else
+        offset;
 }
 pub fn writeDylinkerLC(writer: *Writer) !void {
 @@ -260,6 +270,13 @@ pub fn writeDylibIdLC(macho_file: *MachO, writer: *Writer) !void {
     }, writer);
 }
+pub fn writeEncryptionInfoLC(macho_file: *MachO, writer: *Writer) !void {
+    try writer.writeAll(mem.asBytes(&macho.encryption_info_command_64{
+        .cryptoff = macho_file.header_size.?,
+        .cryptsize = @as(u32, @intCast(macho_file.getTextSegment().filesize)) - macho_file.header_size.?,
+    }));
+}
 pub fn writeRpathLC(rpath: []const u8, writer: *Writer) !void {
     const rpath_len = rpath.len + 1;
     const cmdsize = @as(u32, @intCast(mem.alignForward(