diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 56bc10c123..4436391979 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -158,8 +158,8 @@ stub_preamble_sym_index: ?u32 = null,
 strtab: std.ArrayListUnmanaged(u8) = .{},
 strtab_dir: std.HashMapUnmanaged(u32, u32, StringIndexContext, std.hash_map.default_max_load_percentage) = .{},
 
-got_entries_map: std.AutoArrayHashMapUnmanaged(GotIndirectionKey, *TextBlock) = .{},
-stubs_map: std.AutoArrayHashMapUnmanaged(u32, *TextBlock) = .{},
+got_entries_map: std.AutoArrayHashMapUnmanaged(GotIndirectionKey, *Atom) = .{},
+stubs_map: std.AutoArrayHashMapUnmanaged(u32, *Atom) = .{},
 
 error_flags: File.ErrorFlags = File.ErrorFlags{},
 
@@ -171,12 +171,12 @@ has_stabs: bool = false,
 
 section_ordinals: std.AutoArrayHashMapUnmanaged(MatchingSection, void) = .{},
 
-/// A list of text blocks that have surplus capacity. This list can have false
+/// A list of atoms that have surplus capacity. This list can have false
 /// positives, as functions grow and shrink over time, only sometimes being added
 /// or removed from the freelist.
 ///
-/// A text block has surplus capacity when its overcapacity value is greater than
-/// padToIdeal(minimum_text_block_size). That is, when it has so
+/// An atom has surplus capacity when its overcapacity value is greater than
+/// padToIdeal(minimum_atom_size). That is, when it has so
 /// much extra capacity, that we could fit a small new symbol in it, itself with
 /// ideal_capacity or more.
 ///
@@ -184,23 +184,23 @@ section_ordinals: std.AutoArrayHashMapUnmanaged(MatchingSection, void) = .{},
 ///
 /// Overcapacity is measured by actual_capacity - ideal_capacity. Note that
 /// overcapacity can be negative. A simple way to have negative overcapacity is to
-/// allocate a fresh text block, which will have ideal capacity, and then grow it
+/// allocate a fresh atom, which will have ideal capacity, and then grow it
 /// by 1 byte. It will then have -1 overcapacity.
-block_free_lists: std.AutoHashMapUnmanaged(MatchingSection, std.ArrayListUnmanaged(*TextBlock)) = .{},
+atom_free_lists: std.AutoHashMapUnmanaged(MatchingSection, std.ArrayListUnmanaged(*Atom)) = .{},
 
-/// Pointer to the last allocated text block
-blocks: std.AutoHashMapUnmanaged(MatchingSection, *TextBlock) = .{},
+/// Pointer to the last allocated atom
+atoms: std.AutoHashMapUnmanaged(MatchingSection, *Atom) = .{},
 
-/// List of TextBlocks that are owned directly by the linker.
-/// Currently these are only TextBlocks that are the result of linking
-/// object files. TextBlock which take part in incremental linking are 
+/// List of atoms that are owned directly by the linker.
+/// Currently these are only atoms that are the result of linking
+/// object files. Atoms which take part in incremental linking are 
 /// at present owned by Module.Decl.
 /// TODO consolidate this.
-managed_blocks: std.ArrayListUnmanaged(*TextBlock) = .{},
+managed_atoms: std.ArrayListUnmanaged(*Atom) = .{},
 
 /// Table of Decls that are currently alive.
 /// We store them here so that we can properly dispose of any allocated
-/// memory within the TextBlock in the incremental linker.
+/// memory within the atom in the incremental linker.
 /// TODO consolidate this.
 decls: std.AutoArrayHashMapUnmanaged(*Module.Decl, void) = .{},
 
