Merge pull request #5158 from ziglang/zir-to-elf

beginnings of (non-LLVM) self-hosted machine code generation and linking

1 files changed, 748 insertions, 500 deletions

diff --git a/src-self-hosted/link.zig b/src-self-hosted/link.zig
index 013a6248cc..cb6aa40afe 100644
--- a/src-self-hosted/link.zig
+++ b/src-self-hosted/link.zig
@@ -1,576 +1,824 @@
 const std = @import("std");
 const mem = std.mem;
-const c = @import("c.zig");
-const Compilation = @import("compilation.zig").Compilation;
-const Target = std.Target;
-const ObjectFormat = Target.ObjectFormat;
-const LibCInstallation = @import("libc_installation.zig").LibCInstallation;
 const assert = std.debug.assert;
-const util = @import("util.zig");
-
-const Context = struct {
-    comp: *Compilation,
-    arena: std.heap.ArenaAllocator,
-    args: std.ArrayList([*:0]const u8),
-    link_in_crt: bool,
+const Allocator = std.mem.Allocator;
+const ir = @import("ir.zig");
+const fs = std.fs;
+const elf = std.elf;
+const codegen = @import("codegen.zig");
+
+/// On common systems with a 0o022 umask, 0o777 will still result in a file created
+/// with 0o755 permissions, but it works appropriately if the system is configured
+/// more leniently. As another data point, C's fopen seems to open files with the
+/// 666 mode.
+const executable_mode = 0o777;
+const default_entry_addr = 0x8000000;
+
+pub const ErrorMsg = struct {
+    byte_offset: usize,
+    msg: []const u8,
+};
 
-    link_err: error{OutOfMemory}!void,
-    link_msg: std.ArrayListSentineled(u8, 0),
+pub const Result = struct {
+    errors: []ErrorMsg,
 
-    libc: *LibCInstallation,
-    out_file_path: std.ArrayListSentineled(u8, 0),
+    pub fn deinit(self: *Result, allocator: *mem.Allocator) void {
+        for (self.errors) |err| {
+            allocator.free(err.msg);
+        }
+        allocator.free(self.errors);
+        self.* = undefined;
+    }
 };
 
-pub fn link(comp: *Compilation) !void {
-    var ctx = Context{
-        .comp = comp,
-        .arena = std.heap.ArenaAllocator.init(comp.gpa()),
-        .args = undefined,
-        .link_in_crt = comp.haveLibC() and comp.kind == .Exe,
-        .link_err = {},
-        .link_msg = undefined,
-        .libc = undefined,
-        .out_file_path = undefined,
-    };
-    defer ctx.arena.deinit();
-    ctx.args = std.ArrayList([*:0]const u8).init(&ctx.arena.allocator);
-    ctx.link_msg = std.ArrayListSentineled(u8, 0).initNull(&ctx.arena.allocator);
-
-    ctx.out_file_path = try std.ArrayListSentineled(u8, 0).init(&ctx.arena.allocator, comp.name.span());
-    switch (comp.kind) {
-        .Exe => {
-            try ctx.out_file_path.append(comp.target.exeFileExt());
-        },
-        .Lib => {
-            try ctx.out_file_path.append(if (comp.is_static) comp.target.staticLibSuffix() else comp.target.dynamicLibSuffix());
-        },
-        .Obj => {
-            try ctx.out_file_path.append(comp.target.oFileExt());
+/// Attempts incremental linking, if the file already exists.
+/// If incremental linking fails, falls back to truncating the file and rewriting it.
+/// A malicious file is detected as incremental link failure and does not cause Illegal Behavior.
+/// This operation is not atomic.
+pub fn updateExecutableFilePath(
+    allocator: *Allocator,
+    module: ir.Module,
+    dir: fs.Dir,
+    sub_path: []const u8,
+) !Result {
+    const file = try dir.createFile(sub_path, .{ .truncate = false, .read = true, .mode = executable_mode });
+    defer file.close();
+
+    return updateExecutableFile(allocator, module, file);
+}
+
+/// Atomically overwrites the old file, if present.
+pub fn writeExecutableFilePath(
+    allocator: *Allocator,
+    module: ir.Module,
+    dir: fs.Dir,
+    sub_path: []const u8,
+) !Result {
+    const af = try dir.atomicFile(sub_path, .{ .mode = executable_mode });
+    defer af.deinit();
+
+    const result = try writeExecutableFile(allocator, module, af.file);
+    try af.finish();
+    return result;
+}
+
+/// Attempts incremental linking, if the file already exists.
+/// If incremental linking fails, falls back to truncating the file and rewriting it.
+/// Returns an error if `file` is not already open with +read +write +seek abilities.
+/// A malicious file is detected as incremental link failure and does not cause Illegal Behavior.
+/// This operation is not atomic.
+pub fn updateExecutableFile(allocator: *Allocator, module: ir.Module, file: fs.File) !Result {
+    return updateExecutableFileInner(allocator, module, file) catch |err| switch (err) {
+        error.IncrFailed => {
+            return writeExecutableFile(allocator, module, file);
         },
-    }
+        else => |e| return e,
+    };
+}
 
-    // even though we're calling LLD as a library it thinks the first
-    // argument is its own exe name
-    try ctx.args.append("lld");
-
-    if (comp.haveLibC()) {
-        // TODO https://github.com/ziglang/zig/issues/3190
-        var libc = ctx.comp.override_libc orelse blk: {
-            @panic("this code has bitrotted");
-            //switch (comp.target) {
-            //    Target.Native => {
-            //        break :blk comp.zig_compiler.getNativeLibC() catch return error.LibCRequiredButNotProvidedOrFound;
-            //    },
-            //    else => return error.LibCRequiredButNotProvidedOrFound,
-            //}
-        };
-        ctx.libc = libc;
-    }
+const Update = struct {
+    file: fs.File,
+    module: *const ir.Module,
 
-    try constructLinkerArgs(&ctx);
+    /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
+    /// Same order as in the file.
+    sections: std.ArrayList(elf.Elf64_Shdr),
+    shdr_table_offset: ?u64,
 
-    if (comp.verbose_link) {
-        for (ctx.args.span()) |arg, i| {
-            const space = if (i == 0) "" else " ";
-            std.debug.warn("{}{s}", .{ space, arg });
-        }
-        std.debug.warn("\n", .{});
+    /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
+    /// Same order as in the file.
+    program_headers: std.ArrayList(elf.Elf64_Phdr),
+    phdr_table_offset: ?u64,
+    /// The index into the program headers of a PT_LOAD program header with Read and Execute flags
+    phdr_load_re_index: ?u16,
+    entry_addr: ?u64,
+
+    shstrtab: std.ArrayList(u8),
+    shstrtab_index: ?u16,
+
+    text_section_index: ?u16,
+    symtab_section_index: ?u16,
+
+    /// The same order as in the file
+    symbols: std.ArrayList(elf.Elf64_Sym),
+
+    errors: std.ArrayList(ErrorMsg),
+
+    fn deinit(self: *Update) void {
+        self.sections.deinit();
+        self.program_headers.deinit();
+        self.shstrtab.deinit();
+        self.symbols.deinit();
+        self.errors.deinit();
     }
 
-    const extern_ofmt = toExternObjectFormatType(comp.target.getObjectFormat());
-    const args_slice = ctx.args.span();
-
-    {
-        // LLD is not thread-safe, so we grab a global lock.
-        const held = comp.zig_compiler.lld_lock.acquire();
-        defer held.release();
-
-        // Not evented I/O. LLD does its own multithreading internally.
-        if (!ZigLLDLink(extern_ofmt, args_slice.ptr, args_slice.len, linkDiagCallback, @ptrCast(*c_void, &ctx))) {
-            if (!ctx.link_msg.isNull()) {
-                // TODO capture these messages and pass them through the system, reporting them through the
-                // event system instead of printing them directly here.
-                // perhaps try to parse and understand them.
-                std.debug.warn("{}\n", .{ctx.link_msg.span()});
+    // `expand_num / expand_den` is the factor of padding when allocation
+    const alloc_num = 4;
+    const alloc_den = 3;
+
+    /// Returns end pos of collision, if any.
+    fn detectAllocCollision(self: *Update, start: u64, size: u64) ?u64 {
+        const small_ptr = self.module.target.cpu.arch.ptrBitWidth() == 32;
+        const ehdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Ehdr) else @sizeOf(elf.Elf64_Ehdr);
+        if (start < ehdr_size)
+            return ehdr_size;
+
+        const end = start + satMul(size, alloc_num) / alloc_den;
+
+        if (self.shdr_table_offset) |off| {
+            const shdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Shdr) else @sizeOf(elf.Elf64_Shdr);
+            const tight_size = self.sections.items.len * shdr_size;
+            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;
             }
-            return error.LinkFailed;
         }
-    }
-}
 
-extern fn ZigLLDLink(
-    oformat: c.ZigLLVM_ObjectFormatType,
-    args: [*]const [*]const u8,
-    arg_count: usize,
-    append_diagnostic: extern fn (*c_void, [*]const u8, usize) void,
-    context: *c_void,
-) bool;
-
-fn linkDiagCallback(context: *c_void, ptr: [*]const u8, len: usize) callconv(.C) void {
-    const ctx = @ptrCast(*Context, @alignCast(@alignOf(Context), context));
-    ctx.link_err = linkDiagCallbackErrorable(ctx, ptr[0..len]);
-}
+        if (self.phdr_table_offset) |off| {
+            const phdr_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Phdr) else @sizeOf(elf.Elf64_Phdr);
+            const tight_size = self.sections.items.len * phdr_size;
+            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;
+            }
+        }
 
-fn linkDiagCallbackErrorable(ctx: *Context, msg: []const u8) !void {
-    if (ctx.link_msg.isNull()) {
-        try ctx.link_msg.resize(0);
+        for (self.sections.items) |section| {
+            const increased_size = satMul(section.sh_size, alloc_num) / alloc_den;
+            const test_end = section.sh_offset + increased_size;
+            if (end > section.sh_offset and start < test_end) {
+                return test_end;
+            }
+        }
+        for (self.program_headers.items) |program_header| {
+            const increased_size = satMul(program_header.p_filesz, alloc_num) / alloc_den;
+            const test_end = program_header.p_offset + increased_size;
+            if (end > program_header.p_offset and start < test_end) {
+                return test_end;
+            }
+        }
+        return null;
     }
-    try ctx.link_msg.append(msg);
-}
 
-fn toExternObjectFormatType(ofmt: ObjectFormat) c.ZigLLVM_ObjectFormatType {
-    return switch (ofmt) {
-        .unknown => .ZigLLVM_UnknownObjectFormat,
-        .coff => .ZigLLVM_COFF,
-        .elf => .ZigLLVM_ELF,
-        .macho => .ZigLLVM_MachO,
-        .wasm => .ZigLLVM_Wasm,
-    };
-}
-
-fn constructLinkerArgs(ctx: *Context) !void {
-    switch (ctx.comp.target.getObjectFormat()) {
-        .unknown => unreachable,
-        .coff => return constructLinkerArgsCoff(ctx),
-        .elf => return constructLinkerArgsElf(ctx),
-        .macho => return constructLinkerArgsMachO(ctx),
-        .wasm => return constructLinkerArgsWasm(ctx),
+    fn allocatedSize(self: *Update, start: u64) u64 {
+        var min_pos: u64 = std.math.maxInt(u64);
+        if (self.shdr_table_offset) |off| {
+            if (off > start and off < min_pos) min_pos = off;
+        }
+        if (self.phdr_table_offset) |off| {
+            if (off > start and off < min_pos) min_pos = off;
+        }
+        for (self.sections.items) |section| {
+            if (section.sh_offset <= start) continue;
+            if (section.sh_offset < min_pos) min_pos = section.sh_offset;
+        }
+        for (self.program_headers.items) |program_header| {
+            if (program_header.p_offset <= start) continue;
+            if (program_header.p_offset < min_pos) min_pos = program_header.p_offset;
+        }
+        return min_pos - start;
     }
-}
 
-fn constructLinkerArgsElf(ctx: *Context) !void {
-    // TODO commented out code in this function
-    //if (g->linker_script) {
-    //    lj->args.append("-T");
-    //    lj->args.append(g->linker_script);
-    //}
-    try ctx.args.append("--gc-sections");
-    if (ctx.comp.link_eh_frame_hdr) {
-        try ctx.args.append("--eh-frame-hdr");
+    fn findFreeSpace(self: *Update, 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;
     }
 
-    //lj->args.append("-m");
-    //lj->args.append(getLDMOption(&g->zig_target));
-
-    //bool is_lib = g->out_type == OutTypeLib;
-    //bool shared = !g->is_static && is_lib;
-    //Buf *soname = nullptr;
-    if (ctx.comp.is_static) {
-        //if (util.isArmOrThumb(ctx.comp.target)) {
-        //    try ctx.args.append("-Bstatic");
-        //} else {
-        //    try ctx.args.append("-static");
-        //}
-    }
-    //} else if (shared) {
-    //    lj->args.append("-shared");
-
-    //    if (buf_len(&lj->out_file) == 0) {
-    //        buf_appendf(&lj->out_file, "lib%s.so.%" ZIG_PRI_usize ".%" ZIG_PRI_usize ".%" ZIG_PRI_usize "",
-    //                buf_ptr(g->root_out_name), g->version_major, g->version_minor, g->version_patch);
-    //    }
-    //    soname = buf_sprintf("lib%s.so.%" ZIG_PRI_usize "", buf_ptr(g->root_out_name), g->version_major);
-    //}
-
-    try ctx.args.append("-o");
-    try ctx.args.append(ctx.out_file_path.span());
-
-    if (ctx.link_in_crt) {
-        const crt1o = if (ctx.comp.is_static) "crt1.o" else "Scrt1.o";
-        try addPathJoin(ctx, ctx.libc.crt_dir.?, crt1o);
-        try addPathJoin(ctx, ctx.libc.crt_dir.?, "crti.o");
+    fn makeString(self: *Update, bytes: []const u8) !u32 {
+        const result = self.shstrtab.items.len;
+        try self.shstrtab.appendSlice(bytes);
+        try self.shstrtab.append(0);
+        return @intCast(u32, result);
     }
 
-    if (ctx.comp.haveLibC()) {
-        try ctx.args.append("-L");
-        // TODO addNullByte should probably return [:0]u8
-        try ctx.args.append(@ptrCast([*:0]const u8, (try std.cstr.addNullByte(&ctx.arena.allocator, ctx.libc.crt_dir.?)).ptr));
-
-        //if (!ctx.comp.is_static) {
-        //    const dl = blk: {
-        //        //if (ctx.libc.dynamic_linker_path) |dl| break :blk dl;
-        //        //if (util.getDynamicLinkerPath(ctx.comp.target)) |dl| break :blk dl;
-        //        return error.LibCMissingDynamicLinker;
-        //    };
-        //    try ctx.args.append("-dynamic-linker");
-        //    try ctx.args.append(@ptrCast([*:0]const u8, (try std.cstr.addNullByte(&ctx.arena.allocator, dl)).ptr));
-        //}
-    }
+    fn perform(self: *Update) !void {
+        const ptr_width: enum { p32, p64 } = switch (self.module.target.cpu.arch.ptrBitWidth()) {
+            32 => .p32,
+            64 => .p64,
+            else => return error.UnsupportedArchitecture,
+        };
+        const small_ptr = switch (ptr_width) {
+            .p32 => true,
+            .p64 => false,
+        };
+        // This means the entire read-only executable program code needs to be rewritten.
+        var phdr_load_re_dirty = false;
+        var phdr_table_dirty = false;
+        var shdr_table_dirty = false;
+        var shstrtab_dirty = false;
+        var symtab_dirty = false;
+
+        if (self.phdr_load_re_index == null) {
+            self.phdr_load_re_index = @intCast(u16, self.program_headers.items.len);
+            const file_size = 256 * 1024;
+            const p_align = 0x1000;
+            const off = self.findFreeSpace(file_size, p_align);
+            //std.debug.warn("found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+            try self.program_headers.append(.{
+                .p_type = elf.PT_LOAD,
+                .p_offset = off,
+                .p_filesz = file_size,
+                .p_vaddr = default_entry_addr,
+                .p_paddr = default_entry_addr,
+                .p_memsz = 0,
+                .p_align = p_align,
+                .p_flags = elf.PF_X | elf.PF_R,
+            });
+            self.entry_addr = null;
+            phdr_load_re_dirty = true;
+            phdr_table_dirty = true;
+        }
+        if (self.sections.items.len == 0) {
+            // There must always be a null section in index 0
+            try self.sections.append(.{
+                .sh_name = 0,
+                .sh_type = elf.SHT_NULL,
+                .sh_flags = 0,
+                .sh_addr = 0,
+                .sh_offset = 0,
+                .sh_size = 0,
+                .sh_link = 0,
+                .sh_info = 0,
+                .sh_addralign = 0,
+                .sh_entsize = 0,
+            });
+            shdr_table_dirty = true;
+        }
+        if (self.shstrtab_index == null) {
+            self.shstrtab_index = @intCast(u16, self.sections.items.len);
+            assert(self.shstrtab.items.len == 0);
+            try self.shstrtab.append(0); // need a 0 at position 0
+            const off = self.findFreeSpace(self.shstrtab.items.len, 1);
+            //std.debug.warn("found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });
+            try self.sections.append(.{
+                .sh_name = try self.makeString(".shstrtab"),
+                .sh_type = elf.SHT_STRTAB,
+                .sh_flags = 0,
+                .sh_addr = 0,
+                .sh_offset = off,
+                .sh_size = self.shstrtab.items.len,
+                .sh_link = 0,
+                .sh_info = 0,
+                .sh_addralign = 1,
+                .sh_entsize = 0,
+            });
+            shstrtab_dirty = true;
+            shdr_table_dirty = true;
+        }
+        if (self.text_section_index == null) {
+            self.text_section_index = @intCast(u16, self.sections.items.len);
+            const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
+
+            try self.sections.append(.{
+                .sh_name = try self.makeString(".text"),
+                .sh_type = elf.SHT_PROGBITS,
+                .sh_flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
+                .sh_addr = phdr.p_vaddr,
+                .sh_offset = phdr.p_offset,
+                .sh_size = phdr.p_filesz,
+                .sh_link = 0,
+                .sh_info = 0,
+                .sh_addralign = phdr.p_align,
+                .sh_entsize = 0,
+            });
+            shdr_table_dirty = true;
+        }
+        if (self.symtab_section_index == null) {
+            self.symtab_section_index = @intCast(u16, self.sections.items.len);
+            const min_align: u16 = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym);
+            const each_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym);
+            const file_size = self.module.exports.len * each_size;
+            const off = self.findFreeSpace(file_size, min_align);
+            //std.debug.warn("found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+
+            try self.sections.append(.{
+                .sh_name = try self.makeString(".symtab"),
+                .sh_type = elf.SHT_SYMTAB,
+                .sh_flags = 0,
+                .sh_addr = 0,
+                .sh_offset = off,
+                .sh_size = file_size,
+                // The section header index of the associated string table.
+                .sh_link = self.shstrtab_index.?,
+                .sh_info = @intCast(u32, self.module.exports.len),
+                .sh_addralign = min_align,
+                .sh_entsize = each_size,
+            });
+            symtab_dirty = true;
+            shdr_table_dirty = true;
+        }
+        const shsize: u64 = switch (ptr_width) {
+            .p32 => @sizeOf(elf.Elf32_Shdr),
+            .p64 => @sizeOf(elf.Elf64_Shdr),
+        };
+        const shalign: u16 = switch (ptr_width) {
+            .p32 => @alignOf(elf.Elf32_Shdr),
+            .p64 => @alignOf(elf.Elf64_Shdr),
+        };
+        if (self.shdr_table_offset == null) {
+            self.shdr_table_offset = self.findFreeSpace(self.sections.items.len * shsize, shalign);
+            shdr_table_dirty = true;
+        }
+        const phsize: u64 = switch (ptr_width) {
+            .p32 => @sizeOf(elf.Elf32_Phdr),
+            .p64 => @sizeOf(elf.Elf64_Phdr),
+        };
+        const phalign: u16 = switch (ptr_width) {
+            .p32 => @alignOf(elf.Elf32_Phdr),
+            .p64 => @alignOf(elf.Elf64_Phdr),
+        };
+        if (self.phdr_table_offset == null) {
+            self.phdr_table_offset = self.findFreeSpace(self.program_headers.items.len * phsize, phalign);
+            phdr_table_dirty = true;
+        }
+        const foreign_endian = self.module.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
 
-    //if (shared) {
-    //    lj->args.append("-soname");
-    //    lj->args.append(buf_ptr(soname));
-    //}
+        try self.writeCodeAndSymbols(phdr_table_dirty, shdr_table_dirty);
 
-    // .o files
-    for (ctx.comp.link_objects) |link_object| {
-        const link_obj_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, link_object);
-        try ctx.args.append(@ptrCast([*:0]const u8, link_obj_with_null.ptr));
-    }
-    try addFnObjects(ctx);
-
-    //if (g->out_type == OutTypeExe || g->out_type == OutTypeLib) {
-    //    if (g->libc_link_lib == nullptr) {
-    //        Buf *builtin_o_path = build_o(g, "builtin");
-    //        lj->args.append(buf_ptr(builtin_o_path));
-    //    }
-
-    //    // sometimes libgcc is missing stuff, so we still build compiler_rt and rely on weak linkage
-    //    Buf *compiler_rt_o_path = build_compiler_rt(g);
-    //    lj->args.append(buf_ptr(compiler_rt_o_path));
-    //}
-
-    //for (size_t i = 0; i < g->link_libs_list.length; i += 1) {
-    //    LinkLib *link_lib = g->link_libs_list.at(i);
-    //    if (buf_eql_str(link_lib->name, "c")) {
-    //        continue;
-    //    }
-    //    Buf *arg;
-    //    if (buf_starts_with_str(link_lib->name, "/") || buf_ends_with_str(link_lib->name, ".a") ||
-    //        buf_ends_with_str(link_lib->name, ".so"))
-    //    {
-    //        arg = link_lib->name;
-    //    } else {
-    //        arg = buf_sprintf("-l%s", buf_ptr(link_lib->name));
-    //    }
-    //    lj->args.append(buf_ptr(arg));
-    //}
-
-    // libc dep
-    if (ctx.comp.haveLibC()) {
-        if (ctx.comp.is_static) {
-            try ctx.args.append("--start-group");
-            try ctx.args.append("-lgcc");
-            try ctx.args.append("-lgcc_eh");
-            try ctx.args.append("-lc");
-            try ctx.args.append("-lm");
-            try ctx.args.append("--end-group");
+        if (phdr_table_dirty) {
+            const allocated_size = self.allocatedSize(self.phdr_table_offset.?);
+            const needed_size = self.program_headers.items.len * phsize;
+
+            if (needed_size > allocated_size) {
+                self.phdr_table_offset = null; // free the space
+                self.phdr_table_offset = self.findFreeSpace(needed_size, phalign);
+            }
+
+            const allocator = self.program_headers.allocator;
+            switch (ptr_width) {
+                .p32 => {
+                    const buf = try allocator.alloc(elf.Elf32_Phdr, self.program_headers.items.len);
+                    defer allocator.free(buf);
+
+                    for (buf) |*phdr, i| {
+                        phdr.* = progHeaderTo32(self.program_headers.items[i]);
+                        if (foreign_endian) {
+                            bswapAllFields(elf.Elf32_Phdr, phdr);
+                        }
+                    }
+                    try self.file.pwriteAll(mem.sliceAsBytes(buf), self.phdr_table_offset.?);
+                },
+                .p64 => {
+                    const buf = try allocator.alloc(elf.Elf64_Phdr, self.program_headers.items.len);
+                    defer allocator.free(buf);
+
+                    for (buf) |*phdr, i| {
+                        phdr.* = self.program_headers.items[i];
+                        if (foreign_endian) {
+                            bswapAllFields(elf.Elf64_Phdr, phdr);
+                        }
+                    }
+                    try self.file.pwriteAll(mem.sliceAsBytes(buf), self.phdr_table_offset.?);
+                },
+            }
+        }
+
+        {
+            const shstrtab_sect = &self.sections.items[self.shstrtab_index.?];
+            if (shstrtab_dirty or self.shstrtab.items.len != shstrtab_sect.sh_size) {
+                const allocated_size = self.allocatedSize(shstrtab_sect.sh_offset);
+                const needed_size = self.shstrtab.items.len;
+
+                if (needed_size > allocated_size) {
+                    shstrtab_sect.sh_size = 0; // free the space
+                    shstrtab_sect.sh_offset = self.findFreeSpace(needed_size, 1);
+                }
+                shstrtab_sect.sh_size = needed_size;
+                //std.debug.warn("shstrtab start=0x{x} end=0x{x}\n", .{ shstrtab_sect.sh_offset, shstrtab_sect.sh_offset + needed_size });
+
+                try self.file.pwriteAll(self.shstrtab.items, shstrtab_sect.sh_offset);
+                if (!shdr_table_dirty) {
+                    // Then it won't get written with the others and we need to do it.
+                    try self.writeSectHeader(self.shstrtab_index.?);
+                }
+            }
+        }
+        if (shdr_table_dirty) {
+            const allocated_size = self.allocatedSize(self.shdr_table_offset.?);
+            const needed_size = self.sections.items.len * phsize;
+
+            if (needed_size > allocated_size) {
+                self.shdr_table_offset = null; // free the space
+                self.shdr_table_offset = self.findFreeSpace(needed_size, phalign);
+            }
+
+            const allocator = self.sections.allocator;
+            switch (ptr_width) {
+                .p32 => {
+                    const buf = try allocator.alloc(elf.Elf32_Shdr, self.sections.items.len);
+                    defer allocator.free(buf);
+
+                    for (buf) |*shdr, i| {
+                        shdr.* = sectHeaderTo32(self.sections.items[i]);
+                        if (foreign_endian) {
+                            bswapAllFields(elf.Elf32_Shdr, shdr);
+                        }
+                    }
+                    try self.file.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
+                },
+                .p64 => {
+                    const buf = try allocator.alloc(elf.Elf64_Shdr, self.sections.items.len);
+                    defer allocator.free(buf);
+
+                    for (buf) |*shdr, i| {
+                        shdr.* = self.sections.items[i];
+                        //std.debug.warn("writing section {}\n", .{shdr.*});
+                        if (foreign_endian) {
+                            bswapAllFields(elf.Elf64_Shdr, shdr);
+                        }
+                    }
+                    try self.file.pwriteAll(mem.sliceAsBytes(buf), self.shdr_table_offset.?);
+                },
+            }
+        }
+        if (self.entry_addr == null) {
+            const msg = try std.fmt.allocPrint(self.errors.allocator, "no entry point found", .{});
+            errdefer self.errors.allocator.free(msg);
+            try self.errors.append(.{
+                .byte_offset = 0,
+                .msg = msg,
+            });
         } else {
-            try ctx.args.append("-lgcc");
-            try ctx.args.append("--as-needed");
-            try ctx.args.append("-lgcc_s");
-            try ctx.args.append("--no-as-needed");
-            try ctx.args.append("-lc");
-            try ctx.args.append("-lm");
-            try ctx.args.append("-lgcc");
-            try ctx.args.append("--as-needed");
-            try ctx.args.append("-lgcc_s");
-            try ctx.args.append("--no-as-needed");
+            try self.writeElfHeader();
         }
+        // TODO find end pos and truncate
     }
 
-    // crt end
-    if (ctx.link_in_crt) {
-        try addPathJoin(ctx, ctx.libc.crt_dir.?, "crtn.o");
-    }
+    fn writeElfHeader(self: *Update) !void {
+        var hdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 = undefined;
 
-    //if (ctx.comp.target != Target.Native) {
-    //    try ctx.args.append("--allow-shlib-undefined");
-    //}
-}
+        var index: usize = 0;
+        hdr_buf[0..4].* = "\x7fELF".*;
+        index += 4;
 
-fn addPathJoin(ctx: *Context, dirname: []const u8, basename: []const u8) !void {
-    const full_path = try std.fs.path.join(&ctx.arena.allocator, &[_][]const u8{ dirname, basename });
-    const full_path_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, full_path);
-    try ctx.args.append(@ptrCast([*:0]const u8, full_path_with_null.ptr));
-}
+        const ptr_width: enum { p32, p64 } = switch (self.module.target.cpu.arch.ptrBitWidth()) {
+            32 => .p32,
+            64 => .p64,
+            else => return error.UnsupportedArchitecture,
+        };
+        hdr_buf[index] = switch (ptr_width) {
+            .p32 => elf.ELFCLASS32,
+            .p64 => elf.ELFCLASS64,
+        };
+        index += 1;
 
-fn constructLinkerArgsCoff(ctx: *Context) !void {
-    try ctx.args.append("-NOLOGO");
+        const endian = self.module.target.cpu.arch.endian();
+        hdr_buf[index] = switch (endian) {
+            .Little => elf.ELFDATA2LSB,
+            .Big => elf.ELFDATA2MSB,
+        };
+        index += 1;
 
-    if (!ctx.comp.strip) {
-        try ctx.args.append("-DEBUG");
-    }
+        hdr_buf[index] = 1; // ELF version
+        index += 1;
 
-    switch (ctx.comp.target.cpu.arch) {
-        .i386 => try ctx.args.append("-MACHINE:X86"),
-        .x86_64 => try ctx.args.append("-MACHINE:X64"),
-        .aarch64 => try ctx.args.append("-MACHINE:ARM"),
-        else => return error.UnsupportedLinkArchitecture,
-    }
+        // OS ABI, often set to 0 regardless of target platform
+        // ABI Version, possibly used by glibc but not by static executables
+        // padding
+        mem.set(u8, hdr_buf[index..][0..9], 0);
+        index += 9;
 
-    const is_library = ctx.comp.kind == .Lib;
+        assert(index == 16);
 
-    const out_arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-OUT:{}\x00", .{ctx.out_file_path.span()});
-    try ctx.args.append(@ptrCast([*:0]const u8, out_arg.ptr));
+        mem.writeInt(u16, hdr_buf[index..][0..2], @enumToInt(elf.ET.EXEC), endian);
+        index += 2;
 
-    if (ctx.comp.haveLibC()) {
-        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", .{ctx.libc.msvc_lib_dir.?})).ptr));
-        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", .{ctx.libc.kernel32_lib_dir.?})).ptr));
-        try ctx.args.append(@ptrCast([*:0]const u8, (try std.fmt.allocPrint(&ctx.arena.allocator, "-LIBPATH:{}\x00", .{ctx.libc.crt_dir.?})).ptr));
-    }
+        const machine = self.module.target.cpu.arch.toElfMachine();
+        mem.writeInt(u16, hdr_buf[index..][0..2], @enumToInt(machine), endian);
+        index += 2;
 
-    if (ctx.link_in_crt) {
-        const lib_str = if (ctx.comp.is_static) "lib" else "";
-        const d_str = if (ctx.comp.build_mode == .Debug) "d" else "";
+        // ELF Version, again
+        mem.writeInt(u32, hdr_buf[index..][0..4], 1, endian);
+        index += 4;
 
-        if (ctx.comp.is_static) {
-            const cmt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "libcmt{}.lib\x00", .{d_str});
-            try ctx.args.append(@ptrCast([*:0]const u8, cmt_lib_name.ptr));
-        } else {
-            const msvcrt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "msvcrt{}.lib\x00", .{d_str});
-            try ctx.args.append(@ptrCast([*:0]const u8, msvcrt_lib_name.ptr));
-        }
+        switch (ptr_width) {
+            .p32 => {
+                // e_entry
+                mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, self.entry_addr.?), endian);
+                index += 4;
+
+                // e_phoff
+                mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, self.phdr_table_offset.?), endian);
+                index += 4;
 
