Commit dac1cd7750
Changed files (2)
src-self-hosted
src-self-hosted/link/MachO.zig
@@ -18,36 +18,66 @@ const File = link.File;
pub const base_tag: File.Tag = File.Tag.macho;
+const LoadCommand = union(enum) {
+ Segment: macho.segment_command_64,
+ LinkeditData: macho.linkedit_data_command,
+ Symtab: macho.symtab_command,
+ Dysymtab: macho.dysymtab_command,
+
+ pub fn cmdsize(self: LoadCommand) u32 {
+ return switch (self) {
+ .Segment => |x| x.cmdsize,
+ .LinkeditData => |x| x.cmdsize,
+ .Symtab => |x| x.cmdsize,
+ .Dysymtab => |x| x.cmdsize,
+ };
+ }
+};
+
base: File,
-/// List of all load command headers that are in the file.
-/// We use it to track number and size of all commands needed by the header.
-commands: std.ArrayListUnmanaged(macho.load_command) = std.ArrayListUnmanaged(macho.load_command){},
-command_file_offset: ?u64 = null,
+/// Table of all load commands
+load_commands: std.ArrayListUnmanaged(LoadCommand) = .{},
+segment_cmd_index: ?u16 = null,
+symtab_cmd_index: ?u16 = null,
+dysymtab_cmd_index: ?u16 = null,
+data_in_code_cmd_index: ?u16 = null,
-/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
-/// Same order as in the file.
-segments: std.ArrayListUnmanaged(macho.segment_command_64) = std.ArrayListUnmanaged(macho.segment_command_64){},
-/// Section (headers) *always* follow segment (load commands) directly!
-sections: std.ArrayListUnmanaged(macho.section_64) = std.ArrayListUnmanaged(macho.section_64){},
+/// Table of all sections
+sections: std.ArrayListUnmanaged(macho.section_64) = .{},
-/// Offset (index) into __TEXT segment load command.
-text_segment_offset: ?u64 = null,
-/// Offset (index) into __LINKEDIT segment load command.
-linkedit_segment_offset: ?u664 = null,
+/// __TEXT segment sections
+text_section_index: ?u16 = null,
+cstring_section_index: ?u16 = null,
+const_text_section_index: ?u16 = null,
+stubs_section_index: ?u16 = null,
+stub_helper_section_index: ?u16 = null,
+
+/// __DATA segment sections
+got_section_index: ?u16 = null,
+const_data_section_index: ?u16 = null,
-/// Entry point load command
-entry_point_cmd: ?macho.entry_point_command = null,
entry_addr: ?u64 = null,
-/// The first 4GB of process' memory is reserved for the null (__PAGEZERO) segment.
-/// This is also the start address for our binary.
-vm_start_address: u64 = 0x100000000,
+/// Table of all symbols used.
+/// Internally references string table for names (which are optional).
+symbol_table: std.ArrayListUnmanaged(macho.nlist_64) = .{},
+
+/// Table of symbol names aka the string table.
+string_table: std.ArrayListUnmanaged(u8) = .{},
-seg_table_dirty: bool = false,
+/// Table of symbol vaddr values. The values is the absolute vaddr value.
+/// If the vaddr of the executable __TEXT segment vaddr changes, the entire offset
+/// table needs to be rewritten.
+offset_table: std.ArrayListUnmanaged(u64) = .{},
error_flags: File.ErrorFlags = File.ErrorFlags{},
+cmd_table_dirty: bool = false,
+
+/// Pointer to the last allocated text block
+last_text_block: ?*TextBlock = null,
+
/// `alloc_num / alloc_den` is the factor of padding when allocating.
const alloc_num = 4;
const alloc_den = 3;
@@ -67,7 +97,23 @@ const LIB_SYSTEM_NAME: [*:0]const u8 = "System";
const LIB_SYSTEM_PATH: [*:0]const u8 = DEFAULT_LIB_SEARCH_PATH ++ "/libSystem.B.dylib";
pub const TextBlock = struct {
- pub const empty = TextBlock{};
+ /// Index into the symbol table
+ symbol_table_index: ?u32,
+ /// Index into offset table
+ offset_table_index: ?u32,
+ /// Size of this text block
+ size: u64,
+ /// Points to the previous and next neighbours
+ prev: ?*TextBlock,
+ next: ?*TextBlock,
+
+ pub const empty = TextBlock{
+ .symbol_table_index = null,
+ .offset_table_index = null,
+ .size = 0,
+ .prev = null,
+ .next = null,
+ };
};
pub const SrcFn = struct {
@@ -117,6 +163,12 @@ fn openFile(allocator: *Allocator, file: fs.File, options: link.Options) !MachO
/// Truncates the existing file contents and overwrites the contents.
/// Returns an error if `file` is not already open with +read +write +seek abilities.
fn createFile(allocator: *Allocator, file: fs.File, options: link.Options) !MachO {
+ switch (options.output_mode) {
+ .Exe => {},
+ .Obj => {},
+ .Lib => return error.TODOImplementWritingLibFiles,
+ }
+
var self: MachO = .{
.base = .{
.file = file,
@@ -127,104 +179,15 @@ fn createFile(allocator: *Allocator, file: fs.File, options: link.Options) !Mach
};
errdefer self.deinit();
- switch (options.output_mode) {
- .Exe => {
- // The first segment command for executables is always a __PAGEZERO segment.
- const pagezero = .{
- .cmd = macho.LC_SEGMENT_64,
- .cmdsize = commandSize(@sizeOf(macho.segment_command_64)),
- .segname = makeString("__PAGEZERO"),
- .vmaddr = 0,
- .vmsize = self.vm_start_address,
- .fileoff = 0,
- .filesize = 0,
- .maxprot = macho.VM_PROT_NONE,
- .initprot = macho.VM_PROT_NONE,
- .nsects = 0,
- .flags = 0,
- };
- try self.commands.append(allocator, .{
- .cmd = pagezero.cmd,
- .cmdsize = pagezero.cmdsize,
- });
- try self.segments.append(allocator, pagezero);
- },
- .Obj => return error.TODOImplementWritingObjFiles,
- .Lib => return error.TODOImplementWritingLibFiles,
- }
-
try self.populateMissingMetadata();
return self;
}
-fn writeMachOHeader(self: *MachO) !void {
- var hdr: macho.mach_header_64 = undefined;
- hdr.magic = macho.MH_MAGIC_64;
-
- const CpuInfo = struct {
- cpu_type: macho.cpu_type_t,
- cpu_subtype: macho.cpu_subtype_t,
- };
-
- const cpu_info: CpuInfo = switch (self.base.options.target.cpu.arch) {
- .aarch64 => .{
- .cpu_type = macho.CPU_TYPE_ARM64,
- .cpu_subtype = macho.CPU_SUBTYPE_ARM_ALL,
- },
- .x86_64 => .{
- .cpu_type = macho.CPU_TYPE_X86_64,
- .cpu_subtype = macho.CPU_SUBTYPE_X86_64_ALL,
- },
- else => return error.UnsupportedMachOArchitecture,
- };
- hdr.cputype = cpu_info.cpu_type;
- hdr.cpusubtype = cpu_info.cpu_subtype;
-
- const filetype: u32 = switch (self.base.options.output_mode) {
- .Exe => macho.MH_EXECUTE,
- .Obj => macho.MH_OBJECT,
- .Lib => switch (self.base.options.link_mode) {
- .Static => return error.TODOStaticLibMachOType,
- .Dynamic => macho.MH_DYLIB,
- },
- };
- hdr.filetype = filetype;
-
- const ncmds = try math.cast(u32, self.commands.items.len);
- hdr.ncmds = ncmds;
-
- var sizeof_cmds: u32 = 0;
- for (self.commands.items) |cmd| {
- sizeof_cmds += cmd.cmdsize;
- }
- hdr.sizeofcmds = sizeof_cmds;
-
- // TODO should these be set to something else?
- hdr.flags = 0;
- hdr.reserved = 0;
-
- try self.base.file.?.pwriteAll(@ptrCast([*]const u8, &hdr)[0..@sizeOf(macho.mach_header_64)], 0);
-}
-
pub fn flush(self: *MachO, module: *Module) !void {
- // Save segments first
- {
- const buf = try self.base.allocator.alloc(macho.segment_command_64, self.segments.items.len);
- defer self.base.allocator.free(buf);
-
- self.command_file_offset = @sizeOf(macho.mach_header_64);
-
- for (buf) |*seg, i| {
- seg.* = self.segments.items[i];
- self.command_file_offset.? += self.segments.items[i].cmdsize;
- }
-
- try self.base.file.?.pwriteAll(mem.sliceAsBytes(buf), @sizeOf(macho.mach_header_64));
- }
-
switch (self.base.options.output_mode) {
.Exe => {
+ var last_cmd_offset: usize = @sizeOf(macho.mach_header_64);
{
// Specify path to dynamic linker dyld
const cmdsize = commandSize(@sizeOf(macho.dylinker_command) + mem.lenZ(DEFAULT_DYLD_PATH));
@@ -235,18 +198,14 @@ pub fn flush(self: *MachO, module: *Module) !void {
.name = @sizeOf(macho.dylinker_command),
},
};
- try self.commands.append(self.base.allocator, .{
- .cmd = macho.LC_LOAD_DYLINKER,
- .cmdsize = cmdsize,
- });
- try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylinker[0..1]), self.command_file_offset.?);
+ try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylinker[0..1]), last_cmd_offset);
- const file_offset = self.command_file_offset.? + @sizeOf(macho.dylinker_command);
+ const file_offset = last_cmd_offset + @sizeOf(macho.dylinker_command);
try self.addPadding(cmdsize - @sizeOf(macho.dylinker_command), file_offset);
try self.base.file.?.pwriteAll(mem.spanZ(DEFAULT_DYLD_PATH), file_offset);
- self.command_file_offset.? += cmdsize;
+ last_cmd_offset += cmdsize;
}
{
@@ -268,21 +227,44 @@ pub fn flush(self: *MachO, module: *Module) !void {
.dylib = dylib,
},
};
- try self.commands.append(self.base.allocator, .{
- .cmd = macho.LC_LOAD_DYLIB,
- .cmdsize = cmdsize,
- });
- try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylib[0..1]), self.command_file_offset.?);
+ try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylib[0..1]), last_cmd_offset);
- const file_offset = self.command_file_offset.? + @sizeOf(macho.dylib_command);
+ const file_offset = last_cmd_offset + @sizeOf(macho.dylib_command);
try self.addPadding(cmdsize - @sizeOf(macho.dylib_command), file_offset);
try self.base.file.?.pwriteAll(mem.spanZ(LIB_SYSTEM_PATH), file_offset);
- self.command_file_offset.? += cmdsize;
+ last_cmd_offset += cmdsize;
}
},
- .Obj => return error.TODOImplementWritingObjFiles,
+ .Obj => {
+ {
+ const symtab = &self.load_commands.items[self.symtab_cmd_index.?].Symtab;
+ symtab.nsyms = @intCast(u32, self.symbol_table.items.len);
+ const allocated_size = self.allocatedSize(symtab.stroff);
+ const needed_size = self.string_table.items.len;
+ log.debug("allocated_size = 0x{x}, needed_size = 0x{x}\n", .{ allocated_size, needed_size });
+
+ if (needed_size > allocated_size) {
+ symtab.strsize = 0;
+ symtab.stroff = @intCast(u32, self.findFreeSpace(needed_size, 1));
+ }
+ symtab.strsize = @intCast(u32, needed_size);
+
+ log.debug("writing string table from 0x{x} to 0x{x}\n", .{ symtab.stroff, symtab.stroff + symtab.strsize });
+
+ try self.base.file.?.pwriteAll(self.string_table.items, symtab.stroff);
+ }
+
+ var last_cmd_offset: usize = @sizeOf(macho.mach_header_64);
+ for (self.load_commands.items) |cmd| {
+ const cmd_to_write = [1]@TypeOf(cmd){cmd};
+ try self.base.file.?.pwriteAll(mem.sliceAsBytes(cmd_to_write[0..1]), last_cmd_offset);
+ last_cmd_offset += cmd.cmdsize();
+ }
+ const off = @sizeOf(macho.mach_header_64) + @sizeOf(macho.segment_command_64);
+ try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.sections.items), off);
+ },
.Lib => return error.TODOImplementWritingLibFiles,
}
@@ -297,14 +279,110 @@ pub fn flush(self: *MachO, module: *Module) !void {
}
pub fn deinit(self: *MachO) void {
- self.commands.deinit(self.base.allocator);
- self.segments.deinit(self.base.allocator);
+ self.offset_table.deinit(self.base.allocator);
+ self.string_table.deinit(self.base.allocator);
+ self.symbol_table.deinit(self.base.allocator);
self.sections.deinit(self.base.allocator);
+ self.load_commands.deinit(self.base.allocator);
+}
+
+pub fn allocateDeclIndexes(self: *MachO, decl: *Module.Decl) !void {
+ if (decl.link.macho.symbol_table_index) |_| return;
+
+ try self.symbol_table.ensureCapacity(self.base.allocator, self.symbol_table.items.len + 1);
+ try self.offset_table.ensureCapacity(self.base.allocator, self.offset_table.items.len + 1);
+
+ log.debug("allocating symbol index {} for {}\n", .{ self.symbol_table.items.len, decl.name });
+ decl.link.macho.symbol_table_index = @intCast(u32, self.symbol_table.items.len);
+ _ = self.symbol_table.addOneAssumeCapacity();
+
+ decl.link.macho.offset_table_index = @intCast(u32, self.offset_table.items.len);
+ _ = self.offset_table.addOneAssumeCapacity();
+
+ self.symbol_table.items[decl.link.macho.symbol_table_index.?] = .{
+ .n_strx = 0,
+ .n_type = 0,
+ .n_sect = 0,
+ .n_desc = 0,
+ .n_value = 0,
+ };
+ self.offset_table.items[decl.link.macho.offset_table_index.?] = 0;
}
-pub fn allocateDeclIndexes(self: *MachO, decl: *Module.Decl) !void {}
+pub fn updateDecl(self: *MachO, module: *Module, decl: *Module.Decl) !void {
+ const tracy = trace(@src());
+ defer tracy.end();
+
+ var code_buffer = std.ArrayList(u8).init(self.base.allocator);
+ defer code_buffer.deinit();
-pub fn updateDecl(self: *MachO, module: *Module, decl: *Module.Decl) !void {}
+ var dbg_line_buffer = std.ArrayList(u8).init(self.base.allocator);
+ defer dbg_line_buffer.deinit();
+
+ var dbg_info_buffer = std.ArrayList(u8).init(self.base.allocator);
+ defer dbg_info_buffer.deinit();
+
+ var dbg_info_type_relocs: File.DbgInfoTypeRelocsTable = .{};
+ defer {
+ var it = dbg_info_type_relocs.iterator();
+ while (it.next()) |entry| {
+ entry.value.relocs.deinit(self.base.allocator);
+ }
+ dbg_info_type_relocs.deinit(self.base.allocator);
+ }
+
+ const typed_value = decl.typed_value.most_recent.typed_value;
+ const res = try codegen.generateSymbol(
+ &self.base,
+ decl.src(),
+ typed_value,
+ &code_buffer,
+ &dbg_line_buffer,
+ &dbg_info_buffer,
+ &dbg_info_type_relocs,
+ );
+
+ const code = switch (res) {
+ .externally_managed => |x| x,
+ .appended => code_buffer.items,
+ .fail => |em| {
+ decl.analysis = .codegen_failure;
+ try module.failed_decls.put(module.gpa, decl, em);
+ return;
+ },
+ };
+ log.debug("generated code {}\n", .{code});
+
+ const required_alignment = typed_value.ty.abiAlignment(self.base.options.target);
+ const symbol = &self.symbol_table.items[decl.link.macho.symbol_table_index.?];
+
+ const decl_name = mem.spanZ(decl.name);
+ const name_str_index = try self.makeString(decl_name);
+ const addr = try self.allocateTextBlock(&decl.link.macho, code.len, required_alignment);
+ log.debug("allocated text block for {} at 0x{x}\n", .{ decl_name, addr });
+ log.debug("updated text section {}\n", .{self.sections.items[self.text_section_index.?]});
+
+ symbol.* = .{
+ .n_strx = name_str_index,
+ .n_type = macho.N_SECT,
+ .n_sect = @intCast(u8, self.text_section_index.?) + 1,
+ .n_desc = 0,
+ .n_value = addr,
+ };
+ self.offset_table.items[decl.link.macho.offset_table_index.?] = addr;
+
+ try self.writeSymbol(decl.link.macho.symbol_table_index.?);
+
+ const text_section = self.sections.items[self.text_section_index.?];
+ const section_offset = symbol.n_value - text_section.addr;
+ const file_offset = text_section.offset + section_offset;
+ log.debug("file_offset 0x{x}\n", .{file_offset});
+ try self.base.file.?.pwriteAll(code, file_offset);
+
+ // Since we updated the vaddr and the size, each corresponding export symbol also needs to be updated.
+ const decl_exports = module.decl_exports.get(decl) orelse &[0]*Module.Export{};
+ return self.updateDeclExports(module, decl, decl_exports);
+}
pub fn updateDeclLineNumber(self: *MachO, module: *Module, decl: *const Module.Decl) !void {}
@@ -313,51 +391,191 @@ pub fn updateDeclExports(
module: *Module,
decl: *const Module.Decl,
exports: []const *Module.Export,
-) !void {}
+) !void {
+ const tracy = trace(@src());
+ defer tracy.end();
+
+ if (decl.link.macho.symbol_table_index == null) return;
+
+ var decl_sym = self.symbol_table.items[decl.link.macho.symbol_table_index.?];
+ // TODO implement
+ if (exports.len == 0) return;
+
+ const exp = exports[0];
+ self.entry_addr = decl_sym.n_value;
+ decl_sym.n_type |= macho.N_EXT;
+ exp.link.sym_index = 0;
+}
pub fn freeDecl(self: *MachO, decl: *Module.Decl) void {}
pub fn getDeclVAddr(self: *MachO, decl: *const Module.Decl) u64 {
- @panic("TODO implement getDeclVAddr for MachO");
+ return self.symbol_table.items[decl.link.macho.symbol_table_index.?].n_value;
}
pub fn populateMissingMetadata(self: *MachO) !void {
- if (self.text_segment_offset == null) {
- self.text_segment_offset = @intCast(u64, self.segments.items.len);
- const file_size = alignSize(u64, self.base.options.program_code_size_hint, 0x1000);
- log.debug("vmsize/filesize = {}", .{file_size});
- const file_offset = 0;
- const vm_address = self.vm_start_address; // the end of __PAGEZERO segment in VM
- const protection = macho.VM_PROT_READ | macho.VM_PROT_EXECUTE;
- const cmdsize = commandSize(@sizeOf(macho.segment_command_64));
- const text_segment = .{
- .cmd = macho.LC_SEGMENT_64,
- .cmdsize = cmdsize,
- .segname = makeString("__TEXT"),
- .vmaddr = vm_address,
- .vmsize = file_size,
- .fileoff = 0, // __TEXT segment *always* starts at 0 file offset
- .filesize = 0, //file_size,
- .maxprot = protection,
- .initprot = protection,
- .nsects = 0,
- .flags = 0,
- };
- try self.commands.append(self.base.allocator, .{
- .cmd = macho.LC_SEGMENT_64,
- .cmdsize = cmdsize,
+ if (self.segment_cmd_index == null) {
+ self.segment_cmd_index = @intCast(u16, self.load_commands.items.len);
+ try self.load_commands.append(self.base.allocator, .{
+ .Segment = .{
+ .cmd = macho.LC_SEGMENT_64,
+ .cmdsize = @sizeOf(macho.segment_command_64),
+ .segname = makeStaticString(""),
+ .vmaddr = 0,
+ .vmsize = 0,
+ .fileoff = 0,
+ .filesize = 0,
+ .maxprot = 0,
+ .initprot = 0,
+ .nsects = 0,
+ .flags = 0,
+ },
+ });
+ self.cmd_table_dirty = true;
+ }
+ if (self.symtab_cmd_index == null) {
+ self.symtab_cmd_index = @intCast(u16, self.load_commands.items.len);
+ try self.load_commands.append(self.base.allocator, .{
+ .Symtab = .{
+ .cmd = macho.LC_SYMTAB,
+ .cmdsize = @sizeOf(macho.symtab_command),
+ .symoff = 0,
+ .nsyms = 0,
+ .stroff = 0,
+ .strsize = 0,
+ },
});
- try self.segments.append(self.base.allocator, text_segment);
+ self.cmd_table_dirty = true;
+ }
+ if (self.text_section_index == null) {
+ self.text_section_index = @intCast(u16, self.sections.items.len);
+ const segment = &self.load_commands.items[self.segment_cmd_index.?].Segment;
+ segment.cmdsize += @sizeOf(macho.section_64);
+ segment.nsects += 1;
+
+ const file_size = self.base.options.program_code_size_hint;
+ const off = @intCast(u32, self.findFreeSpace(file_size, 1));
+ const flags = macho.S_REGULAR | macho.S_ATTR_PURE_INSTRUCTIONS | macho.S_ATTR_SOME_INSTRUCTIONS;
+
+ log.debug("found __text section free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+
+ try self.sections.append(self.base.allocator, .{
+ .sectname = makeStaticString("__text"),
+ .segname = makeStaticString("__TEXT"),
+ .addr = 0,
+ .size = file_size,
+ .offset = off,
+ .@"align" = 0x1000,
+ .reloff = 0,
+ .nreloc = 0,
+ .flags = flags,
+ .reserved1 = 0,
+ .reserved2 = 0,
+ .reserved3 = 0,
+ });
+
+ segment.vmsize += file_size;
+ segment.filesize += file_size;
+ segment.fileoff = off;
+
+ log.debug("initial text section {}\n", .{self.sections.items[self.text_section_index.?]});
+ }
+ {
+ const symtab = &self.load_commands.items[self.symtab_cmd_index.?].Symtab;
+ if (symtab.symoff == 0) {
+ const p_align = @sizeOf(macho.nlist_64);
+ const nsyms = self.base.options.symbol_count_hint;
+ const file_size = p_align * nsyms;
+ const off = @intCast(u32, self.findFreeSpace(file_size, p_align));
+ log.debug("found symbol table free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ symtab.symoff = off;
+ symtab.nsyms = @intCast(u32, nsyms);
+ }
+ if (symtab.stroff == 0) {
+ try self.string_table.append(self.base.allocator, 0);
+ const file_size = @intCast(u32, self.string_table.items.len);
+ const off = @intCast(u32, self.findFreeSpace(file_size, 1));
+ log.debug("found string table free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ symtab.stroff = off;
+ symtab.strsize = file_size;
+ }
}
}
-fn makeString(comptime bytes: []const u8) [16]u8 {
+fn allocateTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
+ const segment = &self.load_commands.items[self.segment_cmd_index.?].Segment;
+ const text_section = &self.sections.items[self.text_section_index.?];
+ const new_block_ideal_capacity = new_block_size * alloc_num / alloc_den;
+
+ var block_placement: ?*TextBlock = null;
+ const addr = blk: {
+ if (self.last_text_block) |last| {
+ const last_symbol = self.symbol_table.items[last.symbol_table_index.?];
+ const ideal_capacity = last.size * alloc_num / alloc_den;
+ const ideal_capacity_end_addr = last_symbol.n_value + ideal_capacity;
+ const new_start_addr = mem.alignForwardGeneric(u64, ideal_capacity_end_addr, alignment);
+ block_placement = last;
+ break :blk new_start_addr;
+ } else {
+ break :blk text_section.addr;
+ }
+ };
+ log.debug("computed symbol address 0x{x}\n", .{addr});
+
+ const expand_text_section = block_placement == null or block_placement.?.next == null;
+ if (expand_text_section) {
+ const text_capacity = self.allocatedSize(text_section.offset);
+ const needed_size = (addr + new_block_size) - text_section.addr;
+ log.debug("text capacity 0x{x}, needed size 0x{x}\n", .{ text_capacity, needed_size });
+
+ if (needed_size > text_capacity) {
+ // TODO handle growth
+ }
+
+ self.last_text_block = text_block;
+ text_section.size = needed_size;
+ segment.vmsize = needed_size;
+ segment.filesize = needed_size;
+ if (alignment < text_section.@"align") {
+ text_section.@"align" = @intCast(u32, alignment);
+ }
+ }
+ text_block.size = new_block_size;
+
+ if (text_block.prev) |prev| {
+ prev.next = text_block.next;
+ }
+ if (text_block.next) |next| {
+ next.prev = text_block.prev;
+ }
+
+ if (block_placement) |big_block| {
+ text_block.prev = big_block;
+ text_block.next = big_block.next;
+ big_block.next = text_block;
+ } else {
+ text_block.prev = null;
+ text_block.next = null;
+ }
+
+ return addr;
+}
+
+fn makeStaticString(comptime bytes: []const u8) [16]u8 {
var buf = [_]u8{0} ** 16;
- if (bytes.len > buf.len) @compileError("MachO segment/section name too long");
+ if (bytes.len > buf.len) @compileError("string too long; max 16 bytes");
mem.copy(u8, buf[0..], bytes);
return buf;
}
+fn makeString(self: *MachO, bytes: []const u8) !u32 {
+ try self.string_table.ensureCapacity(self.base.allocator, self.string_table.items.len + bytes.len + 1);
+ const result = self.string_table.items.len;
+ self.string_table.appendSliceAssumeCapacity(bytes);
+ self.string_table.appendAssumeCapacity(0);
+ return @intCast(u32, result);
+}
+
fn alignSize(comptime Int: type, min_size: anytype, alignment: Int) Int {
const size = @intCast(Int, min_size);
if (size % alignment == 0) return size;
@@ -370,7 +588,7 @@ fn commandSize(min_size: anytype) u32 {
return alignSize(u32, min_size, @sizeOf(u64));
}
-fn addPadding(self: *MachO, size: u32, file_offset: u64) !void {
+fn addPadding(self: *MachO, size: u64, file_offset: u64) !void {
if (size == 0) return;
const buf = try self.base.allocator.alloc(u8, size);
@@ -380,3 +598,151 @@ fn addPadding(self: *MachO, size: u32, file_offset: u64) !void {
try self.base.file.?.pwriteAll(buf, file_offset);
}
+
+fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 {
+ const hdr_size: u64 = @sizeOf(macho.mach_header_64);
+ if (start < hdr_size)
+ return hdr_size;
+
+ const end = start + satMul(size, alloc_num) / alloc_den;
+
+ {
+ const off = @sizeOf(macho.mach_header_64);
+ var tight_size: u64 = 0;
+ for (self.load_commands.items) |cmd| {
+ tight_size += cmd.cmdsize();
+ }
+ const increased_size = satMul(tight_size, alloc_num) / alloc_den;
+ const test_end = off + increased_size;
+ if (end > off and start < test_end) {
+ return test_end;
+ }
+ }
+
+ for (self.sections.items) |section| {
+ const increased_size = satMul(section.size, alloc_num) / alloc_den;
+ const test_end = section.offset + increased_size;
+ if (end > section.offset and start < test_end) {
+ return test_end;
+ }
+ }
+
+ if (self.symtab_cmd_index) |symtab_index| {
+ const symtab = self.load_commands.items[symtab_index].Symtab;
+ {
+ const tight_size = @sizeOf(macho.nlist_64) * symtab.nsyms;
+ const increased_size = satMul(tight_size, alloc_num) / alloc_den;
+ const test_end = symtab.symoff + increased_size;
+ if (end > symtab.symoff and start < test_end) {
+ return test_end;
+ }
+ }
+ {
+ const increased_size = satMul(symtab.strsize, alloc_num) / alloc_den;
+ const test_end = symtab.stroff + increased_size;
+ if (end > symtab.stroff and start < test_end) {
+ return test_end;
+ }
+ }
+ }
+
+ return null;
+}
+
+fn allocatedSize(self: *MachO, start: u64) u64 {
+ if (start == 0)
+ return 0;
+ var min_pos: u64 = std.math.maxInt(u64);
+ {
+ const off = @sizeOf(macho.mach_header_64);
+ if (off > start and off < min_pos) min_pos = off;
+ }
+ for (self.sections.items) |section| {
+ if (section.offset <= start) continue;
+ if (section.offset < min_pos) min_pos = section.offset;
+ }
+ if (self.symtab_cmd_index) |symtab_index| {
+ const symtab = self.load_commands.items[symtab_index].Symtab;
+ if (symtab.symoff > start and symtab.symoff < min_pos) min_pos = symtab.symoff;
+ if (symtab.stroff > start and symtab.stroff < min_pos) min_pos = symtab.stroff;
+ }
+ return min_pos - start;
+}
+
+fn findFreeSpace(self: *MachO, object_size: u64, min_alignment: u16) u64 {
+ var start: u64 = 0;
+ while (self.detectAllocCollision(start, object_size)) |item_end| {
+ start = mem.alignForwardGeneric(u64, item_end, min_alignment);
+ }
+ return start;
+}
+
+fn writeSymbol(self: *MachO, index: usize) !void {
+ const tracy = trace(@src());
+ defer tracy.end();
+
+ const symtab = &self.load_commands.items[self.symtab_cmd_index.?].Symtab;
+ var sym = [1]macho.nlist_64{self.symbol_table.items[index]};
+ const off = symtab.symoff + @sizeOf(macho.nlist_64) * index;
+ log.debug("writing symbol {} at 0x{x}\n", .{ sym[0], off });
+ try self.base.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
+}
+
+/// Writes Mach-O file header.
+/// Should be invoked last as it needs up-to-date values of ncmds and sizeof_cmds bookkeeping
+/// variables.
+fn writeMachOHeader(self: *MachO) !void {
+ var hdr: macho.mach_header_64 = undefined;
+ hdr.magic = macho.MH_MAGIC_64;
+
+ const CpuInfo = struct {
+ cpu_type: macho.cpu_type_t,
+ cpu_subtype: macho.cpu_subtype_t,
+ };
+
+ const cpu_info: CpuInfo = switch (self.base.options.target.cpu.arch) {
+ .aarch64 => .{
+ .cpu_type = macho.CPU_TYPE_ARM64,
+ .cpu_subtype = macho.CPU_SUBTYPE_ARM_ALL,
+ },
+ .x86_64 => .{
+ .cpu_type = macho.CPU_TYPE_X86_64,
+ .cpu_subtype = macho.CPU_SUBTYPE_X86_64_ALL,
+ },
+ else => return error.UnsupportedMachOArchitecture,
+ };
+ hdr.cputype = cpu_info.cpu_type;
+ hdr.cpusubtype = cpu_info.cpu_subtype;
+
+ const filetype: u32 = switch (self.base.options.output_mode) {
+ .Exe => macho.MH_EXECUTE,
+ .Obj => macho.MH_OBJECT,
+ .Lib => switch (self.base.options.link_mode) {
+ .Static => return error.TODOStaticLibMachOType,
+ .Dynamic => macho.MH_DYLIB,
+ },
+ };
+ hdr.filetype = filetype;
+ hdr.ncmds = @intCast(u32, self.load_commands.items.len);
+
+ var sizeofcmds: u32 = 0;
+ for (self.load_commands.items) |cmd| {
+ sizeofcmds += cmd.cmdsize();
+ }
+
+ hdr.sizeofcmds = sizeofcmds;
+
+ // TODO should these be set to something else?
+ hdr.flags = 0;
+ hdr.reserved = 0;
+
+ log.debug("writing Mach-O header {}\n", .{hdr});
+
+ try self.base.file.?.pwriteAll(@ptrCast([*]const u8, &hdr)[0..@sizeOf(macho.mach_header_64)], 0);
+}
+
+/// Saturating multiplication
+fn satMul(a: anytype, b: anytype) @TypeOf(a, b) {
+ const T = @TypeOf(a, b);
+ return std.math.mul(T, a, b) catch std.math.maxInt(T);
+}
src-self-hosted/codegen.zig
@@ -1443,7 +1443,57 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
}
} else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
switch (arch) {
- .x86_64 => return self.fail(inst.base.src, "TODO implement codegen for call when linking with MachO for x86_64 arch", .{}),
+ .x86_64 => {
+ for (info.args) |mc_arg, arg_i| {
+ const arg = inst.args[arg_i];
+ const arg_mcv = try self.resolveInst(inst.args[arg_i]);
+ // Here we do not use setRegOrMem even though the logic is similar, because
+ // the function call will move the stack pointer, so the offsets are different.
+ switch (mc_arg) {
+ .none => continue,
+ .register => |reg| {
+ try self.genSetReg(arg.src, reg, arg_mcv);
+ // TODO interact with the register allocator to mark the instruction as moved.
+ },
+ .stack_offset => {
+ // Here we need to emit instructions like this:
+ // mov qword ptr [rsp + stack_offset], x
+ return self.fail(inst.base.src, "TODO implement calling with parameters in memory", .{});
+ },
+ .ptr_stack_offset => {
+ return self.fail(inst.base.src, "TODO implement calling with MCValue.ptr_stack_offset arg", .{});
+ },
+ .ptr_embedded_in_code => {
+ return self.fail(inst.base.src, "TODO implement calling with MCValue.ptr_embedded_in_code arg", .{});
+ },
+ .undef => unreachable,
+ .immediate => unreachable,
+ .unreach => unreachable,
+ .dead => unreachable,
+ .embedded_in_code => unreachable,
+ .memory => unreachable,
+ .compare_flags_signed => unreachable,
+ .compare_flags_unsigned => unreachable,
+ }
+ }
+
+ if (inst.func.cast(ir.Inst.Constant)) |func_inst| {
+ if (func_inst.val.cast(Value.Payload.Function)) |func_val| {
+ const func = func_val.func;
+ const got = &macho_file.sections.items[macho_file.got_section_index.?];
+ const ptr_bytes = 8;
+ const got_addr = @intCast(u32, got.addr + func.owner_decl.link.macho.offset_table_index.? * ptr_bytes);
+ // ff 14 25 xx xx xx xx call [addr]
+ try self.code.ensureCapacity(self.code.items.len + 7);
+ self.code.appendSliceAssumeCapacity(&[3]u8{ 0xff, 0x14, 0x25 });
+ mem.writeIntLittle(u32, self.code.addManyAsArrayAssumeCapacity(4), got_addr);
+ } else {
+ return self.fail(inst.base.src, "TODO implement calling bitcasted functions", .{});
+ }
+ } else {
+ return self.fail(inst.base.src, "TODO implement calling runtime known function pointer", .{});
+ }
+ },
.aarch64 => return self.fail(inst.base.src, "TODO implement codegen for call when linking with MachO for aarch64 arch", .{}),
else => unreachable,
}
@@ -2486,6 +2536,11 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
const got_addr = got.p_vaddr + decl.link.elf.offset_table_index * ptr_bytes;
return MCValue{ .memory = got_addr };
+ } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
+ const decl = payload.decl;
+ const got = &macho_file.sections.items[macho_file.got_section_index.?];
+ const got_addr = got.addr + decl.link.macho.offset_table_index.? * ptr_bytes;
+ return MCValue{ .memory = got_addr };
} else {
return self.fail(src, "TODO codegen non-ELF const Decl pointer", .{});
}