@@ -229,6 +229,45 @@ public void ReadsAndWritesAUniversalBinary()
         ByteArrayAssert.AreEqual(original, output.ToArray(), "Invalid binary diff for helloworld_fat after read -> write");
     }
 
+    /// <summary>
+    /// A computed layout has to reproduce an image nobody touched, byte for byte. If packing the
+    /// __LINKEDIT tables in place gives back the original, the computation agrees with what the
+    /// linker did, and only then is it safe to use on an image that has been changed.
+    /// </summary>
+    [TestMethod]
+    [DataRow("helloworld_x86_64")]
+    [DataRow("helloworld_arm64")]
+    [DataRow("chainedfixups_arm64")]
+    [DataRow("libhelloworld_x86_64.dylib")]
+    [DataRow("unixthread_i386")]
+    [DataRow("dyldinfo_i386")]
+    public void ComputedLayoutReproducesAnUntouchedImage(string name)
+    {
+        var original = File.ReadAllBytes(GetFile(name));
+
+        var file = MachOFile.Read(new MemoryStream(original));
+        file.UpdateLinkEditLayout();
+
+        ByteArrayAssert.AreEqual(original, WriteToArray(file), $"Recomputing the layout of {name} changed it");
+    }
+
+    /// <summary>
+    /// An object file keeps its tables past the end of its only segment, so there is no
+    /// __LINKEDIT to lay out and the attempt has to leave the image alone rather than misplace
+    /// tables it cannot see.
+    /// </summary>
+    [TestMethod]
+    public void ComputingTheLayoutOfAnObjectFileDoesNothing()
+    {
+        var original = File.ReadAllBytes(GetFile("helloworld_x86_64.o"));
+
+        var file = MachOFile.Read(new MemoryStream(original));
+        Assert.IsNull(file.FindSegment("__LINKEDIT"));
+        file.UpdateLinkEditLayout();
+
+        ByteArrayAssert.AreEqual(original, WriteToArray(file), "Recomputing the layout of an object file changed it");
+    }
+
     [TestMethod]
     public void RejectsANonMachOStream()
     {
 
@@ -0,0 +1,154 @@
+// Copyright (c) Alexandre Mutel. All rights reserved.
+// This file is licensed under the BSD-Clause 2 license.
+// See the license.txt file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using LibObjectFile.MachO.CodeSign;
+
+namespace LibObjectFile.MachO;
+
+partial class MachOFile
+{
+    /// <summary>
+    /// Recomputes where everything in <c>__LINKEDIT</c> sits, packing the tables in their current
+    /// order and resizing the segment around them.
+    /// </summary>
+    /// <remarks>
+    /// This is the only part of an image whose layout can be computed. A section's address is its
+    /// segment's address plus its distance from the segment's file offset, so moving a section
+    /// moves its address and invalidates everything referring to it. Nothing addresses
+    /// <c>__LINKEDIT</c> that way: the loader reaches its tables only through the file offsets in
+    /// the load commands, which is why they can be repacked and those offsets rewritten.
+    /// <para>
+    /// The spacing a linker left between tables is kept rather than derived, because linkers do
+    /// not agree on it: lld aligns the string table to a pointer while ld64 packs it against
+    /// whatever precedes it, so no single rule reproduces both. Each table keeps the gap that
+    /// preceded it and the offsets are recomputed around those gaps, which reproduces an
+    /// untouched image exactly and still lays out correctly once something has resized. The code
+    /// signature is aligned on top of that, since 16-byte alignment is required of it rather
+    /// than a matter of style.
+    /// </para>
+    /// </remarks>
+    public void UpdateLinkEditLayout()
+    {
+        var linkEdit = FindSegment("__LINKEDIT");
+        if (linkEdit?.Content is null) return;
+
+        var blobs = CollectLinkEditBlobs();
+        if (blobs.Count == 0) return;
+
+        // Read the current bytes before any offset is rewritten.
+        var contents = new byte[blobs.Count][];
+        for (var i = 0; i < blobs.Count; i++)
+        {
+            contents[i] = ReadFileBytes(blobs[i].Offset, blobs[i].Size, "a __LINKEDIT table");
+        }
+
+        var content = new MemoryStream();
+        var cursor = (uint)linkEdit.FileOffset;
+
+        for (var i = 0; i < blobs.Count; i++)
+        {
+            var blob = blobs[i];
+
+            var target = cursor + blob.PrecedingGap;
+            if (blob.Alignment > 1)
+            {
+                target = (target + blob.Alignment - 1) & ~(blob.Alignment - 1);
+            }
+
+            content.Write(new byte[target - cursor]);
+            cursor = target;
+
+            blob.SetOffset(cursor);
+            content.Write(contents[i]);
+            cursor += blob.Size;
+        }
+
+        linkEdit.Content = content;
+        linkEdit.ContentFileOffset = linkEdit.FileOffset;
+        linkEdit.FileSize = cursor - linkEdit.FileOffset;
+        linkEdit.VmSize = Math.Max(linkEdit.VmSize, linkEdit.FileSize);
+    }
+
+    /// <summary>
+    /// A table inside <c>__LINKEDIT</c>, paired with the way to record where it ends up.
+    /// </summary>
+    private readonly record struct LinkEditBlob(uint Offset, uint Size, uint Alignment, Action<uint> SetOffset)
+    {
+        /// <summary>
+        /// Gets or sets the bytes that separated this table from the one before it. Preserving
+        /// this is what lets an untouched image come back out unchanged whichever linker built it.
+        /// </summary>
+        public uint PrecedingGap { get; init; }
+    }
+
+    /// <summary>
+    /// Gathers the tables the load commands point at, in the order they currently sit in the
+    /// file. Sizes are counts in most commands, so each is converted to bytes here.
+    /// </summary>
+    private List<LinkEditBlob> CollectLinkEditBlobs()
+    {
+        var blobs = new List<LinkEditBlob>();
+
+        foreach (var command in LoadCommands)
+        {
+            switch (command)
+            {
+                case MachOSymbolTableCommand symtab:
+                    Add(symtab.SymbolOffset, symtab.SymbolCount * MachOSymbolTableCommand.GetSymbolSize(Is64Bit), 1, o => symtab.SymbolOffset = o);
+                    Add(symtab.StringOffset, symtab.StringSize, 1, o => symtab.StringOffset = o);
+                    break;
+
+                case MachODynamicSymbolTableCommand dysymtab:
+                    Add(dysymtab.TableOfContentsOffset, dysymtab.TableOfContentsCount * 8, 1, o => dysymtab.TableOfContentsOffset = o);
+                    Add(dysymtab.ModuleTableOffset, dysymtab.ModuleTableCount * (Is64Bit ? 56u : 52u), 1, o => dysymtab.ModuleTableOffset = o);
+                    Add(dysymtab.ExternalReferenceOffset, dysymtab.ExternalReferenceCount * 4, 1, o => dysymtab.ExternalReferenceOffset = o);
+                    Add(dysymtab.IndirectSymbolOffset, dysymtab.IndirectSymbolCount * 4, 1, o => dysymtab.IndirectSymbolOffset = o);
+                    Add(dysymtab.ExternalRelocationOffset, dysymtab.ExternalRelocationCount * 8, 1, o => dysymtab.ExternalRelocationOffset = o);
+                    Add(dysymtab.LocalRelocationOffset, dysymtab.LocalRelocationCount * 8, 1, o => dysymtab.LocalRelocationOffset = o);
+                    break;
+
+                case MachODyldInfoCommand dyldInfo:
+                    Add(dyldInfo.RebaseOffset, dyldInfo.RebaseSize, 1, o => dyldInfo.RebaseOffset = o);
+                    Add(dyldInfo.BindOffset, dyldInfo.BindSize, 1, o => dyldInfo.BindOffset = o);
+                    Add(dyldInfo.WeakBindOffset, dyldInfo.WeakBindSize, 1, o => dyldInfo.WeakBindOffset = o);
+                    Add(dyldInfo.LazyBindOffset, dyldInfo.LazyBindSize, 1, o => dyldInfo.LazyBindOffset = o);
+                    Add(dyldInfo.ExportOffset, dyldInfo.ExportSize, 1, o => dyldInfo.ExportOffset = o);
+                    break;
+
+                case MachOLinkEditDataCommand data:
+                    // The signature is located as a blob starting on a 16-byte boundary.
+                    var alignment = data.Type == MachOLoadCommandType.CodeSignature ? (uint)MachOCodeSignatureConstants.SignatureAlignment : 1u;
+                    Add(data.DataOffset, data.DataSize, alignment, o => data.DataOffset = o);
+                    break;
+
+                case MachOTwoLevelHintsCommand hints:
+                    Add(hints.Offset, hints.HintCount * 4, 1, o => hints.Offset = o);
+                    break;
+            }
+        }
+
+        blobs.Sort((left, right) => left.Offset.CompareTo(right.Offset));
+
+        // Record what separated each table from the one before it, now that they are in order.
+        var previousEnd = (uint)(FindSegment("__LINKEDIT")?.FileOffset ?? 0);
+        for (var i = 0; i < blobs.Count; i++)
+        {
+            blobs[i] = blobs[i] with { PrecedingGap = blobs[i].Offset > previousEnd ? blobs[i].Offset - previousEnd : 0 };
+            previousEnd = blobs[i].Offset + blobs[i].Size;
+        }
+
+        return blobs;
+
+        void Add(uint offset, uint size, uint alignment, Action<uint> setOffset)
+        {
+            // An offset of zero means the table is absent rather than at the start of the file.
+            if (offset == 0 || size == 0) return;
+            blobs.Add(new LinkEditBlob(offset, size, alignment, setOffset));
+        }
+    }
+}