-        const vcruntime_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "{}vcruntime{}.lib\x00", .{
-            lib_str,
-            d_str,
-        });
-        try ctx.args.append(@ptrCast([*:0]const u8, vcruntime_lib_name.ptr));
-
-        const crt_lib_name = try std.fmt.allocPrint(&ctx.arena.allocator, "{}ucrt{}.lib\x00", .{ lib_str, d_str });
-        try ctx.args.append(@ptrCast([*:0]const u8, crt_lib_name.ptr));
-
-        // Visual C++ 2015 Conformance Changes
-        // https://msdn.microsoft.com/en-us/library/bb531344.aspx
-        try ctx.args.append("legacy_stdio_definitions.lib");
-
-        // msvcrt depends on kernel32
-        try ctx.args.append("kernel32.lib");
-    } else {
-        try ctx.args.append("-NODEFAULTLIB");
-        if (!is_library) {
-            try ctx.args.append("-ENTRY:WinMainCRTStartup");
+                // e_shoff
+                mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(u32, self.shdr_table_offset.?), endian);
+                index += 4;
+            },
+            .p64 => {
+                // e_entry
+                mem.writeInt(u64, hdr_buf[index..][0..8], self.entry_addr.?, endian);
+                index += 8;
+
+                // e_phoff
+                mem.writeInt(u64, hdr_buf[index..][0..8], self.phdr_table_offset.?, endian);
+                index += 8;
+
+                // e_shoff
+                mem.writeInt(u64, hdr_buf[index..][0..8], self.shdr_table_offset.?, endian);
+                index += 8;
+            },
         }
