Commit 7ece5e656da5cdd991f9fd1cb289f71c586a9210 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-08-24 08:39:50+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-08-24 20:42:40+01:00
log	7ece5e656da5cdd991f9fd1cb289f71c586a9210
tree	1b45d684c0f3548f263cb020c7ce1594aceb3070
parent	96c9ff1c93532e7c2764449e0cd6f39d4dce2285
signature	Commit is signed but in an unrecognized format.

link.MappedFile: remove unnecessary child iterator

There are now functions for `first`, `last`, `prev`, and `next`, so
there is no need for a separate abstraction wrapping a simple linked
list iteration.

3 files changed, 56 insertions(+), 64 deletions(-)

src
- link

src/link/Coff.zig+40-35

 @@ -3546,16 +3546,20 @@ fn objectSectionMapIndex(
         try coff.symbols.ensureUnusedCapacity(gpa, 1);
         const parent_ni = parent.node(coff);
         var prev_oni: MappedFile.Node.Index.Optional = .none;
-        var next_it = parent_ni.children(&coff.mf);
+        {
-        while (next_it.next()) |next_ni| switch (std.mem.order(
+            var child_oni = parent_ni.first(&coff.mf);
-            u8,
+            while (child_oni.unwrap()) |child_ni| : (child_oni = child_ni.next(&coff.mf)) {
-            name_slice,
+                switch (std.mem.order(
-            coff.getNode(next_ni).object_section.name(coff).toSlice(coff),
+                    u8,
-        )) {
+                    name_slice,
-            .lt => break,
+                    coff.getNode(child_ni).object_section.name(coff).toSlice(coff),
-            .eq => unreachable,
+                )) {
-            .gt => prev_oni = .wrap(next_ni),
+                    .lt => break,
-        };
+                    .eq => unreachable,
+                    .gt => prev_oni = .wrap(child_ni),
+                }
+            }
+        }
         const ni = try parent_ni.addHeaderChildAfter(&coff.mf, gpa, prev_oni, .{
             .alignment = alignment,
         });
 @@ -7025,7 +7029,7 @@ fn flushResized(coff: *Coff, ni: MappedFile.Node.Index) !void {
             if (coff.isArchive() and coff.members.items.len > 0) {
                 const last_member = coff.members.items[coff.members.items.len - 1];
                 // See .archive_member branch for reasoning
-                assert(Node.known.file.reverseChildren(&coff.mf).ni == last_member.content_ni.toOptional());
+                assert(Node.known.file.last(&coff.mf).unwrap().? == last_member.content_ni);
                 try coff.flushResized(last_member.content_ni);
             }
         },
 @@ -7717,30 +7721,31 @@ pub fn printNode(
             if (mf_node.flags.has_content) " has_content" else "",
         });
     }
-    var leaf = true;
+    if (ni.first(&coff.mf).unwrap()) |first_ni| {
-    var child_it = ni.children(&coff.mf);
+        // non-leaf, just print children
-    while (child_it.next()) |child_ni| {
+        var child_ni = first_ni;
-        leaf = false;
+        while (true) {
-        try coff.printNode(tid, w, child_ni, indent + 1);
+            try coff.printNode(tid, w, child_ni, indent + 1);
-    }
+            child_ni = child_ni.next(&coff.mf).unwrap() orelse break;
-    if (leaf) {
-        const file_loc = ni.fileLocation(&coff.mf, false);
-        if (file_loc.size == 0) return;
-        var address = file_loc.offset;
-        const line_len = 0x10;
-        var line_it = std.mem.window(
-            u8,
-            coff.mf.memory_map.memory[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)],
-            line_len,
-            line_len,
-        );
-        while (line_it.next()) |line_bytes| : (address += line_len) {
-            try w.splatByteAll(' ', indent + 1);
-            try w.print("{x:0>8}  ", .{address});
-            for (line_bytes) |byte| try w.print("{x:0>2} ", .{byte});
-            try w.splatByteAll(' ', 3 * (line_len - line_bytes.len) + 1);
-            for (line_bytes) |byte| try w.writeByte(if (std.ascii.isPrint(byte)) byte else '.');
-            try w.writeByte('\n');
         }
+        return;
+    }
+    const file_loc = ni.fileLocation(&coff.mf, false);
+    if (file_loc.size == 0) return;
+    var address = file_loc.offset;
+    const line_len = 0x10;
+    var line_it = std.mem.window(
+        u8,
+        coff.mf.memory_map.memory[@intCast(file_loc.offset)..][0..@intCast(file_loc.size)],
+        line_len,
+        line_len,
+    );
+    while (line_it.next()) |line_bytes| : (address += line_len) {
+        try w.splatByteAll(' ', indent + 1);
+        try w.print("{x:0>8}  ", .{address});
+        for (line_bytes) |byte| try w.print("{x:0>2} ", .{byte});
+        try w.splatByteAll(' ', 3 * (line_len - line_bytes.len) + 1);
+        for (line_bytes) |byte| try w.writeByte(if (std.ascii.isPrint(byte)) byte else '.');
+        try w.writeByte('\n');
     }
 }