@@ -768,31 +768,8 @@ pub fn flush(self: *MachO, comp: *Compilation) !void {
         try self.addDataInCodeLC();
         try self.addCodeSignatureLC();
 
-        try self.parseTextBlocks();
+        try self.parseObjectsIntoAtoms();
         try self.allocateGlobalSymbols();
-        {
-            log.debug("locals:", .{});
-            for (self.locals.items) |sym| {
-                log.debug("  {s}: {}", .{ self.getString(sym.n_strx), sym });
-            }
-            log.debug("globals:", .{});
-            for (self.globals.items) |sym| {
-                log.debug("  {s}: {}", .{ self.getString(sym.n_strx), sym });
-            }
-            log.debug("undefs:", .{});
-            for (self.undefs.items) |sym| {
-                log.debug("  {s}: {}", .{ self.getString(sym.n_strx), sym });
-            }
-            log.debug("unresolved:", .{});
-            for (self.unresolved.keys()) |key| {
-                log.debug("  {d} => {s}", .{ key, self.unresolved.get(key).? });
-            }
-            log.debug("resolved:", .{});
-            var it = self.symbol_resolver.iterator();
-            while (it.next()) |entry| {
-                log.debug("  {s} => {}", .{ self.getString(entry.key_ptr.*), entry.value_ptr.* });
-            }
-        }
         try self.writeAtoms();
 
         if (self.bss_section_index) |idx| {
@@ -1637,87 +1614,24 @@ pub fn getMatchingSection(self: *MachO, sect: macho.section_64) !?MatchingSectio
     return res;
 }
 
-pub fn createEmptyAtom(self: *MachO, local_sym_index: u32, size: u64, alignment: u32) !*TextBlock {
+pub fn createEmptyAtom(self: *MachO, local_sym_index: u32, size: u64, alignment: u32) !*Atom {
     const code = try self.base.allocator.alloc(u8, size);
     defer self.base.allocator.free(code);
     mem.set(u8, code, 0);
 
-    const atom = try self.base.allocator.create(TextBlock);
+    const atom = try self.base.allocator.create(Atom);
     errdefer self.base.allocator.destroy(atom);
-    atom.* = TextBlock.empty;
+    atom.* = Atom.empty;
     atom.local_sym_index = local_sym_index;
     atom.size = size;
     atom.alignment = alignment;
     try atom.code.appendSlice(self.base.allocator, code);
-    try self.managed_blocks.append(self.base.allocator, atom);
+    try self.managed_atoms.append(self.base.allocator, atom);
 
     return atom;
 }
 
-pub fn allocateAtom(self: *MachO, atom: *TextBlock, match: MatchingSection) !u64 {
-    const seg = &self.load_commands.items[match.seg].Segment;
-    const sect = &seg.sections.items[match.sect];
-
-    const sym = &self.locals.items[atom.local_sym_index];
-    const needs_padding = match.seg == self.text_segment_cmd_index.? and match.sect == self.text_section_index.?;
-
-    var atom_placement: ?*TextBlock = null;
-    const atom_alignment = try math.powi(u32, 2, atom.alignment);
-
-    // TODO converge with `allocateTextBlock` and handle free list
-    var vaddr = if (self.blocks.get(match)) |last| blk: {
-        const last_atom_sym = self.locals.items[last.local_sym_index];
-        const ideal_capacity = if (needs_padding) padToIdeal(last.size) else last.size;
-        const ideal_capacity_end_vaddr = last_atom_sym.n_value + ideal_capacity;
-        const new_start_vaddr = mem.alignForwardGeneric(u64, ideal_capacity_end_vaddr, atom_alignment);
-        atom_placement = last;
-        break :blk new_start_vaddr;
-    } else mem.alignForwardGeneric(u64, sect.addr, atom_alignment);
-
-    // TODO what if the section which was preallocated is not aligned to the maximum (section) alignment?
-    // Should we move the section?
-
-    log.debug("allocating atom for symbol {s} at address 0x{x}", .{ self.getString(sym.n_strx), vaddr });
-
-    const expand_section = atom_placement == null or atom_placement.?.next == null;
-    if (expand_section) {
-        const needed_size = @intCast(u32, (vaddr + atom.size) - sect.addr);
-        try self.growSection(match, needed_size);
-        sect.size = needed_size;
-        self.load_commands_dirty = true;
-    }
-    sect.@"align" = math.max(sect.@"align", atom.alignment);
-
-    const n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
-    sym.n_value = vaddr;
-    sym.n_sect = n_sect;
-
-    // Update each alias (if any)
-    for (atom.aliases.items) |index| {
-        const alias_sym = &self.locals.items[index];
-        alias_sym.n_value = vaddr;
-        alias_sym.n_sect = n_sect;
-    }
-
-    // Update each symbol contained within the TextBlock
-    for (atom.contained.items) |sym_at_off| {
-        const contained_sym = &self.locals.items[sym_at_off.local_sym_index];
-        contained_sym.n_value = vaddr + sym_at_off.offset;
-        contained_sym.n_sect = n_sect;
-    }
-
-    if (self.blocks.getPtr(match)) |last| {
-        last.*.next = atom;
-        atom.prev = last.*;
-        last.* = atom;
-    } else {
-        try self.blocks.putNoClobber(self.base.allocator, match, atom);
-    }
-
-    return vaddr;
-}
-
-pub fn writeAtom(self: *MachO, atom: *TextBlock, match: MatchingSection) !void {
+pub fn writeAtom(self: *MachO, atom: *Atom, match: MatchingSection) !void {
     const seg = self.load_commands.items[match.seg].Segment;
     const sect = seg.sections.items[match.sect];
     const sym = self.locals.items[atom.local_sym_index];
@@ -1728,7 +1642,7 @@ pub fn writeAtom(self: *MachO, atom: *TextBlock, match: MatchingSection) !void {
 }
 
 fn allocateLocalSymbols(self: *MachO, match: MatchingSection, offset: i64) !void {
-    var atom = self.blocks.get(match) orelse return;
+    var atom = self.atoms.get(match) orelse return;
 
     while (true) {
         const atom_sym = &self.locals.items[atom.local_sym_index];
@@ -1751,8 +1665,6 @@ fn allocateLocalSymbols(self: *MachO, match: MatchingSection, offset: i64) !void
 }
 
 fn allocateGlobalSymbols(self: *MachO) !void {
-    // TODO should we do this in `allocateAtom` (or similar)? Then, we would need to
-    // store the link atom -> globals somewhere.
     var sym_it = self.symbol_resolver.valueIterator();
     while (sym_it.next()) |resolv| {
         if (resolv.where != .global) continue;
@@ -1770,12 +1682,14 @@ fn writeAtoms(self: *MachO) !void {
     defer buffer.deinit();
     var file_offset: ?u64 = null;
 
-    var it = self.blocks.iterator();
+    var it = self.atoms.iterator();
     while (it.next()) |entry| {
         const match = entry.key_ptr.*;
         const seg = self.load_commands.items[match.seg].Segment;
         const sect = seg.sections.items[match.sect];
-        var atom: *TextBlock = entry.value_ptr.*;
+        var atom: *Atom = entry.value_ptr.*;
+
+        log.debug("writing atoms in {s},{s}", .{ commands.segmentName(sect), commands.sectionName(sect) });
 
         while (atom.prev) |prev| {
             atom = prev;
@@ -1789,6 +1703,8 @@ fn writeAtoms(self: *MachO) !void {
                     break :blk next_sym.n_value - (atom_sym.n_value + atom.size);
                 } else 0;
 
+                log.debug("  (adding atom {s} to buffer: {})", .{ self.getString(atom_sym.n_strx), atom_sym });
+
                 try atom.resolveRelocs(self);
                 try buffer.appendSlice(atom.code.items);
                 try buffer.ensureUnusedCapacity(padding_size);
@@ -1824,7 +1740,7 @@ fn writeAtoms(self: *MachO) !void {
     }
 }
 
-pub fn createGotAtom(self: *MachO, key: GotIndirectionKey) !*TextBlock {
+pub fn createGotAtom(self: *MachO, key: GotIndirectionKey) !*Atom {
     const local_sym_index = @intCast(u32, self.locals.items.len);
     try self.locals.append(self.base.allocator, .{
         .n_strx = try self.makeString("l_zld_got_entry"),
@@ -1860,7 +1776,7 @@ pub fn createGotAtom(self: *MachO, key: GotIndirectionKey) !*TextBlock {
     return atom;
 }
 
-fn createDyldPrivateAtom(self: *MachO) !*TextBlock {
+fn createDyldPrivateAtom(self: *MachO) !*Atom {
     const local_sym_index = @intCast(u32, self.locals.items.len);
     try self.locals.append(self.base.allocator, .{
         .n_strx = try self.makeString("l_zld_dyld_private"),
@@ -1873,7 +1789,7 @@ fn createDyldPrivateAtom(self: *MachO) !*TextBlock {
     return self.createEmptyAtom(local_sym_index, @sizeOf(u64), 3);
 }
 
-fn createStubHelperPreambleAtom(self: *MachO) !*TextBlock {
+fn createStubHelperPreambleAtom(self: *MachO) !*Atom {
     const arch = self.base.options.target.cpu.arch;
     const size: u64 = switch (arch) {
         .x86_64 => 15,
@@ -2006,7 +1922,7 @@ fn createStubHelperPreambleAtom(self: *MachO) !*TextBlock {
     return atom;
 }
 
-pub fn createStubHelperAtom(self: *MachO) !*TextBlock {
+pub fn createStubHelperAtom(self: *MachO) !*Atom {
     const arch = self.base.options.target.cpu.arch;
     const stub_size: u4 = switch (arch) {
         .x86_64 => 10,
@@ -2072,7 +1988,7 @@ pub fn createStubHelperAtom(self: *MachO) !*TextBlock {
     return atom;
 }
 
-pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, lazy_binding_sym_index: u32) !*TextBlock {
+pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, lazy_binding_sym_index: u32) !*Atom {
     const local_sym_index = @intCast(u32, self.locals.items.len);
     try self.locals.append(self.base.allocator, .{
         .n_strx = try self.makeString("l_zld_lazy_ptr"),
@@ -2102,7 +2018,7 @@ pub fn createLazyPointerAtom(self: *MachO, stub_sym_index: u32, lazy_binding_sym
     return atom;
 }
 
-pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*TextBlock {
+pub fn createStubAtom(self: *MachO, laptr_sym_index: u32) !*Atom {
     const arch = self.base.options.target.cpu.arch;
     const alignment: u2 = switch (arch) {
         .x86_64 => 0,
@@ -2273,14 +2189,6 @@ fn resolveSymbolsInObject(
                     continue;
                 },
                 .undef => {
-                    // const undef = &self.undefs.items[resolv.where_index];
-                    // undef.* = .{
-                    //     .n_strx = 0,
-                    //     .n_type = macho.N_UNDF,
-                    //     .n_sect = 0,
-                    //     .n_desc = 0,
-                    //     .n_value = 0,
-                    // };
                     _ = self.unresolved.fetchSwapRemove(resolv.where_index);
                 },
             }
@@ -2437,23 +2345,36 @@ fn resolveSymbols(self: *MachO) !void {
         resolv.local_sym_index = local_sym_index;
 
         const atom = try self.createEmptyAtom(local_sym_index, size, alignment);
-        _ = try self.allocateAtom(atom, match);
+        const alignment_pow_2 = try math.powi(u32, 2, alignment);
+        const vaddr = try self.allocateAtom(atom, size, alignment_pow_2, match);
+        sym.n_value = vaddr;
     }
 
     try self.resolveDyldStubBinder();
     {
-        const atom = try self.createDyldPrivateAtom();
-        _ = try self.allocateAtom(atom, .{
+        const match = MatchingSection{
             .seg = self.data_segment_cmd_index.?,
             .sect = self.data_section_index.?,
-        });
+        };
+        const atom = try self.createDyldPrivateAtom();
+        const sym = &self.locals.items[atom.local_sym_index];
+        const vaddr = try self.allocateAtom(atom, @sizeOf(u64), 8, match);
+        sym.n_value = vaddr;
+        sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
+        log.debug("allocated {s} atom at 0x{x}", .{ self.getString(sym.n_strx), vaddr });
     }
     {
-        const atom = try self.createStubHelperPreambleAtom();
-        _ = try self.allocateAtom(atom, .{
+        const match = MatchingSection{
             .seg = self.text_segment_cmd_index.?,
             .sect = self.stub_helper_section_index.?,
-        });
+        };
+        const atom = try self.createStubHelperPreambleAtom();
+        const sym = &self.locals.items[atom.local_sym_index];
+        const alignment = try math.powi(u32, 2, atom.alignment);
+        const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
+        sym.n_value = vaddr;
+        sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
+        log.debug("allocated {s} atom at 0x{x}", .{ self.getString(sym.n_strx), vaddr });
     }
 
     // Third pass, resolve symbols in dynamic libraries.
@@ -2483,30 +2404,45 @@ fn resolveSymbols(self: *MachO) !void {
                     .stub => {
                         if (self.stubs_map.contains(resolv.where_index)) break :outer_blk;
                         const stub_helper_atom = blk: {
-                            const atom = try self.createStubHelperAtom();
-                            _ = try self.allocateAtom(atom, .{
+                            const match = MatchingSection{
                                 .seg = self.text_segment_cmd_index.?,
                                 .sect = self.stub_helper_section_index.?,
-                            });
+                            };
+                            const atom = try self.createStubHelperAtom();
+                            const atom_sym = &self.locals.items[atom.local_sym_index];
+                            const alignment = try math.powi(u32, 2, atom.alignment);
+                            const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
+                            atom_sym.n_value = vaddr;
+                            atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
                             break :blk atom;
                         };
                         const laptr_atom = blk: {
+                            const match = MatchingSection{
+                                .seg = self.data_segment_cmd_index.?,
+                                .sect = self.la_symbol_ptr_section_index.?,
+                            };
                             const atom = try self.createLazyPointerAtom(
                                 stub_helper_atom.local_sym_index,
                                 resolv.where_index,
                             );
-                            _ = try self.allocateAtom(atom, .{
-                                .seg = self.data_segment_cmd_index.?,
-                                .sect = self.la_symbol_ptr_section_index.?,
-                            });
+                            const atom_sym = &self.locals.items[atom.local_sym_index];
+                            const alignment = try math.powi(u32, 2, atom.alignment);
+                            const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
+                            atom_sym.n_value = vaddr;
+                            atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
                             break :blk atom;
                         };
                         const stub_atom = blk: {
-                            const atom = try self.createStubAtom(laptr_atom.local_sym_index);
-                            _ = try self.allocateAtom(atom, .{
+                            const match = MatchingSection{
                                 .seg = self.text_segment_cmd_index.?,
                                 .sect = self.stubs_section_index.?,
-                            });
+                            };
+                            const atom = try self.createStubAtom(laptr_atom.local_sym_index);
+                            const atom_sym = &self.locals.items[atom.local_sym_index];
+                            const alignment = try math.powi(u32, 2, atom.alignment);
+                            const vaddr = try self.allocateAtom(atom, atom.size, alignment, match);
+                            atom_sym.n_value = vaddr;
+                            atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
                             break :blk atom;
                         };
                         try self.stubs_map.putNoClobber(self.base.allocator, resolv.where_index, stub_atom);
@@ -2565,7 +2501,10 @@ fn resolveSymbols(self: *MachO) !void {
         // TODO perhaps we should special-case special symbols? Create a separate
         // linked list of atoms?
         const atom = try self.createEmptyAtom(local_sym_index, 0, 0);
-        _ = try self.allocateAtom(atom, match);
+        const sym = &self.locals.items[local_sym_index];
+        const vaddr = try self.allocateAtom(atom, 0, 1, match);
+        sym.n_value = vaddr;
+        atom.dirty = false; // We don't really want to write it to file.
     }
 
     for (self.unresolved.keys()) |index| {
@@ -2632,10 +2571,14 @@ fn resolveDyldStubBinder(self: *MachO) !void {
         .seg = self.data_const_segment_cmd_index.?,
         .sect = self.got_section_index.?,
     };
-    _ = try self.allocateAtom(atom, match);
+    const atom_sym = &self.locals.items[atom.local_sym_index];
+    const vaddr = try self.allocateAtom(atom, @sizeOf(u64), 8, match);
+    atom_sym.n_value = vaddr;
+    atom_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
+    log.debug("allocated {s} atom at 0x{x}", .{ self.getString(sym.n_strx), vaddr });
 }
 
-fn parseTextBlocks(self: *MachO) !void {
+fn parseObjectsIntoAtoms(self: *MachO) !void {
     var parsed_atoms = Object.ParsedAtoms.init(self.base.allocator);
     defer parsed_atoms.deinit();
 
@@ -2710,7 +2653,7 @@ fn parseTextBlocks(self: *MachO) !void {
             metadata.alignment,
         });
 
-        const sect_size = if (self.blocks.get(match)) |last| blk: {
+        const sect_size = if (self.atoms.get(match)) |last| blk: {
             const last_atom_sym = self.locals.items[last.local_sym_index];
             break :blk last_atom_sym.n_value + last.size - sect.addr;
         } else 0;
@@ -2720,7 +2663,7 @@ fn parseTextBlocks(self: *MachO) !void {
         try self.growSection(match, needed_size);
         sect.size = needed_size;
 
-        var base_vaddr = if (self.blocks.get(match)) |last| blk: {
+        var base_vaddr = if (self.atoms.get(match)) |last| blk: {
             const last_atom_sym = self.locals.items[last.local_sym_index];
             break :blk last_atom_sym.n_value + last.size;
         } else sect.addr;
@@ -2750,7 +2693,7 @@ fn parseTextBlocks(self: *MachO) !void {
                 alias_sym.n_sect = n_sect;
             }
 
-            // Update each symbol contained within the TextBlock
+            // Update each symbol contained within the atom
             for (atom.contained.items) |sym_at_off| {
                 const contained_sym = &self.locals.items[sym_at_off.local_sym_index];
                 contained_sym.n_value = base_vaddr + sym_at_off.offset;
@@ -2764,13 +2707,13 @@ fn parseTextBlocks(self: *MachO) !void {
             } else break;
         }
 
-        if (self.blocks.getPtr(match)) |last| {
+        if (self.atoms.getPtr(match)) |last| {
             const first_atom = first_atoms.get(match).?;
             last.*.next = first_atom;
             first_atom.prev = last.*;
             last.* = first_atom;
         }
-        _ = try self.blocks.put(self.base.allocator, match, parsed_atoms.get(match).?);
+        _ = try self.atoms.put(self.base.allocator, match, parsed_atoms.get(match).?);
     }
 }
 
@@ -2905,18 +2848,18 @@ pub fn deinit(self: *MachO) void {
     }
     self.load_commands.deinit(self.base.allocator);
 
-    for (self.managed_blocks.items) |block| {
-        block.deinit(self.base.allocator);
-        self.base.allocator.destroy(block);
+    for (self.managed_atoms.items) |atom| {
+        atom.deinit(self.base.allocator);
+        self.base.allocator.destroy(atom);
     }
-    self.managed_blocks.deinit(self.base.allocator);
-    self.blocks.deinit(self.base.allocator);
+    self.managed_atoms.deinit(self.base.allocator);
+    self.atoms.deinit(self.base.allocator);
     {
-        var it = self.block_free_lists.valueIterator();
+        var it = self.atom_free_lists.valueIterator();
         while (it.next()) |free_list| {
             free_list.deinit(self.base.allocator);
         }
-        self.block_free_lists.deinit(self.base.allocator);
+        self.atom_free_lists.deinit(self.base.allocator);
     }
     for (self.decls.keys()) |decl| {
         decl.link.macho.deinit(self.base.allocator);
@@ -2936,25 +2879,21 @@ pub fn closeFiles(self: MachO) void {
     }
 }
 
-fn freeTextBlock(self: *MachO, text_block: *TextBlock) void {
-    log.debug("freeTextBlock {*}", .{text_block});
-    text_block.deinit(self.base.allocator);
+fn freeAtom(self: *MachO, atom: *Atom, match: MatchingSection) void {
+    log.debug("freeAtom {*}", .{atom});
+    atom.deinit(self.base.allocator);
 
-    const match = MatchingSection{
-        .seg = self.text_segment_cmd_index.?,
-        .sect = self.text_section_index.?,
-    };
-    const text_block_free_list = self.block_free_lists.getPtr(match).?;
+    const free_list = self.atom_free_lists.getPtr(match).?;
     var already_have_free_list_node = false;
     {
         var i: usize = 0;
-        // TODO turn text_block_free_list into a hash map
-        while (i < text_block_free_list.items.len) {
-            if (text_block_free_list.items[i] == text_block) {
-                _ = text_block_free_list.swapRemove(i);
+        // TODO turn free_list into a hash map
+        while (i < free_list.items.len) {
+            if (free_list.items[i] == atom) {
+                _ = free_list.swapRemove(i);
                 continue;
             }
-            if (text_block_free_list.items[i] == text_block.prev) {
+            if (free_list.items[i] == atom.prev) {
                 already_have_free_list_node = true;
             }
             i += 1;
@@ -2962,72 +2901,73 @@ fn freeTextBlock(self: *MachO, text_block: *TextBlock) void {
     }
     // TODO process free list for dbg info just like we do above for vaddrs
 
-    if (self.blocks.getPtr(match)) |last_text_block| {
-        if (last_text_block.* == text_block) {
-            if (text_block.prev) |prev| {
-                // TODO shrink the __text section size here
-                last_text_block.* = prev;
+    if (self.atoms.getPtr(match)) |last_atom| {
+        if (last_atom.* == atom) {
+            if (atom.prev) |prev| {
+                // TODO shrink the section size here
+                last_atom.* = prev;
             }
         }
     }
 
     if (self.d_sym) |*ds| {
-        if (ds.dbg_info_decl_first == text_block) {
-            ds.dbg_info_decl_first = text_block.dbg_info_next;
+        if (ds.dbg_info_decl_first == atom) {
+            ds.dbg_info_decl_first = atom.dbg_info_next;
         }
-        if (ds.dbg_info_decl_last == text_block) {
+        if (ds.dbg_info_decl_last == atom) {
             // TODO shrink the .debug_info section size here
-            ds.dbg_info_decl_last = text_block.dbg_info_prev;
+            ds.dbg_info_decl_last = atom.dbg_info_prev;
         }
     }
 
-    if (text_block.prev) |prev| {
-        prev.next = text_block.next;
+    if (atom.prev) |prev| {
+        prev.next = atom.next;
 
         if (!already_have_free_list_node and prev.freeListEligible(self.*)) {
             // The free list is heuristics, it doesn't have to be perfect, so we can ignore
             // the OOM here.
-            text_block_free_list.append(self.base.allocator, prev) catch {};
+            free_list.append(self.base.allocator, prev) catch {};
         }
     } else {
-        text_block.prev = null;
+        atom.prev = null;
     }
 
-    if (text_block.next) |next| {
-        next.prev = text_block.prev;
+    if (atom.next) |next| {
+        next.prev = atom.prev;
     } else {
-        text_block.next = null;
+        atom.next = null;
     }
 
-    if (text_block.dbg_info_prev) |prev| {
-        prev.dbg_info_next = text_block.dbg_info_next;
+    if (atom.dbg_info_prev) |prev| {
+        prev.dbg_info_next = atom.dbg_info_next;
 
-        // TODO the free list logic like we do for text blocks above
+        // TODO the free list logic like we do for atoms above
     } else {
-        text_block.dbg_info_prev = null;
+        atom.dbg_info_prev = null;
     }
 
-    if (text_block.dbg_info_next) |next| {
-        next.dbg_info_prev = text_block.dbg_info_prev;
+    if (atom.dbg_info_next) |next| {
+        next.dbg_info_prev = atom.dbg_info_prev;
     } else {
-        text_block.dbg_info_next = null;
+        atom.dbg_info_next = null;
     }
 }
 
-fn shrinkTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64) void {
+fn shrinkAtom(self: *MachO, atom: *Atom, new_block_size: u64, match: MatchingSection) void {
     _ = self;
-    _ = text_block;
+    _ = atom;
     _ = new_block_size;
+    _ = match;
     // TODO check the new capacity, and if it crosses the size threshold into a big enough
     // capacity, insert a free list node for it.
 }
 
-fn growTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
-    const sym = self.locals.items[text_block.local_sym_index];
+fn growAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64, match: MatchingSection) !u64 {
+    const sym = self.locals.items[atom.local_sym_index];
     const align_ok = mem.alignBackwardGeneric(u64, sym.n_value, alignment) == sym.n_value;
-    const need_realloc = !align_ok or new_block_size > text_block.capacity(self.*);
+    const need_realloc = !align_ok or new_atom_size > atom.capacity(self.*);
     if (!need_realloc) return sym.n_value;
-    return self.allocateTextBlock(text_block, new_block_size, alignment);
+    return self.allocateAtom(atom, new_atom_size, alignment, match);
 }
 
 pub fn allocateDeclIndexes(self: *MachO, decl: *Module.Decl) !void {
@@ -3112,7 +3052,7 @@ pub fn updateFunc(self: *MachO, module: *Module, func: *Module.Fn, air: Air, liv
             // in a different, smarter, more automatic way somewhere else, in a more centralised
             // way than this.
             // If we don't clear the buffers here, we are up for some nasty surprises when
-            // this TextBlock is reused later on and was not freed by freeTextBlock().
+            // this atom is reused later on and was not freed by freeAtom().
             decl.link.macho.code.clearAndFree(self.base.allocator);
             try decl.link.macho.code.appendSlice(self.base.allocator, code_buffer.items);
         },
@@ -3202,7 +3142,7 @@ pub fn updateDecl(self: *MachO, module: *Module, decl: *Module.Decl) !void {
                 // in a different, smarter, more automatic way somewhere else, in a more centralised
                 // way than this.
                 // If we don't clear the buffers here, we are up for some nasty surprises when
-                // this TextBlock is reused later on and was not freed by freeTextBlock().
+                // this atom is reused later on and was not freed by freeAtom().
                 decl.link.macho.code.clearAndFree(self.base.allocator);
                 try decl.link.macho.code.appendSlice(self.base.allocator, code_buffer.items);
                 break :blk decl.link.macho.code.items;
@@ -3231,7 +3171,10 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
         const capacity = decl.link.macho.capacity(self.*);
         const need_realloc = code_len > capacity or !mem.isAlignedGeneric(u64, symbol.n_value, required_alignment);
         if (need_realloc) {
-            const vaddr = try self.growTextBlock(&decl.link.macho, code_len, required_alignment);
+            const vaddr = try self.growAtom(&decl.link.macho, code_len, required_alignment, .{
+                .seg = self.text_segment_cmd_index.?,
+                .sect = self.text_section_index.?,
+            });
 
             log.debug("growing {s} and moving from 0x{x} to 0x{x}", .{ decl.name, symbol.n_value, vaddr });
 
@@ -3241,15 +3184,24 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
                     .where = .local,
                     .where_index = decl.link.macho.local_sym_index,
                 }) orelse unreachable;
-                _ = try self.allocateAtom(got_atom, .{
+                const got_sym = &self.locals.items[got_atom.local_sym_index];
+                const got_vaddr = try self.allocateAtom(got_atom, @sizeOf(u64), 8, .{
                     .seg = self.data_const_segment_cmd_index.?,
                     .sect = self.got_section_index.?,
                 });
+                got_sym.n_value = got_vaddr;
+                got_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(.{
+                    .seg = self.data_const_segment_cmd_index.?,
+                    .sect = self.got_section_index.?,
+                }).? + 1);
             }
 
             symbol.n_value = vaddr;
         } else if (code_len < decl.link.macho.size) {
-            self.shrinkTextBlock(&decl.link.macho, code_len);
+            self.shrinkAtom(&decl.link.macho, code_len, .{
+                .seg = self.text_segment_cmd_index.?,
+                .sect = self.text_section_index.?,
+            });
         }
         decl.link.macho.size = code_len;
 
@@ -3265,11 +3217,17 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
         defer self.base.allocator.free(decl_name);
 
         const name_str_index = try self.makeString(decl_name);
-        const addr = try self.allocateTextBlock(&decl.link.macho, code_len, required_alignment);
+        const addr = try self.allocateAtom(&decl.link.macho, code_len, required_alignment, .{
+            .seg = self.text_segment_cmd_index.?,
+            .sect = self.text_section_index.?,
+        });
 
-        log.debug("allocated text block for {s} at 0x{x}", .{ decl_name, addr });
+        log.debug("allocated atom for {s} at 0x{x}", .{ decl_name, addr });
 
-        errdefer self.freeTextBlock(&decl.link.macho);
+        errdefer self.freeAtom(&decl.link.macho, .{
+            .seg = self.text_segment_cmd_index.?,
+            .sect = self.text_section_index.?,
+        });
 
         symbol.* = .{
             .n_strx = name_str_index,
@@ -3282,10 +3240,16 @@ fn placeDecl(self: *MachO, decl: *Module.Decl, code_len: usize) !*macho.nlist_64
             .where = .local,
             .where_index = decl.link.macho.local_sym_index,
         }) orelse unreachable;
-        _ = try self.allocateAtom(got_atom, .{
+        const got_sym = &self.locals.items[got_atom.local_sym_index];
+        const vaddr = try self.allocateAtom(got_atom, @sizeOf(u64), 8, .{
             .seg = self.data_const_segment_cmd_index.?,
             .sect = self.got_section_index.?,
         });
+        got_sym.n_value = vaddr;
+        got_sym.n_sect = @intCast(u8, self.section_ordinals.getIndex(.{
+            .seg = self.data_const_segment_cmd_index.?,
+            .sect = self.got_section_index.?,
+        }).? + 1);
     }
 
     return symbol;
@@ -3402,7 +3366,10 @@ pub fn freeDecl(self: *MachO, decl: *Module.Decl) void {
     log.debug("freeDecl {*}", .{decl});
     _ = self.decls.swapRemove(decl);
     // Appending to free lists is allowed to fail because the free lists are heuristics based anyway.
-    self.freeTextBlock(&decl.link.macho);
+    self.freeAtom(&decl.link.macho, .{
+        .seg = self.text_segment_cmd_index.?,
+        .sect = self.text_section_index.?,
+    });
     if (decl.link.macho.local_sym_index != 0) {
         self.locals_free_list.append(self.base.allocator, decl.link.macho.local_sym_index) catch {};
 
@@ -3412,7 +3379,7 @@ pub fn freeDecl(self: *MachO, decl: *Module.Decl) void {
         decl.link.macho.local_sym_index = 0;
     }
     if (self.d_sym) |*ds| {
-        // TODO make this logic match freeTextBlock. Maybe abstract the logic
+        // TODO make this logic match freeAtom. Maybe abstract the logic
         // out since the same thing is desired for both.
         _ = ds.dbg_line_fn_free_list.remove(&decl.fn_link.macho);
         if (decl.fn_link.macho.prev) |prev| {
@@ -3947,7 +3914,7 @@ fn allocateSection(
         .sect = index,
     };
     _ = try self.section_ordinals.getOrPut(self.base.allocator, match);
-    try self.block_free_lists.putNoClobber(self.base.allocator, match, .{});
+    try self.atom_free_lists.putNoClobber(self.base.allocator, match, .{});
 
     self.load_commands_dirty = true;
     self.sections_order_dirty = true;
@@ -4113,106 +4080,105 @@ fn getSectionMaxAlignment(self: *MachO, segment_id: u16, start_sect_id: u16) !u3
     return max_alignment;
 }
 
-fn allocateTextBlock(self: *MachO, text_block: *TextBlock, new_block_size: u64, alignment: u64) !u64 {
-    const text_segment = &self.load_commands.items[self.text_segment_cmd_index.?].Segment;
-    const text_section = &text_segment.sections.items[self.text_section_index.?];
-    const match = MatchingSection{
-        .seg = self.text_segment_cmd_index.?,
-        .sect = self.text_section_index.?,
-    };
-    var text_block_free_list = self.block_free_lists.get(match).?;
-    const new_block_ideal_capacity = padToIdeal(new_block_size);
+fn allocateAtom(self: *MachO, atom: *Atom, new_atom_size: u64, alignment: u64, match: MatchingSection) !u64 {
+    const seg = &self.load_commands.items[match.seg].Segment;
+    const sect = &seg.sections.items[match.sect];
+    var free_list = self.atom_free_lists.get(match).?;
+    const needs_padding = match.seg == self.text_segment_cmd_index.? and match.sect == self.text_section_index.?;
+    const new_atom_ideal_capacity = if (needs_padding) padToIdeal(new_atom_size) else new_atom_size;
 
-    // We use these to indicate our intention to update metadata, placing the new block,
+    // We use these to indicate our intention to update metadata, placing the new atom,
     // and possibly removing a free list node.
     // It would be simpler to do it inside the for loop below, but that would cause a
     // problem if an error was returned later in the function. So this action
     // is actually carried out at the end of the function, when errors are no longer possible.
-    var block_placement: ?*TextBlock = null;
+    var atom_placement: ?*Atom = null;
     var free_list_removal: ?usize = null;
 
     // First we look for an appropriately sized free list node.
     // The list is unordered. We'll just take the first thing that works.
     var vaddr = blk: {
         var i: usize = 0;
-        while (i < text_block_free_list.items.len) {
-            const big_block = text_block_free_list.items[i];
-            // We now have a pointer to a live text block that has too much capacity.
-            // Is it enough that we could fit this new text block?
-            const sym = self.locals.items[big_block.local_sym_index];
-            const capacity = big_block.capacity(self.*);
-            const ideal_capacity = padToIdeal(capacity);
+        while (i < free_list.items.len) {
+            const big_atom = free_list.items[i];
+            // We now have a pointer to a live atom that has too much capacity.
+            // Is it enough that we could fit this new atom?
+            const sym = self.locals.items[big_atom.local_sym_index];
+            const capacity = big_atom.capacity(self.*);
+            const ideal_capacity = if (needs_padding) padToIdeal(capacity) else capacity;
             const ideal_capacity_end_vaddr = sym.n_value + ideal_capacity;
             const capacity_end_vaddr = sym.n_value + capacity;
-            const new_start_vaddr_unaligned = capacity_end_vaddr - new_block_ideal_capacity;
+            const new_start_vaddr_unaligned = capacity_end_vaddr - new_atom_ideal_capacity;
             const new_start_vaddr = mem.alignBackwardGeneric(u64, new_start_vaddr_unaligned, alignment);
             if (new_start_vaddr < ideal_capacity_end_vaddr) {
                 // Additional bookkeeping here to notice if this free list node
-                // should be deleted because the block that it points to has grown to take up
+                // should be deleted because the atom that it points to has grown to take up
                 // more of the extra capacity.
-                if (!big_block.freeListEligible(self.*)) {
-                    const bl = text_block_free_list.swapRemove(i);
+                if (!big_atom.freeListEligible(self.*)) {
+                    const bl = free_list.swapRemove(i);
                     bl.deinit(self.base.allocator);
                 } else {
                     i += 1;
                 }
                 continue;
             }
-            // At this point we know that we will place the new block here. But the
+            // At this point we know that we will place the new atom here. But the
             // remaining question is whether there is still yet enough capacity left
             // over for there to still be a free list node.
             const remaining_capacity = new_start_vaddr - ideal_capacity_end_vaddr;
             const keep_free_list_node = remaining_capacity >= min_text_capacity;
 
             // Set up the metadata to be updated, after errors are no longer possible.
-            block_placement = big_block;
+            atom_placement = big_atom;
             if (!keep_free_list_node) {
                 free_list_removal = i;
             }
             break :blk new_start_vaddr;
-        } else if (self.blocks.get(match)) |last| {
+        } else if (self.atoms.get(match)) |last| {
             const last_symbol = self.locals.items[last.local_sym_index];
-            // TODO We should pad out the excess capacity with NOPs. For executables,
-            // no padding seems to be OK, but it will probably not be for objects.
-            const ideal_capacity = padToIdeal(last.size);
+            const ideal_capacity = if (needs_padding) padToIdeal(last.size) else last.size;
             const ideal_capacity_end_vaddr = last_symbol.n_value + ideal_capacity;
             const new_start_vaddr = mem.alignForwardGeneric(u64, ideal_capacity_end_vaddr, alignment);
-            block_placement = last;
+            atom_placement = last;
             break :blk new_start_vaddr;
         } else {
-            break :blk text_section.addr;
+            break :blk mem.alignForwardGeneric(u64, sect.addr, alignment);
         }
     };
 
-    const expand_text_section = block_placement == null or block_placement.?.next == null;
-    if (expand_text_section) {
-        const needed_size = @intCast(u32, (vaddr + new_block_size) - text_section.addr);
+    const expand_section = atom_placement == null or atom_placement.?.next == null;
+    if (expand_section) {
+        const needed_size = @intCast(u32, (vaddr + new_atom_size) - sect.addr);
         try self.growSection(match, needed_size);
-        _ = try self.blocks.put(self.base.allocator, match, text_block);
-        text_section.size = needed_size;
+        _ = try self.atoms.put(self.base.allocator, match, atom);
+        sect.size = needed_size;
         self.load_commands_dirty = true;
     }
     const align_pow = @intCast(u32, math.log2(alignment));
-    text_section.@"align" = math.max(text_section.@"align", align_pow);
-    text_block.size = new_block_size;
-
-    if (text_block.prev) |prev| {
-        prev.next = text_block.next;
+    if (sect.@"align" < align_pow) {
+        sect.@"align" = align_pow;
+        self.load_commands_dirty = true;
     }
-    if (text_block.next) |next| {
-        next.prev = text_block.prev;
+    atom.size = new_atom_size;
+    atom.alignment = align_pow;
+
+    if (atom.prev) |prev| {
+        prev.next = atom.next;
+    }
+    if (atom.next) |next| {
+        next.prev = atom.prev;
     }
 
-    if (block_placement) |big_block| {
-        text_block.prev = big_block;
-        text_block.next = big_block.next;
-        big_block.next = text_block;
+    if (atom_placement) |big_atom| {
+        atom.prev = big_atom;
+        atom.next = big_atom.next;
+        big_atom.next = atom;
     } else {
-        text_block.prev = null;
-        text_block.next = null;
+        atom.prev = null;
+        atom.next = null;
     }
     if (free_list_removal) |i| {
-        _ = text_block_free_list.swapRemove(i);
+        _ = free_list.swapRemove(i);
     }
 
     return vaddr;
@@ -4319,10 +4285,10 @@ fn writeDyldInfoData(self: *MachO) !void {
     defer lazy_bind_pointers.deinit();
 
     {
-        var it = self.blocks.iterator();
+        var it = self.atoms.iterator();
         while (it.next()) |entry| {
             const match = entry.key_ptr.*;
-            var atom: *TextBlock = entry.value_ptr.*;
+            var atom: *Atom = entry.value_ptr.*;
 
             if (match.seg == self.text_segment_cmd_index.?) continue; // __TEXT is non-writable
 
@@ -4444,7 +4410,7 @@ fn writeDyldInfoData(self: *MachO) !void {
 }
 
 fn populateLazyBindOffsetsInStubHelper(self: *MachO, buffer: []const u8) !void {
-    const last_atom = self.blocks.get(.{
+    const last_atom = self.atoms.get(.{
         .seg = self.text_segment_cmd_index.?,
         .sect = self.stub_helper_section_index.?,
     }) orelse return;
@@ -4538,25 +4504,25 @@ fn writeDices(self: *MachO) !void {
     var buf = std.ArrayList(u8).init(self.base.allocator);
     defer buf.deinit();
 
-    var block: *TextBlock = self.blocks.get(.{
+    var atom: *Atom = self.atoms.get(.{
         .seg = self.text_segment_cmd_index orelse return,
         .sect = self.text_section_index orelse return,
     }) orelse return;
 
-    while (block.prev) |prev| {
-        block = prev;
+    while (atom.prev) |prev| {
+        atom = prev;
     }
 
     const text_seg = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
     const text_sect = text_seg.sections.items[self.text_section_index.?];
 
     while (true) {
-        if (block.dices.items.len > 0) {
-            const sym = self.locals.items[block.local_sym_index];
+        if (atom.dices.items.len > 0) {
+            const sym = self.locals.items[atom.local_sym_index];
             const base_off = try math.cast(u32, sym.n_value - text_sect.addr + text_sect.offset);
 
-            try buf.ensureUnusedCapacity(block.dices.items.len * @sizeOf(macho.data_in_code_entry));
-            for (block.dices.items) |dice| {
+            try buf.ensureUnusedCapacity(atom.dices.items.len * @sizeOf(macho.data_in_code_entry));
+            for (atom.dices.items) |dice| {
                 const rebased_dice = macho.data_in_code_entry{
                     .offset = base_off + dice.offset,
                     .length = dice.length,
@@ -4566,8 +4532,8 @@ fn writeDices(self: *MachO) !void {
             }
         }
 
-        if (block.next) |next| {
-            block = next;
+        if (atom.next) |next| {
+            atom = next;
         } else break;
     }