-    }
 
-    if (is_library and !ctx.comp.is_static) {
-        try ctx.args.append("-DLL");
-    }
+        const e_flags = 0;
+        mem.writeInt(u32, hdr_buf[index..][0..4], e_flags, endian);
+        index += 4;
 
-    for (ctx.comp.link_objects) |link_object| {
-        const link_obj_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, link_object);
-        try ctx.args.append(@ptrCast([*:0]const u8, link_obj_with_null.ptr));
-    }
-    try addFnObjects(ctx);
+        const e_ehsize: u16 = switch (ptr_width) {
+            .p32 => @sizeOf(elf.Elf32_Ehdr),
+            .p64 => @sizeOf(elf.Elf64_Ehdr),
+        };
+        mem.writeInt(u16, hdr_buf[index..][0..2], e_ehsize, endian);
+        index += 2;
 
-    switch (ctx.comp.kind) {
-        .Exe, .Lib => {
-            if (!ctx.comp.haveLibC()) {
-                @panic("TODO");
-            }
-        },
-        .Obj => {},
-    }
-}
+        const e_phentsize: u16 = switch (ptr_width) {
+            .p32 => @sizeOf(elf.Elf32_Phdr),
+            .p64 => @sizeOf(elf.Elf64_Phdr),
+        };
+        mem.writeInt(u16, hdr_buf[index..][0..2], e_phentsize, endian);
+        index += 2;
 