src/link/Elf2.zig+16-11

 @@ -7902,8 +7902,10 @@ fn flushElfOffset(elf: *Elf, ni: MappedFile.Node.Index) void {
                     }
                 },
             }
-            var child_it = ni.children(&elf.mf);
+            var child_oni = ni.first(&elf.mf);
-            while (child_it.next()) |child_ni| elf.flushElfOffset(child_ni);
+            while (child_oni.unwrap()) |child_ni| : (child_oni = child_ni.next(&elf.mf)) {
+                elf.flushElfOffset(child_ni);
+            }
         },
         .section => |shndx| switch (elf.shdrPtr(shndx)) {
             inline else => |shdr| elf.targetStore(&shdr.offset, @intCast(elf_offset)),
 @@ -8203,9 +8205,10 @@ fn flushResized(elf: *Elf, ni: MappedFile.Node.Index) std.mem.Allocator.Error!vo
     _, const size = ni.location(&elf.mf).resolve(&elf.mf);
     switch (elf.getNode(ni)) {
         .archive => {
-            var child_it = ni.reverseChildren(&elf.mf);
+            if (ni.last(&elf.mf).unwrap()) |last_ni| {
-            if (child_it.next()) |last_ni| {
+                if (last_ni.prev(&elf.mf).unwrap()) |prev_ni| {
-                if (child_it.next()) |prev_ni| if (prev_ni.hasNextMoved(&elf.mf)) return;
+                    if (prev_ni.hasNextMoved(&elf.mf)) return;
+                }
                 const offset, _ = last_ni.location(&elf.mf).resolve(&elf.mf);
                 _ = std.mem.print(&elf.arHdrPtr(last_ni).ar_size, "{d:<10}", .{
                     size - offset,
 @@ -8894,13 +8897,15 @@ pub fn printNode(
             if (mf_node.flags.has_content) " has_content" else "",
         });
     }
-    var leaf = true;
+    if (ni.first(&elf.mf).unwrap()) |first_ni| {
-    var child_it = ni.children(&elf.mf);
+        // non-leaf, just print children
-    while (child_it.next()) |child_ni| {
+        var child_ni = first_ni;
-        leaf = false;
+        while (true) {
-        try elf.printNode(tid, w, child_ni, indent + 1);
+            try elf.printNode(tid, w, child_ni, indent + 1);
+            child_ni = child_ni.next(&elf.mf).unwrap() orelse break;
+        }
+        return;
     }
-    if (!leaf) return;
     const file_loc = ni.fileLocation(&elf.mf, false);
     var address = file_loc.offset;
     if (file_loc.size == 0) {

src/link/MappedFile.zig-18

...	@@ -486,24 +486,6 @@ pub const Node = extern struct {	...	@@ -486,24 +486,6 @@ pub const Node = extern struct {
486	return ni.get(mf).prev;	486	return ni.get(mf).prev;
487	}	487	}
488		488
489	pub fn ChildIterator(comptime direction: enum { prev, next }) type {
490	return struct {
491	mf: *const MappedFile,
492	ni: Node.Index.Optional,
493	pub fn next(it: *@This()) ?Node.Index {
494	const ni = it.ni.unwrap() orelse return null;
495	it.ni = @field(ni.get(it.mf), @tagName(direction));
496	return ni;
497	}
498	};
499	}
500	pub fn children(ni: Node.Index, mf: *const MappedFile) ChildIterator(.next) {
501	return .{ .mf = mf, .ni = ni.get(mf).first };
502	}
503	pub fn reverseChildren(ni: Node.Index, mf: *const MappedFile) ChildIterator(.prev) {
504	return .{ .mf = mf, .ni = ni.get(mf).last };
505	}
506
507	pub fn childrenMoved(ni: Node.Index, gpa: Allocator, mf: *MappedFile) Allocator.Error!void {	489	pub fn childrenMoved(ni: Node.Index, gpa: Allocator, mf: *MappedFile) Allocator.Error!void {
508	var child_oni = ni.get(mf).last;	490	var child_oni = ni.get(mf).last;
509	while (child_oni.unwrap()) \|child_ni\| {	491	while (child_oni.unwrap()) \|child_ni\| {