std.Build.Step.CheckObject: mostly revert to master branch

the updated code to use new std.io API is crashing

1 files changed, 634 insertions, 536 deletions

diff --git a/lib/std/Build/Step/CheckObject.zig b/lib/std/Build/Step/CheckObject.zig
index 3d140d9969..06ad26ccc8 100644
--- a/lib/std/Build/Step/CheckObject.zig
+++ b/lib/std/Build/Step/CheckObject.zig
@@ -36,7 +36,7 @@ pub fn create(
             .makeFn = make,
         }),
         .source = source.dupe(owner),
-        .checks = .init(gpa),
+        .checks = std.ArrayList(Check).init(gpa),
         .obj_format = obj_format,
     };
     check_object.source.addStepDependencies(&check_object.step);
@@ -75,7 +75,7 @@ const Action = struct {
         b: *std.Build,
         step: *Step,
         haystack: []const u8,
-        global_vars: *std.StringHashMap(u64),
+        global_vars: anytype,
     ) !bool {
         assert(act.tag == .extract);
         const hay = mem.trim(u8, haystack, " ");
@@ -154,11 +154,11 @@ const Action = struct {
     /// Will return true if the `phrase` is correctly parsed into an RPN program and
     /// its reduced, computed value compares using `op` with the expected value, either
     /// a literal or another extracted variable.
-    fn computeCmp(act: Action, b: *std.Build, step: *Step, global_vars: std.StringHashMap(u64)) !bool {
+    fn computeCmp(act: Action, b: *std.Build, step: *Step, global_vars: anytype) !bool {
         const gpa = step.owner.allocator;
         const phrase = act.phrase.resolve(b, step);
-        var op_stack: std.ArrayList(enum { add, sub, mod, mul }) = .init(gpa);
-        var values: std.ArrayList(u64) = .init(gpa);
+        var op_stack = std.ArrayList(enum { add, sub, mod, mul }).init(gpa);
+        var values = std.ArrayList(u64).init(gpa);
 
         var it = mem.tokenizeScalar(u8, phrase, ' ');
         while (it.next()) |next| {
@@ -230,11 +230,11 @@ const ComputeCompareExpected = struct {
         literal: u64,
     },
 
-    pub fn format(value: ComputeCompareExpected, bw: *Writer) Writer.Error!void {
-        try bw.print("{s} ", .{@tagName(value.op)});
+    pub fn format(value: ComputeCompareExpected, w: *Writer) Writer.Error!void {
+        try w.print("{t} ", .{value.op});
         switch (value.value) {
-            .variable => |name| try bw.writeAll(name),
-            .literal => |x| try bw.print("{x}", .{x}),
+            .variable => |name| try w.writeAll(name),
+            .literal => |x| try w.print("{x}", .{x}),
         }
     }
 };
@@ -242,63 +242,56 @@ const ComputeCompareExpected = struct {
 const Check = struct {
     kind: Kind,
     payload: Payload,
-    allocator: Allocator,
-    data: std.ArrayListUnmanaged(u8),
-    actions: std.ArrayListUnmanaged(Action),
+    data: std.ArrayList(u8),
+    actions: std.ArrayList(Action),
 
     fn create(allocator: Allocator, kind: Kind) Check {
         return .{
             .kind = kind,
             .payload = .{ .none = {} },
-            .allocator = allocator,
-            .data = .empty,
-            .actions = .empty,
+            .data = std.ArrayList(u8).init(allocator),
+            .actions = std.ArrayList(Action).init(allocator),
         };
     }
 
-    fn dumpSection(gpa: Allocator, name: [:0]const u8) Check {
-        var check = Check.create(gpa, .dump_section);
+    fn dumpSection(allocator: Allocator, name: [:0]const u8) Check {
+        var check = Check.create(allocator, .dump_section);
         const off: u32 = @intCast(check.data.items.len);
-        check.data.print(gpa, "{s}\x00", .{name}) catch @panic("OOM");
+        check.data.writer().print("{s}\x00", .{name}) catch @panic("OOM");
         check.payload = .{ .dump_section = off };
         return check;
     }
 
     fn extract(check: *Check, phrase: SearchPhrase) void {
-        const gpa = check.allocator;
-        check.actions.append(gpa, .{
+        check.actions.append(.{
             .tag = .extract,
             .phrase = phrase,
         }) catch @panic("OOM");
     }
 
     fn exact(check: *Check, phrase: SearchPhrase) void {
-        const gpa = check.allocator;
-        check.actions.append(gpa, .{
+        check.actions.append(.{
             .tag = .exact,
             .phrase = phrase,
         }) catch @panic("OOM");
     }
 
     fn contains(check: *Check, phrase: SearchPhrase) void {
-        const gpa = check.allocator;
-        check.actions.append(gpa, .{
+        check.actions.append(.{
             .tag = .contains,
             .phrase = phrase,
         }) catch @panic("OOM");
     }
 
     fn notPresent(check: *Check, phrase: SearchPhrase) void {
-        const gpa = check.allocator;
-        check.actions.append(gpa, .{
+        check.actions.append(.{
             .tag = .not_present,
             .phrase = phrase,
         }) catch @panic("OOM");
     }
 
     fn computeCmp(check: *Check, phrase: SearchPhrase, expected: ComputeCompareExpected) void {
-        const gpa = check.allocator;
-        check.actions.append(gpa, .{
+        check.actions.append(.{
             .tag = .compute_cmp,
             .phrase = phrase,
             .expected = expected,
@@ -751,14 +744,14 @@ const MachODumper = struct {
                     },
                     .SYMTAB => {
                         const lc = cmd.cast(macho.symtab_command).?;
-                        const symtab = @as([*]align(1) const macho.nlist_64, @ptrCast(ctx.data[lc.symoff..].ptr))[0..lc.nsyms];
+                        const symtab = @as([*]align(1) const macho.nlist_64, @ptrCast(ctx.data.ptr + lc.symoff))[0..lc.nsyms];
                         const strtab = ctx.data[lc.stroff..][0..lc.strsize];
                         try ctx.symtab.appendUnalignedSlice(ctx.gpa, symtab);
                         try ctx.strtab.appendSlice(ctx.gpa, strtab);
                     },
                     .DYSYMTAB => {
                         const lc = cmd.cast(macho.dysymtab_command).?;
-                        const indexes = @as([*]align(1) const u32, @ptrCast(ctx.data[lc.indirectsymoff..].ptr))[0..lc.nindirectsyms];
+                        const indexes = @as([*]align(1) const u32, @ptrCast(ctx.data.ptr + lc.indirectsymoff))[0..lc.nindirectsyms];
                         try ctx.indsymtab.appendUnalignedSlice(ctx.gpa, indexes);
                     },
                     .LOAD_DYLIB,
@@ -776,7 +769,7 @@ const MachODumper = struct {
 
         fn getString(ctx: ObjectContext, off: u32) [:0]const u8 {
             assert(off < ctx.strtab.items.len);
-            return mem.sliceTo(@as([*:0]const u8, @ptrCast(ctx.strtab.items[off..].ptr)), 0);
+            return mem.sliceTo(@as([*:0]const u8, @ptrCast(ctx.strtab.items.ptr + off)), 0);
         }
 
         fn getLoadCommandIterator(ctx: ObjectContext) macho.LoadCommandIterator {
@@ -806,7 +799,7 @@ const MachODumper = struct {
             return null;
         }
 
-        fn dumpHeader(hdr: macho.mach_header_64, bw: *Writer) !void {
+        fn dumpHeader(hdr: macho.mach_header_64, writer: anytype) !void {
             const cputype = switch (hdr.cputype) {
                 macho.CPU_TYPE_ARM64 => "ARM64",
                 macho.CPU_TYPE_X86_64 => "X86_64",
@@ -827,7 +820,7 @@ const MachODumper = struct {
                 else => "Unknown",
             };
 
-            try bw.print(
+            try writer.print(
                 \\header
                 \\cputype {s}
                 \\filetype {s}
@@ -842,41 +835,41 @@ const MachODumper = struct {
             });
 
             if (hdr.flags > 0) {
-                if (hdr.flags & macho.MH_NOUNDEFS != 0) try bw.writeAll(" NOUNDEFS");
-                if (hdr.flags & macho.MH_INCRLINK != 0) try bw.writeAll(" INCRLINK");
-                if (hdr.flags & macho.MH_DYLDLINK != 0) try bw.writeAll(" DYLDLINK");
-                if (hdr.flags & macho.MH_BINDATLOAD != 0) try bw.writeAll(" BINDATLOAD");
-                if (hdr.flags & macho.MH_PREBOUND != 0) try bw.writeAll(" PREBOUND");
-                if (hdr.flags & macho.MH_SPLIT_SEGS != 0) try bw.writeAll(" SPLIT_SEGS");
-                if (hdr.flags & macho.MH_LAZY_INIT != 0) try bw.writeAll(" LAZY_INIT");
-                if (hdr.flags & macho.MH_TWOLEVEL != 0) try bw.writeAll(" TWOLEVEL");
-                if (hdr.flags & macho.MH_FORCE_FLAT != 0) try bw.writeAll(" FORCE_FLAT");
-                if (hdr.flags & macho.MH_NOMULTIDEFS != 0) try bw.writeAll(" NOMULTIDEFS");
-                if (hdr.flags & macho.MH_NOFIXPREBINDING != 0) try bw.writeAll(" NOFIXPREBINDING");
-                if (hdr.flags & macho.MH_PREBINDABLE != 0) try bw.writeAll(" PREBINDABLE");
-                if (hdr.flags & macho.MH_ALLMODSBOUND != 0) try bw.writeAll(" ALLMODSBOUND");
-                if (hdr.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0) try bw.writeAll(" SUBSECTIONS_VIA_SYMBOLS");
-                if (hdr.flags & macho.MH_CANONICAL != 0) try bw.writeAll(" CANONICAL");
-                if (hdr.flags & macho.MH_WEAK_DEFINES != 0) try bw.writeAll(" WEAK_DEFINES");
-                if (hdr.flags & macho.MH_BINDS_TO_WEAK != 0) try bw.writeAll(" BINDS_TO_WEAK");
-                if (hdr.flags & macho.MH_ALLOW_STACK_EXECUTION != 0) try bw.writeAll(" ALLOW_STACK_EXECUTION");
-                if (hdr.flags & macho.MH_ROOT_SAFE != 0) try bw.writeAll(" ROOT_SAFE");
-                if (hdr.flags & macho.MH_SETUID_SAFE != 0) try bw.writeAll(" SETUID_SAFE");
-                if (hdr.flags & macho.MH_NO_REEXPORTED_DYLIBS != 0) try bw.writeAll(" NO_REEXPORTED_DYLIBS");
-                if (hdr.flags & macho.MH_PIE != 0) try bw.writeAll(" PIE");
-                if (hdr.flags & macho.MH_DEAD_STRIPPABLE_DYLIB != 0) try bw.writeAll(" DEAD_STRIPPABLE_DYLIB");
-                if (hdr.flags & macho.MH_HAS_TLV_DESCRIPTORS != 0) try bw.writeAll(" HAS_TLV_DESCRIPTORS");
-                if (hdr.flags & macho.MH_NO_HEAP_EXECUTION != 0) try bw.writeAll(" NO_HEAP_EXECUTION");
-                if (hdr.flags & macho.MH_APP_EXTENSION_SAFE != 0) try bw.writeAll(" APP_EXTENSION_SAFE");
-                if (hdr.flags & macho.MH_NLIST_OUTOFSYNC_WITH_DYLDINFO != 0) try bw.writeAll(" NLIST_OUTOFSYNC_WITH_DYLDINFO");
+                if (hdr.flags & macho.MH_NOUNDEFS != 0) try writer.writeAll(" NOUNDEFS");
+                if (hdr.flags & macho.MH_INCRLINK != 0) try writer.writeAll(" INCRLINK");
+                if (hdr.flags & macho.MH_DYLDLINK != 0) try writer.writeAll(" DYLDLINK");
+                if (hdr.flags & macho.MH_BINDATLOAD != 0) try writer.writeAll(" BINDATLOAD");
+                if (hdr.flags & macho.MH_PREBOUND != 0) try writer.writeAll(" PREBOUND");
+                if (hdr.flags & macho.MH_SPLIT_SEGS != 0) try writer.writeAll(" SPLIT_SEGS");
+                if (hdr.flags & macho.MH_LAZY_INIT != 0) try writer.writeAll(" LAZY_INIT");
+                if (hdr.flags & macho.MH_TWOLEVEL != 0) try writer.writeAll(" TWOLEVEL");
+                if (hdr.flags & macho.MH_FORCE_FLAT != 0) try writer.writeAll(" FORCE_FLAT");
+                if (hdr.flags & macho.MH_NOMULTIDEFS != 0) try writer.writeAll(" NOMULTIDEFS");
+                if (hdr.flags & macho.MH_NOFIXPREBINDING != 0) try writer.writeAll(" NOFIXPREBINDING");
+                if (hdr.flags & macho.MH_PREBINDABLE != 0) try writer.writeAll(" PREBINDABLE");
+                if (hdr.flags & macho.MH_ALLMODSBOUND != 0) try writer.writeAll(" ALLMODSBOUND");
+                if (hdr.flags & macho.MH_SUBSECTIONS_VIA_SYMBOLS != 0) try writer.writeAll(" SUBSECTIONS_VIA_SYMBOLS");
+                if (hdr.flags & macho.MH_CANONICAL != 0) try writer.writeAll(" CANONICAL");
+                if (hdr.flags & macho.MH_WEAK_DEFINES != 0) try writer.writeAll(" WEAK_DEFINES");
+                if (hdr.flags & macho.MH_BINDS_TO_WEAK != 0) try writer.writeAll(" BINDS_TO_WEAK");
+                if (hdr.flags & macho.MH_ALLOW_STACK_EXECUTION != 0) try writer.writeAll(" ALLOW_STACK_EXECUTION");
+                if (hdr.flags & macho.MH_ROOT_SAFE != 0) try writer.writeAll(" ROOT_SAFE");
+                if (hdr.flags & macho.MH_SETUID_SAFE != 0) try writer.writeAll(" SETUID_SAFE");
+                if (hdr.flags & macho.MH_NO_REEXPORTED_DYLIBS != 0) try writer.writeAll(" NO_REEXPORTED_DYLIBS");
+                if (hdr.flags & macho.MH_PIE != 0) try writer.writeAll(" PIE");
+                if (hdr.flags & macho.MH_DEAD_STRIPPABLE_DYLIB != 0) try writer.writeAll(" DEAD_STRIPPABLE_DYLIB");
+                if (hdr.flags & macho.MH_HAS_TLV_DESCRIPTORS != 0) try writer.writeAll(" HAS_TLV_DESCRIPTORS");
+                if (hdr.flags & macho.MH_NO_HEAP_EXECUTION != 0) try writer.writeAll(" NO_HEAP_EXECUTION");
+                if (hdr.flags & macho.MH_APP_EXTENSION_SAFE != 0) try writer.writeAll(" APP_EXTENSION_SAFE");
+                if (hdr.flags & macho.MH_NLIST_OUTOFSYNC_WITH_DYLDINFO != 0) try writer.writeAll(" NLIST_OUTOFSYNC_WITH_DYLDINFO");
             }
 
-            try bw.writeByte('\n');
+            try writer.writeByte('\n');
         }
 
-        fn dumpLoadCommand(lc: macho.LoadCommandIterator.LoadCommand, index: usize, bw: *Writer) !void {
+        fn dumpLoadCommand(lc: macho.LoadCommandIterator.LoadCommand, index: usize, writer: anytype) !void {
             // print header first
-            try bw.print(
+            try writer.print(
                 \\LC {d}
                 \\cmd {s}
                 \\cmdsize {d}
@@ -885,8 +878,8 @@ const MachODumper = struct {
             switch (lc.cmd()) {
                 .SEGMENT_64 => {
                     const seg = lc.cast(macho.segment_command_64).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\segname {s}
                         \\vmaddr {x}
                         \\vmsize {x}
@@ -901,8 +894,8 @@ const MachODumper = struct {
                     });
 
                     for (lc.getSections()) |sect| {
-                        try bw.writeByte('\n');
-                        try bw.print(
+                        try writer.writeByte('\n');
+                        try writer.print(
                             \\sectname {s}
                             \\addr {x}
                             \\size {x}
@@ -924,8 +917,8 @@ const MachODumper = struct {
                 .REEXPORT_DYLIB,
                 => {
                     const dylib = lc.cast(macho.dylib_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\name {s}
                         \\timestamp {d}
                         \\current version {x}
@@ -940,16 +933,16 @@ const MachODumper = struct {
 
                 .MAIN => {
                     const main = lc.cast(macho.entry_point_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\entryoff {x}
                         \\stacksize {x}
                     , .{ main.entryoff, main.stacksize });
                 },
 
                 .RPATH => {
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\path {s}
                     , .{
                         lc.getRpathPathName(),
@@ -958,8 +951,8 @@ const MachODumper = struct {
 
                 .UUID => {
                     const uuid = lc.cast(macho.uuid_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print("uuid {x}", .{&uuid.uuid});
+                    try writer.writeByte('\n');
+                    try writer.print("uuid {x}", .{&uuid.uuid});
                 },
 
                 .DATA_IN_CODE,
@@ -967,8 +960,8 @@ const MachODumper = struct {
                 .CODE_SIGNATURE,
                 => {
                     const llc = lc.cast(macho.linkedit_data_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\dataoff {x}
                         \\datasize {x}
                     , .{ llc.dataoff, llc.datasize });
@@ -976,8 +969,8 @@ const MachODumper = struct {
 
                 .DYLD_INFO_ONLY => {
                     const dlc = lc.cast(macho.dyld_info_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\rebaseoff {x}
                         \\rebasesize {x}
                         \\bindoff {x}
@@ -1004,8 +997,8 @@ const MachODumper = struct {
 
                 .SYMTAB => {
                     const slc = lc.cast(macho.symtab_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\symoff {x}
                         \\nsyms {x}
                         \\stroff {x}
@@ -1020,8 +1013,8 @@ const MachODumper = struct {
 
                 .DYSYMTAB => {
                     const dlc = lc.cast(macho.dysymtab_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\ilocalsym {x}
                         \\nlocalsym {x}
                         \\iextdefsym {x}
@@ -1044,8 +1037,8 @@ const MachODumper = struct {
 
                 .BUILD_VERSION => {
                     const blc = lc.cast(macho.build_version_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\platform {s}
                         \\minos {d}.{d}.{d}
                         \\sdk {d}.{d}.{d}
@@ -1061,12 +1054,12 @@ const MachODumper = struct {
                         blc.ntools,
                     });
                     for (lc.getBuildVersionTools()) |tool| {
-                        try bw.writeByte('\n');
+                        try writer.writeByte('\n');
                         switch (tool.tool) {
-                            .CLANG, .SWIFT, .LD, .LLD, .ZIG => try bw.print("tool {s}\n", .{@tagName(tool.tool)}),
-                            else => |x| try bw.print("tool {d}\n", .{@intFromEnum(x)}),
+                            .CLANG, .SWIFT, .LD, .LLD, .ZIG => try writer.print("tool {s}\n", .{@tagName(tool.tool)}),
+                            else => |x| try writer.print("tool {d}\n", .{@intFromEnum(x)}),
                         }
-                        try bw.print(
+                        try writer.print(
                             \\version {d}.{d}.{d}
                         , .{
                             tool.version >> 16,
@@ -1082,8 +1075,8 @@ const MachODumper = struct {
                 .VERSION_MIN_TVOS,
                 => {
                     const vlc = lc.cast(macho.version_min_command).?;
-                    try bw.writeByte('\n');
-                    try bw.print(
+                    try writer.writeByte('\n');
+                    try writer.print(
                         \\version {d}.{d}.{d}
                         \\sdk {d}.{d}.{d}
                     , .{
@@ -1100,8 +1093,8 @@ const MachODumper = struct {
             }
         }
 
-        fn dumpSymtab(ctx: ObjectContext, bw: *Writer) !void {
-            try bw.writeAll(symtab_label ++ "\n");
+        fn dumpSymtab(ctx: ObjectContext, writer: anytype) !void {
+            try writer.writeAll(symtab_label ++ "\n");
 
             for (ctx.symtab.items) |sym| {
                 const sym_name = ctx.getString(sym.n_strx);
@@ -1116,32 +1109,32 @@ const MachODumper = struct {
                         macho.N_STSYM => "STSYM",
                         else => "UNKNOWN STAB",
                     };
-                    try bw.print("{x}", .{sym.n_value});
+                    try writer.print("{x}", .{sym.n_value});
                     if (sym.n_sect > 0) {
                         const sect = ctx.sections.items[sym.n_sect - 1];
-                        try bw.print(" ({s},{s})", .{ sect.segName(), sect.sectName() });
+                        try writer.print(" ({s},{s})", .{ sect.segName(), sect.sectName() });
                     }
-                    try bw.print(" {s} (stab) {s}\n", .{ tt, sym_name });
+                    try writer.print(" {s} (stab) {s}\n", .{ tt, sym_name });
                 } else if (sym.sect()) {
                     const sect = ctx.sections.items[sym.n_sect - 1];
-                    try bw.print("{x} ({s},{s})", .{
+                    try writer.print("{x} ({s},{s})", .{
                         sym.n_value,
                         sect.segName(),
                         sect.sectName(),
                     });
-                    if (sym.n_desc & macho.REFERENCED_DYNAMICALLY != 0) try bw.writeAll(" [referenced dynamically]");
-                    if (sym.weakDef()) try bw.writeAll(" weak");
-                    if (sym.weakRef()) try bw.writeAll(" weakref");
+                    if (sym.n_desc & macho.REFERENCED_DYNAMICALLY != 0) try writer.writeAll(" [referenced dynamically]");
+                    if (sym.weakDef()) try writer.writeAll(" weak");
+                    if (sym.weakRef()) try writer.writeAll(" weakref");
                     if (sym.ext()) {
-                        if (sym.pext()) try bw.writeAll(" private");
-                        try bw.writeAll(" external");
-                    } else if (sym.pext()) try bw.writeAll(" (was private external)");
-                    try bw.print(" {s}\n", .{sym_name});
+                        if (sym.pext()) try writer.writeAll(" private");
+                        try writer.writeAll(" external");
+                    } else if (sym.pext()) try writer.writeAll(" (was private external)");
+                    try writer.print(" {s}\n", .{sym_name});
                 } else if (sym.tentative()) {
                     const alignment = (sym.n_desc >> 8) & 0x0F;
-                    try bw.print("  0x{x:0>16} (common) (alignment 2^{d})", .{ sym.n_value, alignment });
-                    if (sym.ext()) try bw.writeAll(" external");
-                    try bw.print(" {s}\n", .{sym_name});
+                    try writer.print("  0x{x:0>16} (common) (alignment 2^{d})", .{ sym.n_value, alignment });
+                    if (sym.ext()) try writer.writeAll(" external");
+                    try writer.print(" {s}\n", .{sym_name});
                 } else if (sym.undf()) {
                     const ordinal = @divFloor(@as(i16, @bitCast(sym.n_desc)), macho.N_SYMBOL_RESOLVER);
                     const import_name = blk: {
@@ -1160,10 +1153,10 @@ const MachODumper = struct {
                         const ext = mem.lastIndexOfScalar(u8, basename, '.') orelse basename.len;
                         break :blk basename[0..ext];
                     };
-                    try bw.writeAll("(undefined)");
-                    if (sym.weakRef()) try bw.writeAll(" weakref");
-                    if (sym.ext()) try bw.writeAll(" external");
-                    try bw.print(" {s} (from {s})\n", .{
+                    try writer.writeAll("(undefined)");
+                    if (sym.weakRef()) try writer.writeAll(" weakref");
+                    if (sym.ext()) try writer.writeAll(" external");
+                    try writer.print(" {s} (from {s})\n", .{
                         sym_name,
                         import_name,
                     });
@@ -1171,8 +1164,8 @@ const MachODumper = struct {
             }
         }
 
-        fn dumpIndirectSymtab(ctx: ObjectContext, bw: *Writer) !void {
-            try bw.writeAll(indirect_symtab_label ++ "\n");
+        fn dumpIndirectSymtab(ctx: ObjectContext, writer: anytype) !void {
+            try writer.writeAll(indirect_symtab_label ++ "\n");
 
             var sects_buffer: [3]macho.section_64 = undefined;
             const sects = blk: {
@@ -1210,33 +1203,35 @@ const MachODumper = struct {
                     break :blk @sizeOf(u64);
                 };
 
-                try bw.print("{s},{s}\n", .{ sect.segName(), sect.sectName() });
-                try bw.print("nentries {d}\n", .{end - start});
+                try writer.print("{s},{s}\n", .{ sect.segName(), sect.sectName() });
+                try writer.print("nentries {d}\n", .{end - start});
                 for (ctx.indsymtab.items[start..end], 0..) |index, j| {
                     const sym = ctx.symtab.items[index];
                     const addr = sect.addr + entry_size * j;
-                    try bw.print("0x{x} {d} {s}\n", .{ addr, index, ctx.getString(sym.n_strx) });
+                    try writer.print("0x{x} {d} {s}\n", .{ addr, index, ctx.getString(sym.n_strx) });
                 }
             }
         }
 
-        fn dumpRebaseInfo(ctx: ObjectContext, data: []const u8, bw: *Writer) !void {
-            var rebases: std.ArrayList(u64) = .init(ctx.gpa);
+        fn dumpRebaseInfo(ctx: ObjectContext, data: []const u8, writer: anytype) !void {
+            var rebases = std.ArrayList(u64).init(ctx.gpa);
             defer rebases.deinit();
             try ctx.parseRebaseInfo(data, &rebases);
             mem.sort(u64, rebases.items, {}, std.sort.asc(u64));
             for (rebases.items) |addr| {
-                try bw.print("0x{x}\n", .{addr});
+                try writer.print("0x{x}\n", .{addr});
             }
         }
 
         fn parseRebaseInfo(ctx: ObjectContext, data: []const u8, rebases: *std.ArrayList(u64)) !void {
-            var r: std.io.Reader = .fixed(data);
+            var stream = std.io.fixedBufferStream(data);
+            var creader = std.io.countingReader(stream.reader());
+            const reader = creader.reader();
 
             var seg_id: ?u8 = null;
             var offset: u64 = 0;
             while (true) {
-                const byte = r.takeByte() catch break;
+                const byte = reader.readByte() catch break;
                 const opc = byte & macho.REBASE_OPCODE_MASK;
                 const imm = byte & macho.REBASE_IMMEDIATE_MASK;
                 switch (opc) {
@@ -1244,17 +1239,17 @@ const MachODumper = struct {
                     macho.REBASE_OPCODE_SET_TYPE_IMM => {},
                     macho.REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
                         seg_id = imm;
-                        offset = try r.takeLeb128(u64);
+                        offset = try std.leb.readUleb128(u64, reader);
                     },
                     macho.REBASE_OPCODE_ADD_ADDR_IMM_SCALED => {
                         offset += imm * @sizeOf(u64);
                     },
                     macho.REBASE_OPCODE_ADD_ADDR_ULEB => {
-                        const addend = try r.takeLeb128(u64);
+                        const addend = try std.leb.readUleb128(u64, reader);
                         offset += addend;
                     },
                     macho.REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB => {
-                        const addend = try r.takeLeb128(u64);
+                        const addend = try std.leb.readUleb128(u64, reader);
                         const seg = ctx.segments.items[seg_id.?];
                         const addr = seg.vmaddr + offset;
                         try rebases.append(addr);
@@ -1271,11 +1266,11 @@ const MachODumper = struct {
                                 ntimes = imm;
                             },
                             macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES => {
-                                ntimes = try r.takeLeb128(u64);
+                                ntimes = try std.leb.readUleb128(u64, reader);
                             },
                             macho.REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB => {
-                                ntimes = try r.takeLeb128(u64);
-                                skip = try r.takeLeb128(u64);
+                                ntimes = try std.leb.readUleb128(u64, reader);
+                                skip = try std.leb.readUleb128(u64, reader);
                             },
                             else => unreachable,
                         }
@@ -1317,8 +1312,8 @@ const MachODumper = struct {
             };
         };
 
-        fn dumpBindInfo(ctx: ObjectContext, data: []const u8, bw: *Writer) !void {
-            var bindings: std.ArrayList(Binding) = .init(ctx.gpa);
+        fn dumpBindInfo(ctx: ObjectContext, data: []const u8, writer: anytype) !void {
+            var bindings = std.ArrayList(Binding).init(ctx.gpa);
             defer {
                 for (bindings.items) |*b| {
                     b.deinit(ctx.gpa);
@@ -1328,20 +1323,22 @@ const MachODumper = struct {
             try ctx.parseBindInfo(data, &bindings);
             mem.sort(Binding, bindings.items, {}, Binding.lessThan);
             for (bindings.items) |binding| {
-                try bw.print("0x{x} [addend: {d}]", .{ binding.address, binding.addend });
-                try bw.writeAll(" (");
+                try writer.print("0x{x} [addend: {d}]", .{ binding.address, binding.addend });
+                try writer.writeAll(" (");
                 switch (binding.tag) {
-                    .self => try bw.writeAll("self"),
-                    .exe => try bw.writeAll("main executable"),
-                    .flat => try bw.writeAll("flat lookup"),
-                    .ord => try bw.writeAll(std.fs.path.basename(ctx.imports.items[binding.ordinal - 1])),
+                    .self => try writer.writeAll("self"),
+                    .exe => try writer.writeAll("main executable"),
+                    .flat => try writer.writeAll("flat lookup"),
+                    .ord => try writer.writeAll(std.fs.path.basename(ctx.imports.items[binding.ordinal - 1])),
                 }
-                try bw.print(") {s}\n", .{binding.name});
+                try writer.print(") {s}\n", .{binding.name});
             }
         }
 
         fn parseBindInfo(ctx: ObjectContext, data: []const u8, bindings: *std.ArrayList(Binding)) !void {
-            var r: std.io.Reader = .fixed(data);
+            var stream = std.io.fixedBufferStream(data);
+            var creader = std.io.countingReader(stream.reader());
+            const reader = creader.reader();
 
             var seg_id: ?u8 = null;
             var tag: Binding.Tag = .self;
@@ -1349,10 +1346,11 @@ const MachODumper = struct {
             var offset: u64 = 0;
             var addend: i64 = 0;
 
-            var name_buf: std.io.Writer.Allocating = .init(ctx.gpa);
+            var name_buf = std.ArrayList(u8).init(ctx.gpa);
             defer name_buf.deinit();
 
-            while (r.takeByte()) |byte| {
+            while (true) {
+                const byte = reader.readByte() catch break;
                 const opc = byte & macho.BIND_OPCODE_MASK;
                 const imm = byte & macho.BIND_IMMEDIATE_MASK;
                 switch (opc) {
@@ -1373,18 +1371,18 @@ const MachODumper = struct {
                     },
                     macho.BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB => {
                         seg_id = imm;
-                        offset = try r.takeLeb128(u64);
+                        offset = try std.leb.readUleb128(u64, reader);
                     },
                     macho.BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM => {
                         name_buf.clearRetainingCapacity();
-                        _ = try r.streamDelimiterLimit(&name_buf.writer, 0, .limited(std.math.maxInt(u32)));
-                        try name_buf.writer.writeByte(0);
+                        try reader.readUntilDelimiterArrayList(&name_buf, 0, std.math.maxInt(u32));
+                        try name_buf.append(0);
                     },
                     macho.BIND_OPCODE_SET_ADDEND_SLEB => {
-                        addend = try r.takeLeb128(i64);
+                        addend = try std.leb.readIleb128(i64, reader);
                     },
                     macho.BIND_OPCODE_ADD_ADDR_ULEB => {
-                        const x = try r.takeLeb128(u64);
+                        const x = try std.leb.readUleb128(u64, reader);
                         offset = @intCast(@as(i64, @intCast(offset)) + @as(i64, @bitCast(x)));
                     },
                     macho.BIND_OPCODE_DO_BIND,
@@ -1399,14 +1397,14 @@ const MachODumper = struct {
                         switch (opc) {
                             macho.BIND_OPCODE_DO_BIND => {},
                             macho.BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB => {
-                                add_addr = try r.takeLeb128(u64);
+                                add_addr = try std.leb.readUleb128(u64, reader);
                             },
                             macho.BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED => {
                                 add_addr = imm * @sizeOf(u64);
                             },
                             macho.BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB => {
-                                count = try r.takeLeb128(u64);
-                                skip = try r.takeLeb128(u64);
+                                count = try std.leb.readUleb128(u64, reader);
+                                skip = try std.leb.readUleb128(u64, reader);
                             },
                             else => unreachable,
                         }
@@ -1420,25 +1418,25 @@ const MachODumper = struct {
                                 .addend = addend,
                                 .tag = tag,
                                 .ordinal = ordinal,
-                                .name = try ctx.gpa.dupe(u8, name_buf.getWritten()),
+                                .name = try ctx.gpa.dupe(u8, name_buf.items),
                             });
                             offset += skip + @sizeOf(u64) + add_addr;
                         }
                     },
                     else => break,
                 }
-            } else |_| {}
+            }
         }
 
-        fn dumpExportsTrie(ctx: ObjectContext, data: []const u8, bw: *Writer) !void {
+        fn dumpExportsTrie(ctx: ObjectContext, data: []const u8, writer: anytype) !void {
             const seg = ctx.getSegmentByName("__TEXT") orelse return;
 
             var arena = std.heap.ArenaAllocator.init(ctx.gpa);
             defer arena.deinit();
 
-            var exports: std.ArrayList(Export) = .init(arena.allocator());
-            var r: std.io.Reader = .fixed(data);
-            try parseTrieNode(arena.allocator(), &r, "", &exports);
+            var exports = std.ArrayList(Export).init(arena.allocator());
+            var it = TrieIterator{ .data = data };
+            try parseTrieNode(arena.allocator(), &it, "", &exports);
 
             mem.sort(Export, exports.items, {}, Export.lessThan);
 
@@ -1447,26 +1445,66 @@ const MachODumper = struct {
                     .@"export" => {
                         const info = exp.data.@"export";
                         if (info.kind != .regular or info.weak) {
-                            try bw.writeByte('[');
+                            try writer.writeByte('[');
                         }
                         switch (info.kind) {
                             .regular => {},
-                            .absolute => try bw.writeAll("ABS, "),
-                            .tlv => try bw.writeAll("THREAD_LOCAL, "),
+                            .absolute => try writer.writeAll("ABS, "),
+                            .tlv => try writer.writeAll("THREAD_LOCAL, "),
                         }
-                        if (info.weak) try bw.writeAll("WEAK");
+                        if (info.weak) try writer.writeAll("WEAK");
                         if (info.kind != .regular or info.weak) {
-                            try bw.writeAll("] ");
+                            try writer.writeAll("] ");
                         }
-                        try bw.print("{x} ", .{seg.vmaddr + info.vmoffset});
+                        try writer.print("{x} ", .{seg.vmaddr + info.vmoffset});
                     },
                     else => {},
                 }
 
-                try bw.print("{s}\n", .{exp.name});
+                try writer.print("{s}\n", .{exp.name});
             }
         }
 
+        const TrieIterator = struct {
+            data: []const u8,
+            pos: usize = 0,
+
+            fn getStream(it: *TrieIterator) std.io.FixedBufferStream([]const u8) {
+                return std.io.fixedBufferStream(it.data[it.pos..]);
+            }
+
+            fn readUleb128(it: *TrieIterator) !u64 {
+                var stream = it.getStream();
+                var creader = std.io.countingReader(stream.reader());
+                const reader = creader.reader();
+                const value = try std.leb.readUleb128(u64, reader);
+                it.pos += creader.bytes_read;
+                return value;
+            }
+
+            fn readString(it: *TrieIterator) ![:0]const u8 {
+                var stream = it.getStream();
+                const reader = stream.reader();
+
+                var count: usize = 0;
+                while (true) : (count += 1) {
+                    const byte = try reader.readByte();
+                    if (byte == 0) break;
+                }
+
+                const str = @as([*:0]const u8, @ptrCast(it.data.ptr + it.pos))[0..count :0];
+                it.pos += count + 1;
+                return str;
+            }
+
+            fn readByte(it: *TrieIterator) !u8 {
+                var stream = it.getStream();
+                const value = try stream.reader().readByte();
+                it.pos += 1;
+                return value;
+            }
+        };
+
         const Export = struct {
             name: []const u8,
             tag: enum { @"export", reexport, stub_resolver },
@@ -1506,17 +1544,17 @@ const MachODumper = struct {
 
         fn parseTrieNode(
             arena: Allocator,
-            r: *std.io.Reader,
+            it: *TrieIterator,
             prefix: []const u8,
             exports: *std.ArrayList(Export),
         ) !void {
-            const size = try r.takeLeb128(u64);
+            const size = try it.readUleb128();
             if (size > 0) {
-                const flags = try r.takeLeb128(u8);
+                const flags = try it.readUleb128();
                 switch (flags) {
                     macho.EXPORT_SYMBOL_FLAGS_REEXPORT => {
-                        const ord = try r.takeLeb128(u64);
-                        const name = try r.takeSentinel(0);
+                        const ord = try it.readUleb128();
+                        const name = try arena.dupe(u8, try it.readString());
                         try exports.append(.{
                             .name = if (name.len > 0) name else prefix,
                             .tag = .reexport,
@@ -1524,8 +1562,8 @@ const MachODumper = struct {
                         });
                     },
                     macho.EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER => {
-                        const stub_offset = try r.takeLeb128(u64);
-                        const resolver_offset = try r.takeLeb128(u64);
+                        const stub_offset = try it.readUleb128();
+                        const resolver_offset = try it.readUleb128();
                         try exports.append(.{
                             .name = prefix,
                             .tag = .stub_resolver,
@@ -1536,7 +1574,7 @@ const MachODumper = struct {
                         });
                     },
                     else => {
-                        const vmoff = try r.takeLeb128(u64);
+                        const vmoff = try it.readUleb128();
                         try exports.append(.{
                             .name = prefix,
                             .tag = .@"export",
@@ -1555,21 +1593,21 @@ const MachODumper = struct {
                 }
             }
 
-            const nedges = try r.takeByte();
+            const nedges = try it.readByte();
             for (0..nedges) |_| {
-                const label = try r.takeSentinel(0);
-                const off = try r.takeLeb128(usize);
+                const label = try it.readString();
+                const off = try it.readUleb128();
                 const prefix_label = try std.fmt.allocPrint(arena, "{s}{s}", .{ prefix, label });
-                const seek = r.seek;
-                r.seek = off;
-                try parseTrieNode(arena, r, prefix_label, exports);
-                r.seek = seek;
+                const curr = it.pos;
+                it.pos = off;
+                try parseTrieNode(arena, it, prefix_label, exports);
+                it.pos = curr;
             }
         }
 
-        fn dumpSection(ctx: ObjectContext, sect: macho.section_64, bw: *Writer) !void {
+        fn dumpSection(ctx: ObjectContext, sect: macho.section_64, writer: anytype) !void {
             const data = ctx.data[sect.offset..][0..sect.size];
-            try bw.print("{s}", .{data});
+            try writer.print("{s}", .{data});
         }
     };
 
@@ -1583,30 +1621,29 @@ const MachODumper = struct {
         var ctx = ObjectContext{ .gpa = gpa, .data = bytes, .header = hdr };
         try ctx.parse();
 
-        var aw: std.io.Writer.Allocating = .init(gpa);
-        defer aw.deinit();
-        const bw = &aw.writer;
+        var output = std.ArrayList(u8).init(gpa);
+        const writer = output.writer();
 
         switch (check.kind) {
             .headers => {
-                try ObjectContext.dumpHeader(ctx.header, bw);
+                try ObjectContext.dumpHeader(ctx.header, writer);
 
                 var it = ctx.getLoadCommandIterator();
                 var i: usize = 0;
                 while (it.next()) |cmd| {
-                    try ObjectContext.dumpLoadCommand(cmd, i, bw);
-                    try bw.writeByte('\n');
+                    try ObjectContext.dumpLoadCommand(cmd, i, writer);
+                    try writer.writeByte('\n');
 
                     i += 1;
                 }
             },
 
             .symtab => if (ctx.symtab.items.len > 0) {
-                try ctx.dumpSymtab(bw);
+                try ctx.dumpSymtab(writer);
             } else return step.fail("no symbol table found", .{}),
 
             .indirect_symtab => if (ctx.symtab.items.len > 0 and ctx.indsymtab.items.len > 0) {
-                try ctx.dumpIndirectSymtab(bw);
+                try ctx.dumpIndirectSymtab(writer);
             } else return step.fail("no indirect symbol table found", .{}),
 
             .dyld_rebase,
@@ -1621,26 +1658,26 @@ const MachODumper = struct {
                 switch (check.kind) {
                     .dyld_rebase => if (lc.rebase_size > 0) {
                         const data = ctx.data[lc.rebase_off..][0..lc.rebase_size];
-                        try bw.writeAll(dyld_rebase_label ++ "\n");
-                        try ctx.dumpRebaseInfo(data, bw);
+                        try writer.writeAll(dyld_rebase_label ++ "\n");
+                        try ctx.dumpRebaseInfo(data, writer);
                     } else return step.fail("no rebase data found", .{}),
 
                     .dyld_bind => if (lc.bind_size > 0) {
                         const data = ctx.data[lc.bind_off..][0..lc.bind_size];
-                        try bw.writeAll(dyld_bind_label ++ "\n");
-                        try ctx.dumpBindInfo(data, bw);
+                        try writer.writeAll(dyld_bind_label ++ "\n");
+                        try ctx.dumpBindInfo(data, writer);
                     } else return step.fail("no bind data found", .{}),
 
                     .dyld_weak_bind => if (lc.weak_bind_size > 0) {
                         const data = ctx.data[lc.weak_bind_off..][0..lc.weak_bind_size];
-                        try bw.writeAll(dyld_weak_bind_label ++ "\n");
-                        try ctx.dumpBindInfo(data, bw);
+                        try writer.writeAll(dyld_weak_bind_label ++ "\n");
+                        try ctx.dumpBindInfo(data, writer);
                     } else return step.fail("no weak bind data found", .{}),
 
                     .dyld_lazy_bind => if (lc.lazy_bind_size > 0) {
                         const data = ctx.data[lc.lazy_bind_off..][0..lc.lazy_bind_size];
-                        try bw.writeAll(dyld_lazy_bind_label ++ "\n");
-                        try ctx.dumpBindInfo(data, bw);
+                        try writer.writeAll(dyld_lazy_bind_label ++ "\n");
+                        try ctx.dumpBindInfo(data, writer);
                     } else return step.fail("no lazy bind data found", .{}),
 
                     else => unreachable,
@@ -1652,8 +1689,8 @@ const MachODumper = struct {
                     const lc = cmd.cast(macho.dyld_info_command).?;
                     if (lc.export_size > 0) {
                         const data = ctx.data[lc.export_off..][0..lc.export_size];
-                        try bw.writeAll(exports_label ++ "\n");
-                        try ctx.dumpExportsTrie(data, bw);
+                        try writer.writeAll(exports_label ++ "\n");
+                        try ctx.dumpExportsTrie(data, writer);
                         break :blk;
                     }
                 }
@@ -1661,20 +1698,20 @@ const MachODumper = struct {
             },
 
             .dump_section => {
-                const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(check.data.items[check.payload.dump_section..].ptr)), 0);
+                const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(check.data.items.ptr + check.payload.dump_section)), 0);
                 const sep_index = mem.indexOfScalar(u8, name, ',') orelse
                     return step.fail("invalid section name: {s}", .{name});
                 const segname = name[0..sep_index];
                 const sectname = name[sep_index + 1 ..];
                 const sect = ctx.getSectionByName(segname, sectname) orelse
                     return step.fail("section '{s}' not found", .{name});
-                try ctx.dumpSection(sect, bw);
+                try ctx.dumpSection(sect, writer);
             },
 
             else => return step.fail("invalid check kind for MachO file format: {s}", .{@tagName(check.kind)}),
         }
 
-        return aw.toOwnedSlice();
+        return output.toOwnedSlice();
     }
 };
 
@@ -1693,138 +1730,161 @@ const ElfDumper = struct {
 
     fn parseAndDumpArchive(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
         const gpa = step.owner.allocator;
-        var r: std.io.Reader = .fixed(bytes);
+        var stream = std.io.fixedBufferStream(bytes);
+        const reader = stream.reader();
 
-        if (!mem.eql(u8, try r.takeArray(elf.ARMAG.len), elf.ARMAG)) return error.InvalidArchiveMagicNumber;
+        const magic = try reader.readBytesNoEof(elf.ARMAG.len);
+        if (!mem.eql(u8, &magic, elf.ARMAG)) {
+            return error.InvalidArchiveMagicNumber;
+        }
 
-        var ctx: ArchiveContext = .{
+        var ctx = ArchiveContext{
             .gpa = gpa,
             .data = bytes,
-            .symtab = &.{},
-            .strtab = &.{},
-            .objects = .empty,
+            .strtab = &[0]u8{},
         };
-        defer ctx.deinit();
+        defer {
+            for (ctx.objects.items) |*object| {
+                gpa.free(object.name);
+            }
+            ctx.objects.deinit(gpa);
+        }
+
+        while (true) {
+            if (stream.pos >= ctx.data.len) break;
+            if (!mem.isAligned(stream.pos, 2)) stream.pos += 1;
 
-        while (r.seek < bytes.len) {
-            const hdr_seek = std.mem.alignForward(usize, r.seek, 2);
-            r.seek = hdr_seek;
-            const hdr = try r.takeStruct(elf.ar_hdr);
+            const hdr = try reader.readStruct(elf.ar_hdr);
 
             if (!mem.eql(u8, &hdr.ar_fmag, elf.ARFMAG)) return error.InvalidArchiveHeaderMagicNumber;
 
-            const data = try r.take(try hdr.size());
+            const size = try hdr.size();
+            defer {
+                _ = stream.seekBy(size) catch {};
+            }
 
             if (hdr.isSymtab()) {
-                try ctx.parseSymtab(data, .p32);
+                try ctx.parseSymtab(ctx.data[stream.pos..][0..size], .p32);
                 continue;
             }
             if (hdr.isSymtab64()) {
-                try ctx.parseSymtab(data, .p64);
+                try ctx.parseSymtab(ctx.data[stream.pos..][0..size], .p64);
                 continue;
             }
             if (hdr.isStrtab()) {
-                ctx.strtab = data;
+                ctx.strtab = ctx.data[stream.pos..][0..size];
                 continue;
             }
             if (hdr.isSymdef() or hdr.isSymdefSorted()) continue;
 
-            const name = hdr.name() orelse ctx.getString((try hdr.nameOffset()).?);
-            try ctx.objects.putNoClobber(gpa, hdr_seek, .{
-                .name = name,
-                .data = data,
-            });
+            const name = if (hdr.name()) |name|
+                try gpa.dupe(u8, name)
+            else if (try hdr.nameOffset()) |off|
+                try gpa.dupe(u8, ctx.getString(off))
+            else
+                unreachable;
+
+            try ctx.objects.append(gpa, .{ .name = name, .off = stream.pos, .len = size });
         }
 
-        var aw: std.io.Writer.Allocating = .init(gpa);
-        defer aw.deinit();
-        const bw = &aw.writer;
+        var output = std.ArrayList(u8).init(gpa);
+        const writer = output.writer();
 
         switch (check.kind) {
-            .archive_symtab => if (ctx.symtab.len > 0) {
-                try ctx.dumpSymtab(bw);
+            .archive_symtab => if (ctx.symtab.items.len > 0) {
+                try ctx.dumpSymtab(writer);
             } else return step.fail("no archive symbol table found", .{}),
 
-            else => if (ctx.objects.count() > 0) {
-                try ctx.dumpObjects(step, check, bw);
+            else => if (ctx.objects.items.len > 0) {
+                try ctx.dumpObjects(step, check, writer);
             } else return step.fail("empty archive", .{}),
         }
 
-        return aw.toOwnedSlice();
+        return output.toOwnedSlice();
     }
 
     const ArchiveContext = struct {
         gpa: Allocator,
         data: []const u8,
-        symtab: []ArSymtabEntry,
+        symtab: std.ArrayListUnmanaged(ArSymtabEntry) = .empty,
         strtab: []const u8,
-        objects: std.AutoArrayHashMapUnmanaged(usize, struct { name: []const u8, data: []const u8 }),
+        objects: std.ArrayListUnmanaged(struct { name: []const u8, off: usize, len: usize }) = .empty,
 
-        fn deinit(ctx: *ArchiveContext) void {
-            ctx.gpa.free(ctx.symtab);
-            ctx.objects.deinit(ctx.gpa);
-        }
-
-        fn parseSymtab(ctx: *ArchiveContext, data: []const u8, ptr_width: enum { p32, p64 }) !void {
-            var r: std.io.Reader = .fixed(data);
+        fn parseSymtab(ctx: *ArchiveContext, raw: []const u8, ptr_width: enum { p32, p64 }) !void {
+            var stream = std.io.fixedBufferStream(raw);
+            const reader = stream.reader();
             const num = switch (ptr_width) {
-                .p32 => try r.takeInt(u32, .big),
-                .p64 => try r.takeInt(u64, .big),
+                .p32 => try reader.readInt(u32, .big),
+                .p64 => try reader.readInt(u64, .big),
             };
             const ptr_size: usize = switch (ptr_width) {
                 .p32 => @sizeOf(u32),
                 .p64 => @sizeOf(u64),
             };
-            _ = try r.discard(.limited(num * ptr_size));
-            const strtab = r.buffered();
+            const strtab_off = (num + 1) * ptr_size;
+            const strtab_len = raw.len - strtab_off;
+            const strtab = raw[strtab_off..][0..strtab_len];
 
-            assert(ctx.symtab.len == 0);
-            ctx.symtab = try ctx.gpa.alloc(ArSymtabEntry, num);
+            try ctx.symtab.ensureTotalCapacityPrecise(ctx.gpa, num);
 
             var stroff: usize = 0;
-            for (ctx.symtab) |*entry| {
+            for (0..num) |_| {
                 const off = switch (ptr_width) {
-                    .p32 => try r.takeInt(u32, .big),
-                    .p64 => try r.takeInt(u64, .big),
+                    .p32 => try reader.readInt(u32, .big),
+                    .p64 => try reader.readInt(u64, .big),
                 };
-                const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab[stroff..].ptr)), 0);
+                const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + stroff)), 0);
                 stroff += name.len + 1;
-                entry.* = .{ .off = off, .name = name };
+                ctx.symtab.appendAssumeCapacity(.{ .off = off, .name = name });
             }
         }
 
-        fn dumpSymtab(ctx: ArchiveContext, bw: *Writer) !void {
-            var symbols: std.AutoArrayHashMap(usize, std.ArrayList([]const u8)) = .init(ctx.gpa);
+        fn dumpSymtab(ctx: ArchiveContext, writer: anytype) !void {
+            var files = std.AutoHashMap(usize, []const u8).init(ctx.gpa);
+            defer files.deinit();
+            try files.ensureUnusedCapacity(@intCast(ctx.objects.items.len));
+
+            for (ctx.objects.items) |object| {
+                files.putAssumeCapacityNoClobber(object.off - @sizeOf(elf.ar_hdr), object.name);
+            }
+
+            var symbols = std.AutoArrayHashMap(usize, std.ArrayList([]const u8)).init(ctx.gpa);
             defer {
-                for (symbols.values()) |*value| value.deinit();
+                for (symbols.values()) |*value| {
+                    value.deinit();
+                }
                 symbols.deinit();
             }
 
-            for (ctx.symtab) |entry| {
+            for (ctx.symtab.items) |entry| {
                 const gop = try symbols.getOrPut(@intCast(entry.off));
-                if (!gop.found_existing) gop.value_ptr.* = .init(ctx.gpa);
+                if (!gop.found_existing) {
+                    gop.value_ptr.* = std.ArrayList([]const u8).init(ctx.gpa);
+                }
                 try gop.value_ptr.append(entry.name);
             }
 
-            try bw.print("{s}\n", .{archive_symtab_label});
+            try writer.print("{s}\n", .{archive_symtab_label});
             for (symbols.keys(), symbols.values()) |off, values| {
-                try bw.print("in object {s}\n", .{ctx.objects.get(off).?.name});
-                for (values.items) |value| try bw.print("{s}\n", .{value});
+                try writer.print("in object {s}\n", .{files.get(off).?});
+                for (values.items) |value| {
+                    try writer.print("{s}\n", .{value});
+                }
             }
         }
 
-        fn dumpObjects(ctx: ArchiveContext, step: *Step, check: Check, bw: *Writer) !void {
-            for (ctx.objects.values()) |object| {
-                try bw.print("object {s}\n", .{object.name});
-                const output = try parseAndDumpObject(step, check, object.data);
+        fn dumpObjects(ctx: ArchiveContext, step: *Step, check: Check, writer: anytype) !void {
+            for (ctx.objects.items) |object| {
+                try writer.print("object {s}\n", .{object.name});
+                const output = try parseAndDumpObject(step, check, ctx.data[object.off..][0..object.len]);
                 defer ctx.gpa.free(output);
-                try bw.print("{s}\n", .{output});
+                try writer.print("{s}\n", .{output});
             }
         }
 
         fn getString(ctx: ArchiveContext, off: u32) []const u8 {
             assert(off < ctx.strtab.len);
-            const name = mem.sliceTo(@as([*:'\n']const u8, @ptrCast(ctx.strtab[off..].ptr)), 0);
+            const name = mem.sliceTo(@as([*:'\n']const u8, @ptrCast(ctx.strtab.ptr + off)), 0);
             return name[0 .. name.len - 1];
         }
 
@@ -1836,23 +1896,24 @@ const ElfDumper = struct {
 
     fn parseAndDumpObject(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
         const gpa = step.owner.allocator;
-        var r: std.io.Reader = .fixed(bytes);
+        var stream = std.io.fixedBufferStream(bytes);
+        const reader = stream.reader();
 
-        const hdr = try r.takeStruct(elf.Elf64_Ehdr);
-        if (!mem.eql(u8, hdr.e_ident[0..4], "\x7fELF")) return error.InvalidMagicNumber;
+        const hdr = try reader.readStruct(elf.Elf64_Ehdr);
+        if (!mem.eql(u8, hdr.e_ident[0..4], "\x7fELF")) {
+            return error.InvalidMagicNumber;
+        }
 
-        const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(bytes[hdr.e_shoff..].ptr))[0..hdr.e_shnum];
-        const phdrs = @as([*]align(1) const elf.Elf64_Phdr, @ptrCast(bytes[hdr.e_phoff..].ptr))[0..hdr.e_phnum];
+        const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(bytes.ptr + hdr.e_shoff))[0..hdr.e_shnum];
+        const phdrs = @as([*]align(1) const elf.Elf64_Phdr, @ptrCast(bytes.ptr + hdr.e_phoff))[0..hdr.e_phnum];
 
-        var ctx: ObjectContext = .{
+        var ctx = ObjectContext{
             .gpa = gpa,
             .data = bytes,
             .hdr = hdr,
             .shdrs = shdrs,
             .phdrs = phdrs,
             .shstrtab = undefined,
-            .symtab = .{},
-            .dysymtab = .{},
         };
         ctx.shstrtab = ctx.getSectionContents(ctx.hdr.e_shstrndx);
 
@@ -1883,121 +1944,120 @@ const ElfDumper = struct {
             else => {},
         };
 
-        var aw: std.io.Writer.Allocating = .init(gpa);
-        defer aw.deinit();
-        const bw = &aw.writer;
+        var output = std.ArrayList(u8).init(gpa);
+        const writer = output.writer();
 
         switch (check.kind) {
             .headers => {
-                try ctx.dumpHeader(bw);
-                try ctx.dumpShdrs(bw);
-                try ctx.dumpPhdrs(bw);
+                try ctx.dumpHeader(writer);
+                try ctx.dumpShdrs(writer);
+                try ctx.dumpPhdrs(writer);
             },
 
             .symtab => if (ctx.symtab.symbols.len > 0) {
-                try ctx.dumpSymtab(.symtab, bw);
+                try ctx.dumpSymtab(.symtab, writer);
             } else return step.fail("no symbol table found", .{}),
 
             .dynamic_symtab => if (ctx.dysymtab.symbols.len > 0) {
-                try ctx.dumpSymtab(.dysymtab, bw);
+                try ctx.dumpSymtab(.dysymtab, writer);
             } else return step.fail("no dynamic symbol table found", .{}),
 
             .dynamic_section => if (ctx.getSectionByName(".dynamic")) |shndx| {
-                try ctx.dumpDynamicSection(shndx, bw);
+                try ctx.dumpDynamicSection(shndx, writer);
             } else return step.fail("no .dynamic section found", .{}),
 
             .dump_section => {
-                const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(check.data.items[check.payload.dump_section..].ptr)), 0);
+                const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(check.data.items.ptr + check.payload.dump_section)), 0);
                 const shndx = ctx.getSectionByName(name) orelse return step.fail("no '{s}' section found", .{name});
-                try ctx.dumpSection(shndx, bw);
+                try ctx.dumpSection(shndx, writer);
             },
 
             else => return step.fail("invalid check kind for ELF file format: {s}", .{@tagName(check.kind)}),
         }
 
-        return aw.toOwnedSlice();
+        return output.toOwnedSlice();
     }
 
     const ObjectContext = struct {
         gpa: Allocator,
         data: []const u8,
-        hdr: *align(1) const elf.Elf64_Ehdr,
+        hdr: elf.Elf64_Ehdr,
         shdrs: []align(1) const elf.Elf64_Shdr,
         phdrs: []align(1) const elf.Elf64_Phdr,
         shstrtab: []const u8,
-        symtab: Symtab,
-        dysymtab: Symtab,
+        symtab: Symtab = .{},
+        dysymtab: Symtab = .{},
 
-        fn dumpHeader(ctx: ObjectContext, bw: *Writer) !void {
-            try bw.writeAll("header\n");
-            try bw.print("type {s}\n", .{@tagName(ctx.hdr.e_type)});
-            try bw.print("entry {x}\n", .{ctx.hdr.e_entry});
+        fn dumpHeader(ctx: ObjectContext, writer: anytype) !void {
+            try writer.writeAll("header\n");
+            try writer.print("type {s}\n", .{@tagName(ctx.hdr.e_type)});
+            try writer.print("entry {x}\n", .{ctx.hdr.e_entry});
         }
 
-        fn dumpPhdrs(ctx: ObjectContext, bw: *Writer) !void {
+        fn dumpPhdrs(ctx: ObjectContext, writer: anytype) !void {
             if (ctx.phdrs.len == 0) return;
 
-            try bw.writeAll("program headers\n");
+            try writer.writeAll("program headers\n");
 
             for (ctx.phdrs, 0..) |phdr, phndx| {
-                try bw.print("phdr {d}\n", .{phndx});
-                try bw.print("type {f}\n", .{fmtPhType(phdr.p_type)});
-                try bw.print("vaddr {x}\n", .{phdr.p_vaddr});
-                try bw.print("paddr {x}\n", .{phdr.p_paddr});
-                try bw.print("offset {x}\n", .{phdr.p_offset});
-                try bw.print("memsz {x}\n", .{phdr.p_memsz});
-                try bw.print("filesz {x}\n", .{phdr.p_filesz});
-                try bw.print("align {x}\n", .{phdr.p_align});
+                try writer.print("phdr {d}\n", .{phndx});
+                try writer.print("type {f}\n", .{fmtPhType(phdr.p_type)});
+                try writer.print("vaddr {x}\n", .{phdr.p_vaddr});
+                try writer.print("paddr {x}\n", .{phdr.p_paddr});
+                try writer.print("offset {x}\n", .{phdr.p_offset});
+                try writer.print("memsz {x}\n", .{phdr.p_memsz});
+                try writer.print("filesz {x}\n", .{phdr.p_filesz});
+                try writer.print("align {x}\n", .{phdr.p_align});
 
                 {
                     const flags = phdr.p_flags;
-                    try bw.writeAll("flags");
-                    if (flags > 0) try bw.writeByte(' ');
+                    try writer.writeAll("flags");
+                    if (flags > 0) try writer.writeByte(' ');
                     if (flags & elf.PF_R != 0) {
-                        try bw.writeByte('R');
+                        try writer.writeByte('R');
                     }
                     if (flags & elf.PF_W != 0) {
-                        try bw.writeByte('W');
+                        try writer.writeByte('W');
                     }
                     if (flags & elf.PF_X != 0) {
-                        try bw.writeByte('E');
+                        try writer.writeByte('E');
                     }
                     if (flags & elf.PF_MASKOS != 0) {
-                        try bw.writeAll("OS");
+                        try writer.writeAll("OS");
                     }
                     if (flags & elf.PF_MASKPROC != 0) {
-                        try bw.writeAll("PROC");
+                        try writer.writeAll("PROC");
                     }
-                    try bw.writeByte('\n');
+                    try writer.writeByte('\n');
                 }
             }
         }
 
-        fn dumpShdrs(ctx: ObjectContext, bw: *Writer) !void {
+        fn dumpShdrs(ctx: ObjectContext, writer: anytype) !void {
             if (ctx.shdrs.len == 0) return;
 
-            try bw.writeAll("section headers\n");
+            try writer.writeAll("section headers\n");
 
             for (ctx.shdrs, 0..) |shdr, shndx| {
-                try bw.print("shdr {d}\n", .{shndx});
-                try bw.print("name {s}\n", .{ctx.getSectionName(shndx)});
-                try bw.print("type {f}\n", .{fmtShType(shdr.sh_type)});
-                try bw.print("addr {x}\n", .{shdr.sh_addr});
-                try bw.print("offset {x}\n", .{shdr.sh_offset});
-                try bw.print("size {x}\n", .{shdr.sh_size});
-                try bw.print("addralign {x}\n", .{shdr.sh_addralign});
+                try writer.print("shdr {d}\n", .{shndx});
+                try writer.print("name {s}\n", .{ctx.getSectionName(shndx)});
+                try writer.print("type {f}\n", .{fmtShType(shdr.sh_type)});
+                try writer.print("addr {x}\n", .{shdr.sh_addr});
+                try writer.print("offset {x}\n", .{shdr.sh_offset});
+                try writer.print("size {x}\n", .{shdr.sh_size});
+                try writer.print("addralign {x}\n", .{shdr.sh_addralign});
                 // TODO dump formatted sh_flags
             }
         }
 
-        fn dumpDynamicSection(ctx: ObjectContext, shndx: usize, bw: *Writer) !void {
+        fn dumpDynamicSection(ctx: ObjectContext, shndx: usize, writer: anytype) !void {
             const shdr = ctx.shdrs[shndx];
             const strtab = ctx.getSectionContents(shdr.sh_link);
             const data = ctx.getSectionContents(shndx);
             const nentries = @divExact(data.len, @sizeOf(elf.Elf64_Dyn));
             const entries = @as([*]align(1) const elf.Elf64_Dyn, @ptrCast(data.ptr))[0..nentries];
 
-            try bw.writeAll(ElfDumper.dynamic_section_label ++ "\n");
+            try writer.writeAll(ElfDumper.dynamic_section_label ++ "\n");
 
             for (entries) |entry| {
                 const key = @as(u64, @bitCast(entry.d_tag));
@@ -2038,7 +2098,7 @@ const ElfDumper = struct {
                     elf.DT_NULL => "NULL",
                     else => "UNKNOWN",
                 };
-                try bw.print("{s}", .{key_str});
+                try writer.print("{s}", .{key_str});
 
                 switch (key) {
                     elf.DT_NEEDED,
@@ -2047,7 +2107,7 @@ const ElfDumper = struct {
                     elf.DT_RUNPATH,
                     => {
                         const name = getString(strtab, @intCast(value));
-                        try bw.print(" {s}", .{name});
+                        try writer.print(" {s}", .{name});
                     },
 
                     elf.DT_INIT_ARRAY,
@@ -2065,7 +2125,7 @@ const ElfDumper = struct {
                     elf.DT_INIT,
                     elf.DT_FINI,
                     elf.DT_NULL,
-                    => try bw.print(" {x}", .{value}),
+                    => try writer.print(" {x}", .{value}),
 
                     elf.DT_INIT_ARRAYSZ,
                     elf.DT_FINI_ARRAYSZ,
@@ -2075,77 +2135,77 @@ const ElfDumper = struct {
                     elf.DT_RELASZ,
                     elf.DT_RELAENT,
                     elf.DT_RELACOUNT,
-                    => try bw.print(" {d}", .{value}),
+                    => try writer.print(" {d}", .{value}),
 
-                    elf.DT_PLTREL => try bw.writeAll(switch (value) {
+                    elf.DT_PLTREL => try writer.writeAll(switch (value) {
                         elf.DT_REL => " REL",
                         elf.DT_RELA => " RELA",
                         else => " UNKNOWN",
                     }),
 
                     elf.DT_FLAGS => if (value > 0) {
-                        if (value & elf.DF_ORIGIN != 0) try bw.writeAll(" ORIGIN");
-                        if (value & elf.DF_SYMBOLIC != 0) try bw.writeAll(" SYMBOLIC");
-                        if (value & elf.DF_TEXTREL != 0) try bw.writeAll(" TEXTREL");
-                        if (value & elf.DF_BIND_NOW != 0) try bw.writeAll(" BIND_NOW");
-                        if (value & elf.DF_STATIC_TLS != 0) try bw.writeAll(" STATIC_TLS");
+                        if (value & elf.DF_ORIGIN != 0) try writer.writeAll(" ORIGIN");
+                        if (value & elf.DF_SYMBOLIC != 0) try writer.writeAll(" SYMBOLIC");
+                        if (value & elf.DF_TEXTREL != 0) try writer.writeAll(" TEXTREL");
+                        if (value & elf.DF_BIND_NOW != 0) try writer.writeAll(" BIND_NOW");
+                        if (value & elf.DF_STATIC_TLS != 0) try writer.writeAll(" STATIC_TLS");
                     },
 
                     elf.DT_FLAGS_1 => if (value > 0) {
-                        if (value & elf.DF_1_NOW != 0) try bw.writeAll(" NOW");
-                        if (value & elf.DF_1_GLOBAL != 0) try bw.writeAll(" GLOBAL");
-                        if (value & elf.DF_1_GROUP != 0) try bw.writeAll(" GROUP");
-                        if (value & elf.DF_1_NODELETE != 0) try bw.writeAll(" NODELETE");
-                        if (value & elf.DF_1_LOADFLTR != 0) try bw.writeAll(" LOADFLTR");
-                        if (value & elf.DF_1_INITFIRST != 0) try bw.writeAll(" INITFIRST");
-                        if (value & elf.DF_1_NOOPEN != 0) try bw.writeAll(" NOOPEN");
-                        if (value & elf.DF_1_ORIGIN != 0) try bw.writeAll(" ORIGIN");
-                        if (value & elf.DF_1_DIRECT != 0) try bw.writeAll(" DIRECT");
-                        if (value & elf.DF_1_TRANS != 0) try bw.writeAll(" TRANS");
-                        if (value & elf.DF_1_INTERPOSE != 0) try bw.writeAll(" INTERPOSE");
-                        if (value & elf.DF_1_NODEFLIB != 0) try bw.writeAll(" NODEFLIB");
-                        if (value & elf.DF_1_NODUMP != 0) try bw.writeAll(" NODUMP");
-                        if (value & elf.DF_1_CONFALT != 0) try bw.writeAll(" CONFALT");
-                        if (value & elf.DF_1_ENDFILTEE != 0) try bw.writeAll(" ENDFILTEE");
-                        if (value & elf.DF_1_DISPRELDNE != 0) try bw.writeAll(" DISPRELDNE");
-                        if (value & elf.DF_1_DISPRELPND != 0) try bw.writeAll(" DISPRELPND");
-                        if (value & elf.DF_1_NODIRECT != 0) try bw.writeAll(" NODIRECT");
-                        if (value & elf.DF_1_IGNMULDEF != 0) try bw.writeAll(" IGNMULDEF");
-                        if (value & elf.DF_1_NOKSYMS != 0) try bw.writeAll(" NOKSYMS");
-                        if (value & elf.DF_1_NOHDR != 0) try bw.writeAll(" NOHDR");
-                        if (value & elf.DF_1_EDITED != 0) try bw.writeAll(" EDITED");
-                        if (value & elf.DF_1_NORELOC != 0) try bw.writeAll(" NORELOC");
-                        if (value & elf.DF_1_SYMINTPOSE != 0) try bw.writeAll(" SYMINTPOSE");
-                        if (value & elf.DF_1_GLOBAUDIT != 0) try bw.writeAll(" GLOBAUDIT");
-                        if (value & elf.DF_1_SINGLETON != 0) try bw.writeAll(" SINGLETON");
-                        if (value & elf.DF_1_STUB != 0) try bw.writeAll(" STUB");
-                        if (value & elf.DF_1_PIE != 0) try bw.writeAll(" PIE");
+                        if (value & elf.DF_1_NOW != 0) try writer.writeAll(" NOW");
+                        if (value & elf.DF_1_GLOBAL != 0) try writer.writeAll(" GLOBAL");
+                        if (value & elf.DF_1_GROUP != 0) try writer.writeAll(" GROUP");
+                        if (value & elf.DF_1_NODELETE != 0) try writer.writeAll(" NODELETE");
+                        if (value & elf.DF_1_LOADFLTR != 0) try writer.writeAll(" LOADFLTR");
+                        if (value & elf.DF_1_INITFIRST != 0) try writer.writeAll(" INITFIRST");
+                        if (value & elf.DF_1_NOOPEN != 0) try writer.writeAll(" NOOPEN");
+                        if (value & elf.DF_1_ORIGIN != 0) try writer.writeAll(" ORIGIN");
+                        if (value & elf.DF_1_DIRECT != 0) try writer.writeAll(" DIRECT");
+                        if (value & elf.DF_1_TRANS != 0) try writer.writeAll(" TRANS");
+                        if (value & elf.DF_1_INTERPOSE != 0) try writer.writeAll(" INTERPOSE");
+                        if (value & elf.DF_1_NODEFLIB != 0) try writer.writeAll(" NODEFLIB");
+                        if (value & elf.DF_1_NODUMP != 0) try writer.writeAll(" NODUMP");
+                        if (value & elf.DF_1_CONFALT != 0) try writer.writeAll(" CONFALT");
+                        if (value & elf.DF_1_ENDFILTEE != 0) try writer.writeAll(" ENDFILTEE");
+                        if (value & elf.DF_1_DISPRELDNE != 0) try writer.writeAll(" DISPRELDNE");
+                        if (value & elf.DF_1_DISPRELPND != 0) try writer.writeAll(" DISPRELPND");
+                        if (value & elf.DF_1_NODIRECT != 0) try writer.writeAll(" NODIRECT");
+                        if (value & elf.DF_1_IGNMULDEF != 0) try writer.writeAll(" IGNMULDEF");
+                        if (value & elf.DF_1_NOKSYMS != 0) try writer.writeAll(" NOKSYMS");
+                        if (value & elf.DF_1_NOHDR != 0) try writer.writeAll(" NOHDR");
+                        if (value & elf.DF_1_EDITED != 0) try writer.writeAll(" EDITED");
+                        if (value & elf.DF_1_NORELOC != 0) try writer.writeAll(" NORELOC");
+                        if (value & elf.DF_1_SYMINTPOSE != 0) try writer.writeAll(" SYMINTPOSE");
+                        if (value & elf.DF_1_GLOBAUDIT != 0) try writer.writeAll(" GLOBAUDIT");
+                        if (value & elf.DF_1_SINGLETON != 0) try writer.writeAll(" SINGLETON");
+                        if (value & elf.DF_1_STUB != 0) try writer.writeAll(" STUB");
+                        if (value & elf.DF_1_PIE != 0) try writer.writeAll(" PIE");
                     },
 
-                    else => try bw.print(" {x}", .{value}),
+                    else => try writer.print(" {x}", .{value}),
                 }
-                try bw.writeByte('\n');
+                try writer.writeByte('\n');
             }
         }
 
-        fn dumpSymtab(ctx: ObjectContext, comptime @"type": enum { symtab, dysymtab }, bw: *Writer) !void {
+        fn dumpSymtab(ctx: ObjectContext, comptime @"type": enum { symtab, dysymtab }, writer: anytype) !void {
             const symtab = switch (@"type") {
                 .symtab => ctx.symtab,
                 .dysymtab => ctx.dysymtab,
             };
 
-            try bw.writeAll(switch (@"type") {
+            try writer.writeAll(switch (@"type") {
                 .symtab => symtab_label,
                 .dysymtab => dynamic_symtab_label,
             } ++ "\n");
 
             for (symtab.symbols, 0..) |sym, index| {
-                try bw.print("{x} {x}", .{ sym.st_value, sym.st_size });
+                try writer.print("{x} {x}", .{ sym.st_value, sym.st_size });
 
                 {
                     if (elf.SHN_LORESERVE <= sym.st_shndx and sym.st_shndx < elf.SHN_HIRESERVE) {
                         if (elf.SHN_LOPROC <= sym.st_shndx and sym.st_shndx < elf.SHN_HIPROC) {
-                            try bw.print(" LO+{d}", .{sym.st_shndx - elf.SHN_LOPROC});
+                            try writer.print(" LO+{d}", .{sym.st_shndx - elf.SHN_LOPROC});
                         } else {
                             const sym_ndx = switch (sym.st_shndx) {
                                 elf.SHN_ABS => "ABS",
@@ -2153,12 +2213,12 @@ const ElfDumper = struct {
                                 elf.SHN_LIVEPATCH => "LIV",
                                 else => "UNK",
                             };
-                            try bw.print(" {s}", .{sym_ndx});
+                            try writer.print(" {s}", .{sym_ndx});
                         }
                     } else if (sym.st_shndx == elf.SHN_UNDEF) {
-                        try bw.writeAll(" UND");
+                        try writer.writeAll(" UND");
                     } else {
-                        try bw.print(" {x}", .{sym.st_shndx});
+                        try writer.print(" {x}", .{sym.st_shndx});
                     }
                 }
 
@@ -2175,12 +2235,12 @@ const ElfDumper = struct {
                         elf.STT_NUM => "NUM",
                         elf.STT_GNU_IFUNC => "IFUNC",
                         else => if (elf.STT_LOPROC <= tt and tt < elf.STT_HIPROC) {
-                            break :blk try bw.print(" LOPROC+{d}", .{tt - elf.STT_LOPROC});
+                            break :blk try writer.print(" LOPROC+{d}", .{tt - elf.STT_LOPROC});
                         } else if (elf.STT_LOOS <= tt and tt < elf.STT_HIOS) {
-                            break :blk try bw.print(" LOOS+{d}", .{tt - elf.STT_LOOS});
+                            break :blk try writer.print(" LOOS+{d}", .{tt - elf.STT_LOOS});
                         } else "UNK",
                     };
-                    try bw.print(" {s}", .{sym_type});
+                    try writer.print(" {s}", .{sym_type});
                 }
 
                 blk: {
@@ -2191,28 +2251,28 @@ const ElfDumper = struct {
                         elf.STB_WEAK => "WEAK",
                         elf.STB_NUM => "NUM",
                         else => if (elf.STB_LOPROC <= bind and bind < elf.STB_HIPROC) {
-                            break :blk try bw.print(" LOPROC+{d}", .{bind - elf.STB_LOPROC});
+                            break :blk try writer.print(" LOPROC+{d}", .{bind - elf.STB_LOPROC});
                         } else if (elf.STB_LOOS <= bind and bind < elf.STB_HIOS) {
-                            break :blk try bw.print(" LOOS+{d}", .{bind - elf.STB_LOOS});
+                            break :blk try writer.print(" LOOS+{d}", .{bind - elf.STB_LOOS});
                         } else "UNKNOWN",
                     };
-                    try bw.print(" {s}", .{sym_bind});
+                    try writer.print(" {s}", .{sym_bind});
                 }
 
                 const sym_vis = @as(elf.STV, @enumFromInt(@as(u2, @truncate(sym.st_other))));
-                try bw.print(" {s}", .{@tagName(sym_vis)});
+                try writer.print(" {s}", .{@tagName(sym_vis)});
 
                 const sym_name = switch (sym.st_type()) {
                     elf.STT_SECTION => ctx.getSectionName(sym.st_shndx),
                     else => symtab.getName(index).?,
                 };
-                try bw.print(" {s}\n", .{sym_name});
+                try writer.print(" {s}\n", .{sym_name});
             }
         }
 
-        fn dumpSection(ctx: ObjectContext, shndx: usize, bw: *Writer) !void {
+        fn dumpSection(ctx: ObjectContext, shndx: usize, writer: anytype) !void {
             const data = ctx.getSectionContents(shndx);
-            try bw.print("{s}", .{data});
+            try writer.print("{s}", .{data});
         }
 
         inline fn getSectionName(ctx: ObjectContext, shndx: usize) []const u8 {
@@ -2250,15 +2310,15 @@ const ElfDumper = struct {
     };
 
     fn getString(strtab: []const u8, off: u32) []const u8 {
-        const str = strtab[off..];
-        return str[0..std.mem.indexOfScalar(u8, str, 0).?];
+        assert(off < strtab.len);
+        return mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + off)), 0);
     }
 
     fn fmtShType(sh_type: u32) std.fmt.Formatter(u32, formatShType) {
         return .{ .data = sh_type };
     }
 
-    fn formatShType(sh_type: u32, w: *Writer) Writer.Error!void {
+    fn formatShType(sh_type: u32, writer: *Writer) Writer.Error!void {
         const name = switch (sh_type) {
             elf.SHT_NULL => "NULL",
             elf.SHT_PROGBITS => "PROGBITS",
@@ -2284,21 +2344,21 @@ const ElfDumper = struct {
             elf.SHT_GNU_VERNEED => "VERNEED",
             elf.SHT_GNU_VERSYM => "VERSYM",
             else => if (elf.SHT_LOOS <= sh_type and sh_type < elf.SHT_HIOS) {
-                return try w.print("LOOS+0x{x}", .{sh_type - elf.SHT_LOOS});
+                return try writer.print("LOOS+0x{x}", .{sh_type - elf.SHT_LOOS});
             } else if (elf.SHT_LOPROC <= sh_type and sh_type < elf.SHT_HIPROC) {
-                return try w.print("LOPROC+0x{x}", .{sh_type - elf.SHT_LOPROC});
+                return try writer.print("LOPROC+0x{x}", .{sh_type - elf.SHT_LOPROC});
             } else if (elf.SHT_LOUSER <= sh_type and sh_type < elf.SHT_HIUSER) {
-                return try w.print("LOUSER+0x{x}", .{sh_type - elf.SHT_LOUSER});
+                return try writer.print("LOUSER+0x{x}", .{sh_type - elf.SHT_LOUSER});
             } else "UNKNOWN",
         };
-        try w.writeAll(name);
+        try writer.writeAll(name);
     }
 
     fn fmtPhType(ph_type: u32) std.fmt.Formatter(u32, formatPhType) {
         return .{ .data = ph_type };
     }
 
-    fn formatPhType(ph_type: u32, w: *Writer) Writer.Error!void {
+    fn formatPhType(ph_type: u32, writer: *Writer) Writer.Error!void {
         const p_type = switch (ph_type) {
             elf.PT_NULL => "NULL",
             elf.PT_LOAD => "LOAD",
@@ -2313,12 +2373,12 @@ const ElfDumper = struct {
             elf.PT_GNU_STACK => "GNU_STACK",
             elf.PT_GNU_RELRO => "GNU_RELRO",
             else => if (elf.PT_LOOS <= ph_type and ph_type < elf.PT_HIOS) {
-                return try w.print("LOOS+0x{x}", .{ph_type - elf.PT_LOOS});
+                return try writer.print("LOOS+0x{x}", .{ph_type - elf.PT_LOOS});
             } else if (elf.PT_LOPROC <= ph_type and ph_type < elf.PT_HIPROC) {
-                return try w.print("LOPROC+0x{x}", .{ph_type - elf.PT_LOPROC});
+                return try writer.print("LOPROC+0x{x}", .{ph_type - elf.PT_LOPROC});
             } else "UNKNOWN",
         };
-        try w.writeAll(p_type);
+        try writer.writeAll(p_type);
     }
 };
 
@@ -2327,38 +2387,49 @@ const WasmDumper = struct {
 
     fn parseAndDump(step: *Step, check: Check, bytes: []const u8) ![]const u8 {
         const gpa = step.owner.allocator;
-        var r: std.io.Reader = .fixed(bytes);
-
-        const buf = try r.takeArray(8);
-        if (!mem.eql(u8, buf[0..4], &std.wasm.magic)) return error.InvalidMagicByte;
-        if (!mem.eql(u8, buf[4..8], &std.wasm.version)) return error.UnsupportedWasmVersion;
+        var fbs = std.io.fixedBufferStream(bytes);
+        const reader = fbs.reader();
 
-        var aw: std.io.Writer.Allocating = .init(gpa);
-        defer aw.deinit();
-        const bw = &aw.writer;
+        const buf = try reader.readBytesNoEof(8);
+        if (!mem.eql(u8, buf[0..4], &std.wasm.magic)) {
+            return error.InvalidMagicByte;
+        }
+        if (!mem.eql(u8, buf[4..], &std.wasm.version)) {
+            return error.UnsupportedWasmVersion;
+        }
 
-        parseAndDumpInner(step, check, &r, bw) catch |err| switch (err) {
-            error.EndOfStream => try bw.writeAll("\n<UnexpectedEndOfStream>"),
+        var output = std.ArrayList(u8).init(gpa);
+        defer output.deinit();
+        parseAndDumpInner(step, check, bytes, &fbs, &output) catch |err| switch (err) {
+            error.EndOfStream => try output.appendSlice("\n<UnexpectedEndOfStream>"),
             else => |e| return e,
         };
-        return aw.toOwnedSlice();
+        return output.toOwnedSlice();
     }
 
     fn parseAndDumpInner(
         step: *Step,
         check: Check,
-        r: *std.io.Reader,
-        bw: *Writer,
+        bytes: []const u8,
+        fbs: *std.io.FixedBufferStream([]const u8),
+        output: *std.ArrayList(u8),
     ) !void {
+        const reader = fbs.reader();
+        const writer = output.writer();
+
         switch (check.kind) {
-            .headers => while (r.takeEnum(std.wasm.Section, .little)) |section| {
-                var section_reader: std.io.Reader = .fixed(try r.take(try r.takeLeb128(u32)));
-                try parseAndDumpSection(step, section, &section_reader, bw);
-            } else |err| switch (err) {
-                error.InvalidEnumTag => return step.fail("invalid section id", .{}),
-                error.EndOfStream => {},
-                else => |e| return e,
+            .headers => {
+                while (reader.readByte()) |current_byte| {
+                    const section = std.enums.fromInt(std.wasm.Section, current_byte) orelse {
+                        return step.fail("Found invalid section id '{d}'", .{current_byte});
+                    };
+
+                    const section_length = try std.leb.readUleb128(u32, reader);
+                    try parseAndDumpSection(step, section, bytes[fbs.pos..][0..section_length], writer);
+                    fbs.pos += section_length;
+                } else |_| {} // reached end of stream
             },
+
             else => return step.fail("invalid check kind for Wasm file format: {s}", .{@tagName(check.kind)}),
         }
     }
@@ -2366,13 +2437,16 @@ const WasmDumper = struct {
     fn parseAndDumpSection(
         step: *Step,
         section: std.wasm.Section,
-        r: *std.io.Reader,
-        bw: *Writer,
+        data: []const u8,
+        writer: anytype,
     ) !void {
-        try bw.print(
+        var fbs = std.io.fixedBufferStream(data);
+        const reader = fbs.reader();
+
+        try writer.print(
             \\Section {s}
             \\size {d}
-        , .{ @tagName(section), r.buffer.len });
+        , .{ @tagName(section), data.len });
 
         switch (section) {
             .type,
@@ -2386,83 +2460,96 @@ const WasmDumper = struct {
             .code,
             .data,
             => {
-                const entries = try r.takeLeb128(u32);
-                try bw.print("\nentries {d}\n", .{entries});
-                try parseSection(step, section, r, entries, bw);
+                const entries = try std.leb.readUleb128(u32, reader);
+                try writer.print("\nentries {d}\n", .{entries});
+                try parseSection(step, section, data[fbs.pos..], entries, writer);
             },
             .custom => {
-                const name = try r.take(try r.takeLeb128(u32));
-                try bw.print("\nname {s}\n", .{name});
+                const name_length = try std.leb.readUleb128(u32, reader);
+                const name = data[fbs.pos..][0..name_length];
+                fbs.pos += name_length;
+                try writer.print("\nname {s}\n", .{name});
 
                 if (mem.eql(u8, name, "name")) {
-                    try parseDumpNames(step, r, bw);
+                    try parseDumpNames(step, reader, writer, data);
                 } else if (mem.eql(u8, name, "producers")) {
-                    try parseDumpProducers(r, bw);
+                    try parseDumpProducers(reader, writer, data);
                 } else if (mem.eql(u8, name, "target_features")) {
-                    try parseDumpFeatures(r, bw);
+                    try parseDumpFeatures(reader, writer, data);
                 }
                 // TODO: Implement parsing and dumping other custom sections (such as relocations)
             },
             .start => {
-                const start = try r.takeLeb128(u32);
-                try bw.print("\nstart {d}\n", .{start});
+                const start = try std.leb.readUleb128(u32, reader);
+                try writer.print("\nstart {d}\n", .{start});
             },
             .data_count => {
-                const count = try r.takeLeb128(u32);
-                try bw.print("\ncount {d}\n", .{count});
+                const count = try std.leb.readUleb128(u32, reader);
+                try writer.print("\ncount {d}\n", .{count});
             },
             else => {}, // skip unknown sections
         }
     }
 
-    fn parseSection(step: *Step, section: std.wasm.Section, r: *std.io.Reader, entries: u32, bw: *Writer) !void {
+    fn parseSection(step: *Step, section: std.wasm.Section, data: []const u8, entries: u32, writer: anytype) !void {
+        var fbs = std.io.fixedBufferStream(data);
+        const reader = fbs.reader();
+
         switch (section) {
             .type => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    const func_type = try r.takeByte();
+                    const func_type = try reader.readByte();
                     if (func_type != std.wasm.function_type) {
                         return step.fail("expected function type, found byte '{d}'", .{func_type});
                     }
-                    const params = try r.takeLeb128(u32);
-                    try bw.print("params {d}\n", .{params});
+                    const params = try std.leb.readUleb128(u32, reader);
+                    try writer.print("params {d}\n", .{params});
                     var index: u32 = 0;
                     while (index < params) : (index += 1) {
-                        _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
+                        _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
                     } else index = 0;
-                    const returns = try r.takeLeb128(u32);
-                    try bw.print("returns {d}\n", .{returns});
+                    const returns = try std.leb.readUleb128(u32, reader);
+                    try writer.print("returns {d}\n", .{returns});
                     while (index < returns) : (index += 1) {
-                        _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
+                        _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
                     }
                 }
             },
             .import => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    const module_name = try r.take(try r.takeLeb128(u32));
-                    const name = try r.take(try r.takeLeb128(u32));
-                    const kind = r.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
-                        error.InvalidEnumTag => return step.fail("invalid import kind", .{}),
-                        else => |e| return e,
+                    const module_name_len = try std.leb.readUleb128(u32, reader);
+                    const module_name = data[fbs.pos..][0..module_name_len];
+                    fbs.pos += module_name_len;
+                    const name_len = try std.leb.readUleb128(u32, reader);
+                    const name = data[fbs.pos..][0..name_len];
+                    fbs.pos += name_len;
+
+                    const kind = std.enums.fromInt(std.wasm.ExternalKind, try reader.readByte()) orelse {
+                        return step.fail("invalid import kind", .{});
                     };
 
-                    try bw.print(
+                    try writer.print(
                         \\module {s}
                         \\name {s}
                         \\kind {s}
                     , .{ module_name, name, @tagName(kind) });
-                    try bw.writeByte('\n');
+                    try writer.writeByte('\n');
                     switch (kind) {
-                        .function => try bw.print("index {d}\n", .{try r.takeLeb128(u32)}),
-                        .memory => try parseDumpLimits(r, bw),
+                        .function => {
+                            try writer.print("index {d}\n", .{try std.leb.readUleb128(u32, reader)});
+                        },
+                        .memory => {
+                            try parseDumpLimits(reader, writer);
+                        },
                         .global => {
-                            _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
-                            try bw.print("mutable {}\n", .{0x01 == try r.takeLeb128(u32)});
+                            _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
+                            try writer.print("mutable {}\n", .{0x01 == try std.leb.readUleb128(u32, reader)});
                         },
                         .table => {
-                            _ = try parseDumpType(step, std.wasm.RefType, r, bw);
-                            try parseDumpLimits(r, bw);
+                            _ = try parseDumpType(step, std.wasm.RefType, reader, writer);
+                            try parseDumpLimits(reader, writer);
                         },
                     }
                 }
@@ -2470,58 +2557,60 @@ const WasmDumper = struct {
             .function => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    try bw.print("index {d}\n", .{try r.takeLeb128(u32)});
+                    try writer.print("index {d}\n", .{try std.leb.readUleb128(u32, reader)});
                 }
             },
             .table => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    _ = try parseDumpType(step, std.wasm.RefType, r, bw);
-                    try parseDumpLimits(r, bw);
+                    _ = try parseDumpType(step, std.wasm.RefType, reader, writer);
+                    try parseDumpLimits(reader, writer);
                 }
             },
             .memory => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    try parseDumpLimits(r, bw);
+                    try parseDumpLimits(reader, writer);
                 }
             },
             .global => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    _ = try parseDumpType(step, std.wasm.Valtype, r, bw);
-                    try bw.print("mutable {}\n", .{0x01 == try r.takeLeb128(u1)});
-                    try parseDumpInit(step, r, bw);
+                    _ = try parseDumpType(step, std.wasm.Valtype, reader, writer);
+                    try writer.print("mutable {}\n", .{0x01 == try std.leb.readUleb128(u1, reader)});
+                    try parseDumpInit(step, reader, writer);
                 }
             },
             .@"export" => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    const name = try r.take(try r.takeLeb128(u32));
-                    const kind = r.takeEnum(std.wasm.ExternalKind, .little) catch |err| switch (err) {
-                        error.InvalidEnumTag => return step.fail("invalid export kind value", .{}),
-                        else => |e| return e,
+                    const name_len = try std.leb.readUleb128(u32, reader);
+                    const name = data[fbs.pos..][0..name_len];
+                    fbs.pos += name_len;
+                    const kind_byte = try std.leb.readUleb128(u8, reader);
+                    const kind = std.enums.fromInt(std.wasm.ExternalKind, kind_byte) orelse {
+                        return step.fail("invalid export kind value '{d}'", .{kind_byte});
                     };
-                    const index = try r.takeLeb128(u32);
-                    try bw.print(
+                    const index = try std.leb.readUleb128(u32, reader);
+                    try writer.print(
                         \\name {s}
                         \\kind {s}
                         \\index {d}
                     , .{ name, @tagName(kind), index });
-                    try bw.writeByte('\n');
+                    try writer.writeByte('\n');
                 }
             },
             .element => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    try bw.print("table index {d}\n", .{try r.takeLeb128(u32)});
-                    try parseDumpInit(step, r, bw);
+                    try writer.print("table index {d}\n", .{try std.leb.readUleb128(u32, reader)});
+                    try parseDumpInit(step, reader, writer);
 
-                    const function_indexes = try r.takeLeb128(u32);
+                    const function_indexes = try std.leb.readUleb128(u32, reader);
                     var function_index: u32 = 0;
-                    try bw.print("indexes {d}\n", .{function_indexes});
+                    try writer.print("indexes {d}\n", .{function_indexes});
                     while (function_index < function_indexes) : (function_index += 1) {
-                        try bw.print("index {d}\n", .{try r.takeLeb128(u32)});
+                        try writer.print("index {d}\n", .{try std.leb.readUleb128(u32, reader)});
                     }
                 }
             },
@@ -2529,95 +2618,101 @@ const WasmDumper = struct {
             .data => {
                 var i: u32 = 0;
                 while (i < entries) : (i += 1) {
-                    const flags: packed struct(u32) {
-                        passive: bool,
-                        memidx: bool,
-                        unused: u30,
-                    } = @bitCast(try r.takeLeb128(u32));
-                    const index = if (flags.memidx) try r.takeLeb128(u32) else 0;
-                    try bw.print("memory index 0x{x}\n", .{index});
-                    if (!flags.passive) try parseDumpInit(step, r, bw);
-                    const size = try r.takeLeb128(u32);
-                    try bw.print("size {d}\n", .{size});
-                    _ = try r.discard(.limited(size)); // we do not care about the content of the segments
+                    const flags = try std.leb.readUleb128(u32, reader);
+                    const index = if (flags & 0x02 != 0)
+                        try std.leb.readUleb128(u32, reader)
+                    else
+                        0;
+                    try writer.print("memory index 0x{x}\n", .{index});
+                    if (flags == 0) {
+                        try parseDumpInit(step, reader, writer);
+                    }
+
+                    const size = try std.leb.readUleb128(u32, reader);
+                    try writer.print("size {d}\n", .{size});
+                    try reader.skipBytes(size, .{}); // we do not care about the content of the segments
                 }
             },
             else => unreachable,
         }
     }
 
-    fn parseDumpType(step: *Step, comptime E: type, r: *std.io.Reader, bw: *Writer) !E {
-        const tag = r.takeEnum(E, .little) catch |err| switch (err) {
-            error.InvalidEnumTag => return step.fail("invalid wasm type value", .{}),
-            else => |e| return e,
+    fn parseDumpType(step: *Step, comptime E: type, reader: anytype, writer: anytype) !E {
+        const byte = try reader.readByte();
+        const tag = std.enums.fromInt(E, byte) orelse {
+            return step.fail("invalid wasm type value '{d}'", .{byte});
         };
-        try bw.print("type {s}\n", .{@tagName(tag)});
+        try writer.print("type {s}\n", .{@tagName(tag)});
         return tag;
     }
 
-    fn parseDumpLimits(r: *std.io.Reader, bw: *Writer) !void {
-        const flags = try r.takeLeb128(u8);
-        const min = try r.takeLeb128(u32);
+    fn parseDumpLimits(reader: anytype, writer: anytype) !void {
+        const flags = try std.leb.readUleb128(u8, reader);
+        const min = try std.leb.readUleb128(u32, reader);
 
-        try bw.print("min {x}\n", .{min});
-        if (flags != 0) try bw.print("max {x}\n", .{try r.takeLeb128(u32)});
+        try writer.print("min {x}\n", .{min});
+        if (flags != 0) {
+            try writer.print("max {x}\n", .{try std.leb.readUleb128(u32, reader)});
+        }
     }
 
-    fn parseDumpInit(step: *Step, r: *std.io.Reader, bw: *Writer) !void {
-        const opcode = r.takeEnum(std.wasm.Opcode, .little) catch |err| switch (err) {
-            error.InvalidEnumTag => return step.fail("invalid wasm opcode", .{}),
-            else => |e| return e,
+    fn parseDumpInit(step: *Step, reader: anytype, writer: anytype) !void {
+        const byte = try reader.readByte();
+        const opcode = std.enums.fromInt(std.wasm.Opcode, byte) orelse {
+            return step.fail("invalid wasm opcode '{d}'", .{byte});
         };
         switch (opcode) {
-            .i32_const => try bw.print("i32.const {x}\n", .{try r.takeLeb128(i32)}),
-            .i64_const => try bw.print("i64.const {x}\n", .{try r.takeLeb128(i64)}),
-            .f32_const => try bw.print("f32.const {x}\n", .{@as(f32, @bitCast(try r.takeInt(u32, .little)))}),
-            .f64_const => try bw.print("f64.const {x}\n", .{@as(f64, @bitCast(try r.takeInt(u64, .little)))}),
-            .global_get => try bw.print("global.get {x}\n", .{try r.takeLeb128(u32)}),
+            .i32_const => try writer.print("i32.const {x}\n", .{try std.leb.readIleb128(i32, reader)}),
+            .i64_const => try writer.print("i64.const {x}\n", .{try std.leb.readIleb128(i64, reader)}),
+            .f32_const => try writer.print("f32.const {x}\n", .{@as(f32, @bitCast(try reader.readInt(u32, .little)))}),
+            .f64_const => try writer.print("f64.const {x}\n", .{@as(f64, @bitCast(try reader.readInt(u64, .little)))}),
+            .global_get => try writer.print("global.get {x}\n", .{try std.leb.readUleb128(u32, reader)}),
             else => unreachable,
         }
-        const end_opcode = try r.takeLeb128(u8);
+        const end_opcode = try std.leb.readUleb128(u8, reader);
         if (end_opcode != @intFromEnum(std.wasm.Opcode.end)) {
             return step.fail("expected 'end' opcode in init expression", .{});
         }
     }
 
     /// https://webassembly.github.io/spec/core/appendix/custom.html
-    fn parseDumpNames(step: *Step, r: *std.io.Reader, bw: *Writer) !void {
-        var subsection_br: std.io.Reader = undefined;
-        while (r.seek < r.buffer.len) {
-            switch (try parseDumpType(step, std.wasm.NameSubsection, r, bw)) {
+    fn parseDumpNames(step: *Step, reader: anytype, writer: anytype, data: []const u8) !void {
+        while (reader.context.pos < data.len) {
+            switch (try parseDumpType(step, std.wasm.NameSubsection, reader, writer)) {
                 // The module name subsection ... consists of a single name
                 // that is assigned to the module itself.
                 .module => {
-                    subsection_br = .fixed(try r.take(try r.takeLeb128(u32)));
-                    const name = try subsection_br.take(try subsection_br.takeLeb128(u32));
-                    try bw.print(
-                        \\name {s}
-                        \\
-                    , .{name});
-                    if (subsection_br.seek != subsection_br.buffer.len) return error.BadSubsectionSize;
+                    const size = try std.leb.readUleb128(u32, reader);
+                    const name_len = try std.leb.readUleb128(u32, reader);
+                    if (size != name_len + 1) return error.BadSubsectionSize;
+                    if (reader.context.pos + name_len > data.len) return error.UnexpectedEndOfStream;
+                    try writer.print("name {s}\n", .{data[reader.context.pos..][0..name_len]});
+                    reader.context.pos += name_len;
                 },
 
                 // The function name subsection ... consists of a name map
                 // assigning function names to function indices.
                 .function, .global, .data_segment => {
-                    subsection_br = .fixed(try r.take(try r.takeLeb128(u32)));
-                    const entries = try r.takeLeb128(u32);
-                    try bw.print(
+                    const size = try std.leb.readUleb128(u32, reader);
+                    const entries = try std.leb.readUleb128(u32, reader);
+                    try writer.print(
+                        \\size {d}
                         \\names {d}
                         \\
-                    , .{entries});
+                    , .{ size, entries });
                     for (0..entries) |_| {
-                        const index = try r.takeLeb128(u32);
-                        const name = try r.take(try r.takeLeb128(u32));
-                        try bw.print(
+                        const index = try std.leb.readUleb128(u32, reader);
+                        const name_len = try std.leb.readUleb128(u32, reader);
+                        if (reader.context.pos + name_len > data.len) return error.UnexpectedEndOfStream;
+                        const name = data[reader.context.pos..][0..name_len];
+                        reader.context.pos += name.len;
+
+                        try writer.print(
                             \\index {d}
                             \\name {s}
                             \\
                         , .{ index, name });
                     }
-                    if (subsection_br.seek != subsection_br.buffer.len) return error.BadSubsectionSize;
                 },
 
                 // The local name subsection ... consists of an indirect name
@@ -2632,49 +2727,52 @@ const WasmDumper = struct {
         }
     }
 
-    fn parseDumpProducers(r: *std.io.Reader, bw: *Writer) !void {
-        const field_count = try r.takeLeb128(u32);
-        try bw.print(
-            \\fields {d}
-            \\
-        , .{field_count});
+    fn parseDumpProducers(reader: anytype, writer: anytype, data: []const u8) !void {
+        const field_count = try std.leb.readUleb128(u32, reader);
+        try writer.print("fields {d}\n", .{field_count});
         var current_field: u32 = 0;
         while (current_field < field_count) : (current_field += 1) {
-            const field_name = try r.take(try r.takeLeb128(u32));
-            const value_count = try r.takeLeb128(u32);
-            try bw.print(
+            const field_name_length = try std.leb.readUleb128(u32, reader);
+            const field_name = data[reader.context.pos..][0..field_name_length];
+            reader.context.pos += field_name_length;
+
+            const value_count = try std.leb.readUleb128(u32, reader);
+            try writer.print(
                 \\field_name {s}
                 \\values {d}
-                \\
             , .{ field_name, value_count });
+            try writer.writeByte('\n');
             var current_value: u32 = 0;
             while (current_value < value_count) : (current_value += 1) {
-                const value = try r.take(try r.takeLeb128(u32));
-                const version = try r.take(try r.takeLeb128(u32));
-                try bw.print(
+                const value_length = try std.leb.readUleb128(u32, reader);
+                const value = data[reader.context.pos..][0..value_length];
+                reader.context.pos += value_length;
+
+                const version_length = try std.leb.readUleb128(u32, reader);
+                const version = data[reader.context.pos..][0..version_length];
+                reader.context.pos += version_length;
+
+                try writer.print(
                     \\value_name {s}
                     \\version {s}
-                    \\
                 , .{ value, version });
+                try writer.writeByte('\n');
             }
         }
     }
 
-    fn parseDumpFeatures(r: *std.io.Reader, bw: *Writer) !void {
-        const feature_count = try r.takeLeb128(u32);
-        try bw.print(
-            \\features {d}
-            \\
-        , .{feature_count});
+    fn parseDumpFeatures(reader: anytype, writer: anytype, data: []const u8) !void {
+        const feature_count = try std.leb.readUleb128(u32, reader);
+        try writer.print("features {d}\n", .{feature_count});
 
         var index: u32 = 0;
         while (index < feature_count) : (index += 1) {
-            const prefix_byte = try r.takeLeb128(u8);
-            const feature_name = try r.take(try r.takeLeb128(u32));
-            try bw.print(
-                \\{c} {s}
-                \\
-            , .{ prefix_byte, feature_name });
+            const prefix_byte = try std.leb.readUleb128(u8, reader);
+            const name_length = try std.leb.readUleb128(u32, reader);
+            const feature_name = data[reader.context.pos..][0..name_length];
+            reader.context.pos += name_length;
+
+            try writer.print("{c} {s}\n", .{ prefix_byte, feature_name });
         }
     }
 };