-fn constructLinkerArgsMachO(ctx: *Context) !void {
-    try ctx.args.append("-demangle");
+        const e_phnum = @intCast(u16, self.program_headers.items.len);
+        mem.writeInt(u16, hdr_buf[index..][0..2], e_phnum, endian);
+        index += 2;
 
-    if (ctx.comp.linker_rdynamic) {
-        try ctx.args.append("-export_dynamic");
-    }
+        const e_shentsize: u16 = switch (ptr_width) {
+            .p32 => @sizeOf(elf.Elf32_Shdr),
+            .p64 => @sizeOf(elf.Elf64_Shdr),
+        };
+        mem.writeInt(u16, hdr_buf[index..][0..2], e_shentsize, endian);
+        index += 2;
 
-    const is_lib = ctx.comp.kind == .Lib;
-    const shared = !ctx.comp.is_static and is_lib;
-    if (ctx.comp.is_static) {
-        try ctx.args.append("-static");
-    } else {
-        try ctx.args.append("-dynamic");
-    }
+        const e_shnum = @intCast(u16, self.sections.items.len);
+        mem.writeInt(u16, hdr_buf[index..][0..2], e_shnum, endian);
+        index += 2;
 
-    try ctx.args.append("-arch");
-    try ctx.args.append(util.getDarwinArchString(ctx.comp.target));
+        mem.writeInt(u16, hdr_buf[index..][0..2], self.shstrtab_index.?, endian);
+        index += 2;
 
-    const platform = try DarwinPlatform.get(ctx.comp);
-    switch (platform.kind) {
-        .MacOS => try ctx.args.append("-macosx_version_min"),
-        .IPhoneOS => try ctx.args.append("-iphoneos_version_min"),
-        .IPhoneOSSimulator => try ctx.args.append("-ios_simulator_version_min"),
+        assert(index == e_ehsize);
+
+        try self.file.pwriteAll(hdr_buf[0..index], 0);
     }
-    const ver_str = try std.fmt.allocPrint(&ctx.arena.allocator, "{}.{}.{}\x00", .{
-        platform.major,
-        platform.minor,
-        platform.micro,
-    });
-    try ctx.args.append(@ptrCast([*:0]const u8, ver_str.ptr));
-
-    if (ctx.comp.kind == .Exe) {
-        if (ctx.comp.is_static) {
-            try ctx.args.append("-no_pie");
-        } else {
-            try ctx.args.append("-pie");
+
+    fn writeCodeAndSymbols(self: *Update, phdr_table_dirty: bool, shdr_table_dirty: bool) !void {
+        // index 0 is always a null symbol
+        try self.symbols.resize(1);
+        self.symbols.items[0] = .{
+            .st_name = 0,
+            .st_info = 0,
+            .st_other = 0,
+            .st_shndx = 0,
+            .st_value = 0,
+            .st_size = 0,
+        };
+
+        const phdr = &self.program_headers.items[self.phdr_load_re_index.?];
+        var vaddr: u64 = phdr.p_vaddr;
+        var file_off: u64 = phdr.p_offset;
+
+        var code = std.ArrayList(u8).init(self.sections.allocator);
+        defer code.deinit();
+
+        for (self.module.exports) |exp| {
+            code.shrink(0);
+            var symbol = try codegen.generateSymbol(exp.typed_value, self.module.*, &code);
+            defer symbol.deinit(code.allocator);
+            if (symbol.errors.len != 0) {
+                for (symbol.errors) |err| {
+                    const msg = try mem.dupe(self.errors.allocator, u8, err.msg);
+                    errdefer self.errors.allocator.free(msg);
+                    try self.errors.append(.{
+                        .byte_offset = err.byte_offset,
+                        .msg = msg,
+                    });
+                }
+                continue;
+            }
+            try self.file.pwriteAll(code.items, file_off);
+
+            if (mem.eql(u8, exp.name, "_start")) {
+                self.entry_addr = vaddr;
+            }
+            (try self.symbols.addOne()).* = .{
+                .st_name = try self.makeString(exp.name),
+                .st_info = (elf.STB_LOCAL << 4) | elf.STT_FUNC,
+                .st_other = 0,
+                .st_shndx = self.text_section_index.?,
+                .st_value = vaddr,
+                .st_size = code.items.len,
+            };
+            vaddr += code.items.len;
+        }
+
+        {
+            // Now that we know the code size, we need to update the program header for executable code
+            phdr.p_memsz = vaddr - phdr.p_vaddr;
+            phdr.p_filesz = phdr.p_memsz;
+
+            const shdr = &self.sections.items[self.text_section_index.?];
+            shdr.sh_size = phdr.p_filesz;
+
+            if (!phdr_table_dirty) {
+                // Then it won't get written with the others and we need to do it.
+                try self.writeProgHeader(self.phdr_load_re_index.?);
+            }
+            if (!shdr_table_dirty) {
+                // Then it won't get written with the others and we need to do it.
+                try self.writeSectHeader(self.text_section_index.?);
+            }
         }
+
+        return self.writeSymbols();
     }
 
-    try ctx.args.append("-o");
-    try ctx.args.append(ctx.out_file_path.span());
-
-    if (shared) {
-        try ctx.args.append("-headerpad_max_install_names");
-    } else if (ctx.comp.is_static) {
-        try ctx.args.append("-lcrt0.o");
-    } else {
-        switch (platform.kind) {
-            .MacOS => {
-                if (platform.versionLessThan(10, 5)) {
-                    try ctx.args.append("-lcrt1.o");
-                } else if (platform.versionLessThan(10, 6)) {
-                    try ctx.args.append("-lcrt1.10.5.o");
-                } else if (platform.versionLessThan(10, 8)) {
-                    try ctx.args.append("-lcrt1.10.6.o");
+    fn writeProgHeader(self: *Update, index: usize) !void {
+        const foreign_endian = self.module.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+        const offset = self.program_headers.items[index].p_offset;
+        switch (self.module.target.cpu.arch.ptrBitWidth()) {
+            32 => {
+                var phdr = [1]elf.Elf32_Phdr{progHeaderTo32(self.program_headers.items[index])};
+                if (foreign_endian) {
+                    bswapAllFields(elf.Elf32_Phdr, &phdr[0]);
                 }
+                return self.file.pwriteAll(mem.sliceAsBytes(&phdr), offset);
             },
-            .IPhoneOS => {
-                if (ctx.comp.target.cpu.arch == .aarch64) {
-                    // iOS does not need any crt1 files for arm64
-                } else if (platform.versionLessThan(3, 1)) {
-                    try ctx.args.append("-lcrt1.o");
-                } else if (platform.versionLessThan(6, 0)) {
-                    try ctx.args.append("-lcrt1.3.1.o");
+            64 => {
+                var phdr = [1]elf.Elf64_Phdr{self.program_headers.items[index]};
+                if (foreign_endian) {
+                    bswapAllFields(elf.Elf64_Phdr, &phdr[0]);
                 }
+                return self.file.pwriteAll(mem.sliceAsBytes(&phdr), offset);
             },
-            .IPhoneOSSimulator => {}, // no crt1.o needed
+            else => return error.UnsupportedArchitecture,
         }
     }
 
-    for (ctx.comp.link_objects) |link_object| {
-        const link_obj_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, link_object);
-        try ctx.args.append(@ptrCast([*:0]const u8, link_obj_with_null.ptr));
-    }
-    try addFnObjects(ctx);
-
-    // TODO
-    //if (ctx.comp.target == Target.Native) {
-    //    for (ctx.comp.link_libs_list.span()) |lib| {
-    //        if (mem.eql(u8, lib.name, "c")) {
-    //            // on Darwin, libSystem has libc in it, but also you have to use it
-    //            // to make syscalls because the syscall numbers are not documented
-    //            // and change between versions.
-    //            // so we always link against libSystem
-    //            try ctx.args.append("-lSystem");
-    //        } else {
-    //            if (mem.indexOfScalar(u8, lib.name, '/') == null) {
-    //                const arg = try std.fmt.allocPrint(&ctx.arena.allocator, "-l{}\x00", .{lib.name});
-    //                try ctx.args.append(@ptrCast([*:0]const u8, arg.ptr));
-    //            } else {
-    //                const arg = try std.cstr.addNullByte(&ctx.arena.allocator, lib.name);
-    //                try ctx.args.append(@ptrCast([*:0]const u8, arg.ptr));
-    //            }
-    //        }
-    //    }
-    //} else {
-    //    try ctx.args.append("-undefined");
-    //    try ctx.args.append("dynamic_lookup");
-    //}
-
-    if (platform.kind == .MacOS) {
-        if (platform.versionLessThan(10, 5)) {
-            try ctx.args.append("-lgcc_s.10.4");
-        } else if (platform.versionLessThan(10, 6)) {
-            try ctx.args.append("-lgcc_s.10.5");
+    fn writeSectHeader(self: *Update, index: usize) !void {
+        const foreign_endian = self.module.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+        const offset = self.sections.items[index].sh_offset;
+        switch (self.module.target.cpu.arch.ptrBitWidth()) {
+            32 => {
+                var shdr: [1]elf.Elf32_Shdr = undefined;
+                shdr[0] = sectHeaderTo32(self.sections.items[index]);
+                if (foreign_endian) {
+                    bswapAllFields(elf.Elf32_Shdr, &shdr[0]);
+                }
+                return self.file.pwriteAll(mem.sliceAsBytes(&shdr), offset);
+            },
+            64 => {
+                var shdr = [1]elf.Elf64_Shdr{self.sections.items[index]};
+                if (foreign_endian) {
+                    bswapAllFields(elf.Elf64_Shdr, &shdr[0]);
+                }
+                return self.file.pwriteAll(mem.sliceAsBytes(&shdr), offset);
+            },
+            else => return error.UnsupportedArchitecture,
         }
-    } else {
-        @panic("TODO");
     }
-}
-
-fn constructLinkerArgsWasm(ctx: *Context) void {
-    @panic("TODO");
-}
 
-fn addFnObjects(ctx: *Context) !void {
-    const held = ctx.comp.fn_link_set.acquire();
-    defer held.release();
-
-    var it = held.value.first;
-    while (it) |node| {
-        const fn_val = node.data orelse {
-            // handle the tombstone. See Value.Fn.destroy.
-            it = node.next;
-            held.value.remove(node);
-            ctx.comp.gpa().destroy(node);
-            continue;
+    fn writeSymbols(self: *Update) !void {
+        const ptr_width: enum { p32, p64 } = switch (self.module.target.cpu.arch.ptrBitWidth()) {
+            32 => .p32,
+            64 => .p64,
+            else => return error.UnsupportedArchitecture,
         };
-        try ctx.args.append(fn_val.containing_object.span());
-        it = node.next;
+        const small_ptr = ptr_width == .p32;
+        const syms_sect = &self.sections.items[self.symtab_section_index.?];
+        const sym_align: u16 = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym);
+        const sym_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym);
+
+        const allocated_size = self.allocatedSize(syms_sect.sh_offset);
+        const needed_size = self.symbols.items.len * sym_size;
+        if (needed_size > allocated_size) {
+            syms_sect.sh_size = 0; // free the space
+            syms_sect.sh_offset = self.findFreeSpace(needed_size, sym_align);
+            //std.debug.warn("moved symtab to 0x{x} to 0x{x}\n", .{ syms_sect.sh_offset, syms_sect.sh_offset + needed_size });
+        }
+        //std.debug.warn("symtab start=0x{x} end=0x{x}\n", .{ syms_sect.sh_offset, syms_sect.sh_offset + needed_size });
+        syms_sect.sh_size = needed_size;
+        syms_sect.sh_info = @intCast(u32, self.symbols.items.len);
+        const allocator = self.symbols.allocator;
+        const foreign_endian = self.module.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+        switch (ptr_width) {
+            .p32 => {
+                const buf = try allocator.alloc(elf.Elf32_Sym, self.symbols.items.len);
+                defer allocator.free(buf);
+
+                for (buf) |*sym, i| {
+                    sym.* = .{
+                        .st_name = self.symbols.items[i].st_name,
+                        .st_value = @intCast(u32, self.symbols.items[i].st_value),
+                        .st_size = @intCast(u32, self.symbols.items[i].st_size),
+                        .st_info = self.symbols.items[i].st_info,
+                        .st_other = self.symbols.items[i].st_other,
+                        .st_shndx = self.symbols.items[i].st_shndx,
+                    };
+                    if (foreign_endian) {
+                        bswapAllFields(elf.Elf32_Sym, sym);
+                    }
+                }
+                try self.file.pwriteAll(mem.sliceAsBytes(buf), syms_sect.sh_offset);
+            },
+            .p64 => {
+                const buf = try allocator.alloc(elf.Elf64_Sym, self.symbols.items.len);
+                defer allocator.free(buf);
+
+                for (buf) |*sym, i| {
+                    sym.* = .{
+                        .st_name = self.symbols.items[i].st_name,
+                        .st_value = self.symbols.items[i].st_value,
+                        .st_size = self.symbols.items[i].st_size,
+                        .st_info = self.symbols.items[i].st_info,
+                        .st_other = self.symbols.items[i].st_other,
+                        .st_shndx = self.symbols.items[i].st_shndx,
+                    };
+                    if (foreign_endian) {
+                        bswapAllFields(elf.Elf64_Sym, sym);
+                    }
+                }
+                try self.file.pwriteAll(mem.sliceAsBytes(buf), syms_sect.sh_offset);
+            },
+        }
     }
-}
+};
 
-const DarwinPlatform = struct {
-    kind: Kind,
-    major: u32,
-    minor: u32,
-    micro: u32,
+/// Truncates the existing file contents and overwrites the contents.
+/// Returns an error if `file` is not already open with +read +write +seek abilities.
+pub fn writeExecutableFile(allocator: *Allocator, module: ir.Module, file: fs.File) !Result {
+    var update = Update{
+        .file = file,
+        .module = &module,
+        .sections = std.ArrayList(elf.Elf64_Shdr).init(allocator),
+        .shdr_table_offset = null,
+        .program_headers = std.ArrayList(elf.Elf64_Phdr).init(allocator),
+        .phdr_table_offset = null,
+        .phdr_load_re_index = null,
+        .entry_addr = null,
+        .shstrtab = std.ArrayList(u8).init(allocator),
+        .shstrtab_index = null,
+        .text_section_index = null,
+        .symtab_section_index = null,
+
+        .symbols = std.ArrayList(elf.Elf64_Sym).init(allocator),
+
+        .errors = std.ArrayList(ErrorMsg).init(allocator),
+    };
+    defer update.deinit();
 
-    const Kind = enum {
-        MacOS,
-        IPhoneOS,
-        IPhoneOSSimulator,
+    try update.perform();
+    return Result{
+        .errors = update.errors.toOwnedSlice(),
     };
+}
 
-    fn get(comp: *Compilation) !DarwinPlatform {
-        var result: DarwinPlatform = undefined;
-        const ver_str = switch (comp.darwin_version_min) {
-            .MacOS => |ver| blk: {
-                result.kind = .MacOS;
-                break :blk ver;
-            },
-            .Ios => |ver| blk: {
-                result.kind = .IPhoneOS;
-                break :blk ver;
-            },
-            .None => blk: {
-                assert(comp.target.os.tag == .macosx);
-                result.kind = .MacOS;
-                break :blk "10.14";
-            },
-        };
+/// Returns error.IncrFailed if incremental update could not be performed.
+fn updateExecutableFileInner(allocator: *Allocator, module: ir.Module, file: fs.File) !Result {
+    //var ehdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 = undefined;
 
-        var had_extra: bool = undefined;
-        try darwinGetReleaseVersion(
-            ver_str,
-            &result.major,
-            &result.minor,
-            &result.micro,
-            &had_extra,
-        );
-        if (had_extra or result.major != 10 or result.minor >= 100 or result.micro >= 100) {
-            return error.InvalidDarwinVersionString;
-        }
+    // TODO implement incremental linking
+    return error.IncrFailed;
+}
 
-        if (result.kind == .IPhoneOS) {
-            switch (comp.target.cpu.arch) {
-                .i386,
-                .x86_64,
-                => result.kind = .IPhoneOSSimulator,
-                else => {},
-            }
-        }
-        return result;
-    }
+/// Saturating multiplication
+fn satMul(a: var, b: var) @TypeOf(a, b) {
+    const T = @TypeOf(a, b);
+    return std.math.mul(T, a, b) catch std.math.maxInt(T);
+}
 
-    fn versionLessThan(self: DarwinPlatform, major: u32, minor: u32) bool {
-        if (self.major < major)
-            return true;
-        if (self.major > major)
-            return false;
-        if (self.minor < minor)
-            return true;
-        return false;
-    }
-};
+fn bswapAllFields(comptime S: type, ptr: *S) void {
+    @panic("TODO implement bswapAllFields");
+}
 
-/// Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
-/// grouped values as integers. Numbers which are not provided are set to 0.
-/// return true if the entire string was parsed (9.2), or all groups were
-/// parsed (10.3.5extrastuff).
-fn darwinGetReleaseVersion(str: []const u8, major: *u32, minor: *u32, micro: *u32, had_extra: *bool) !void {
-    major.* = 0;
-    minor.* = 0;
-    micro.* = 0;
-    had_extra.* = false;
-
-    if (str.len == 0)
-        return error.InvalidDarwinVersionString;
-
-    var start_pos: usize = 0;
-    for ([_]*u32{ major, minor, micro }) |v| {
-        const dot_pos = mem.indexOfScalarPos(u8, str, start_pos, '.');
-        const end_pos = dot_pos orelse str.len;
-        v.* = std.fmt.parseUnsigned(u32, str[start_pos..end_pos], 10) catch return error.InvalidDarwinVersionString;
-        start_pos = (dot_pos orelse return) + 1;
-        if (start_pos == str.len) return;
-    }
-    had_extra.* = true;
+fn progHeaderTo32(phdr: elf.Elf64_Phdr) elf.Elf32_Phdr {
+    return .{
+        .p_type = phdr.p_type,
+        .p_flags = phdr.p_flags,
+        .p_offset = @intCast(u32, phdr.p_offset),
+        .p_vaddr = @intCast(u32, phdr.p_vaddr),
+        .p_paddr = @intCast(u32, phdr.p_paddr),
+        .p_filesz = @intCast(u32, phdr.p_filesz),
+        .p_memsz = @intCast(u32, phdr.p_memsz),
+        .p_align = @intCast(u32, phdr.p_align),
+    };
+}
+
+fn sectHeaderTo32(shdr: elf.Elf64_Shdr) elf.Elf32_Shdr {
+    return .{
+        .sh_name = shdr.sh_name,
+        .sh_type = shdr.sh_type,
+        .sh_flags = @intCast(u32, shdr.sh_flags),
+        .sh_addr = @intCast(u32, shdr.sh_addr),
+        .sh_offset = @intCast(u32, shdr.sh_offset),
+        .sh_size = @intCast(u32, shdr.sh_size),
+        .sh_link = shdr.sh_link,
+        .sh_info = shdr.sh_info,
+        .sh_addralign = @intCast(u32, shdr.sh_addralign),
+        .sh_entsize = @intCast(u32, shdr.sh_entsize),
+    };
 }