@zigc/lib 0.16.0-test.1 → 0.16.0

package/compiler/aro/backend/Ir.zig

@@ -374,24 +374,27 @@ pub fn deinit(ir: *Ir, gpa: std.mem.Allocator) void {
     ir.* = undefined;
 }
 
-const TYPE = std.Io.tty.Color.bright_magenta;
-const INST = std.Io.tty.Color.bright_cyan;
-const REF = std.Io.tty.Color.bright_blue;
-const LITERAL = std.Io.tty.Color.bright_green;
-const ATTRIBUTE = std.Io.tty.Color.bright_yellow;
+const TYPE = std.Io.Terminal.Color.bright_magenta;
+const INST = std.Io.Terminal.Color.bright_cyan;
+const REF = std.Io.Terminal.Color.bright_blue;
+const LITERAL = std.Io.Terminal.Color.bright_green;
+const ATTRIBUTE = std.Io.Terminal.Color.bright_yellow;
 
 const RefMap = std.AutoArrayHashMapUnmanaged(Ref, void);
 
-pub fn dump(ir: *const Ir, gpa: Allocator, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+pub const DumpError = std.Io.Terminal.SetColorError || std.mem.Allocator.Error;
+
+pub fn dump(ir: *const Ir, gpa: Allocator, term: std.Io.Terminal) DumpError!void {
     for (ir.decls.keys(), ir.decls.values()) |name, *decl| {
-        try ir.dumpDecl(decl, gpa, name, config, w);
+        try ir.dumpDecl(decl, gpa, name, term);
     }
-    try w.flush();
+    try term.writer.flush();
 }
 
-fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, term: std.Io.Terminal) !void {
     const tags = decl.instructions.items(.tag);
     const data = decl.instructions.items(.data);
+    const w = term.writer;
 
     var ref_map: RefMap = .empty;
     defer ref_map.deinit(gpa);
@@ -402,10 +405,10 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
     const ret_inst = decl.body.items[decl.body.items.len - 1];
     const ret_operand = data[@intFromEnum(ret_inst)].un;
     const ret_ty = decl.instructions.items(.ty)[@intFromEnum(ret_operand)];
-    try ir.writeType(ret_ty, config, w);
-    try config.setColor(w, REF);
+    try ir.writeType(ret_ty, term);
+    try term.setColor(REF);
     try w.print(" @{s}", .{name});
-    try config.setColor(w, .reset);
+    try term.setColor(.reset);
     try w.writeAll("(");
 
     var arg_count: u32 = 0;
@@ -414,8 +417,8 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
         if (tags[@intFromEnum(ref)] != .arg) break;
         if (arg_count != 0) try w.writeAll(", ");
         try ref_map.put(gpa, ref, {});
-        try ir.writeRef(decl, &ref_map, ref, config, w);
-        try config.setColor(w, .reset);
+        try ir.writeRef(decl, &ref_map, ref, term);
+        try term.setColor(.reset);
     }
     try w.writeAll(") {\n");
     for (decl.body.items[arg_count..]) |ref| {
@@ -432,7 +435,7 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             .arg, .constant, .symbol => unreachable,
             .label => {
                 const label_index = label_map.getIndex(ref).?;
-                try config.setColor(w, REF);
+                try term.setColor(REF);
                 try w.print("{s}.{d}:\n", .{ data[i].label, label_index });
             },
             // .label_val => {
@@ -441,35 +444,35 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             // },
             .jmp => {
                 const un = data[i].un;
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    jmp ");
-                try writeLabel(decl, &label_map, un, config, w);
+                try writeLabel(decl, &label_map, un, term);
                 try w.writeByte('\n');
             },
             .branch => {
                 const br = data[i].branch;
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    branch ");
-                try ir.writeRef(decl, &ref_map, br.cond, config, w);
-                try config.setColor(w, .reset);
+                try ir.writeRef(decl, &ref_map, br.cond, term);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try writeLabel(decl, &label_map, br.then, config, w);
-                try config.setColor(w, .reset);
+                try writeLabel(decl, &label_map, br.then, term);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try writeLabel(decl, &label_map, br.@"else", config, w);
+                try writeLabel(decl, &label_map, br.@"else", term);
                 try w.writeByte('\n');
             },
             .select => {
                 const br = data[i].branch;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("select ");
-                try ir.writeRef(decl, &ref_map, br.cond, config, w);
-                try config.setColor(w, .reset);
+                try ir.writeRef(decl, &ref_map, br.cond, term);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, br.then, config, w);
-                try config.setColor(w, .reset);
+                try ir.writeRef(decl, &ref_map, br.then, term);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, br.@"else", config, w);
+                try ir.writeRef(decl, &ref_map, br.@"else", term);
                 try w.writeByte('\n');
             },
             // .jmp_val => {
@@ -478,91 +481,91 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             // },
             .@"switch" => {
                 const @"switch" = data[i].@"switch";
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    switch ");
-                try ir.writeRef(decl, &ref_map, @"switch".target, config, w);
-                try config.setColor(w, .reset);
+                try ir.writeRef(decl, &ref_map, @"switch".target, term);
+                try term.setColor(.reset);
                 try w.writeAll(" {");
                 for (@"switch".case_vals[0..@"switch".cases_len], @"switch".case_labels) |val_ref, label_ref| {
                     try w.writeAll("\n        ");
-                    try ir.writeValue(val_ref, config, w);
-                    try config.setColor(w, .reset);
+                    try ir.writeValue(val_ref, term);
+                    try term.setColor(.reset);
                     try w.writeAll(" => ");
-                    try writeLabel(decl, &label_map, label_ref, config, w);
-                    try config.setColor(w, .reset);
+                    try writeLabel(decl, &label_map, label_ref, term);
+                    try term.setColor(.reset);
                 }
-                try config.setColor(w, LITERAL);
+                try term.setColor(LITERAL);
                 try w.writeAll("\n        default ");
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll("=> ");
-                try writeLabel(decl, &label_map, @"switch".default, config, w);
-                try config.setColor(w, .reset);
+                try writeLabel(decl, &label_map, @"switch".default, term);
+                try term.setColor(.reset);
                 try w.writeAll("\n    }\n");
             },
             .call => {
                 const call = data[i].call;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("call ");
-                try ir.writeRef(decl, &ref_map, call.func, config, w);
-                try config.setColor(w, .reset);
+                try ir.writeRef(decl, &ref_map, call.func, term);
+                try term.setColor(.reset);
                 try w.writeAll("(");
                 for (call.args(), 0..) |arg, arg_i| {
                     if (arg_i != 0) try w.writeAll(", ");
-                    try ir.writeRef(decl, &ref_map, arg, config, w);
-                    try config.setColor(w, .reset);
+                    try ir.writeRef(decl, &ref_map, arg, term);
+                    try term.setColor(.reset);
                 }
                 try w.writeAll(")\n");
             },
             .alloc => {
                 const alloc = data[i].alloc;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("alloc ");
-                try config.setColor(w, ATTRIBUTE);
+                try term.setColor(ATTRIBUTE);
                 try w.writeAll("size ");
-                try config.setColor(w, LITERAL);
+                try term.setColor(LITERAL);
                 try w.print("{d}", .{alloc.size});
-                try config.setColor(w, ATTRIBUTE);
+                try term.setColor(ATTRIBUTE);
                 try w.writeAll(" align ");
-                try config.setColor(w, LITERAL);
+                try term.setColor(LITERAL);
                 try w.print("{d}", .{alloc.@"align"});
                 try w.writeByte('\n');
             },
             .phi => {
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("phi");
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll(" {");
                 for (data[i].phi.inputs()) |input| {
                     try w.writeAll("\n        ");
-                    try writeLabel(decl, &label_map, input.label, config, w);
-                    try config.setColor(w, .reset);
+                    try writeLabel(decl, &label_map, input.label, term);
+                    try term.setColor(.reset);
                     try w.writeAll(" => ");
-                    try ir.writeRef(decl, &ref_map, input.value, config, w);
-                    try config.setColor(w, .reset);
+                    try ir.writeRef(decl, &ref_map, input.value, term);
+                    try term.setColor(.reset);
                 }
-                try config.setColor(w, .reset);
+                try term.setColor(.reset);
                 try w.writeAll("\n    }\n");
             },
             .store => {
                 const bin = data[i].bin;
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    store ");
-                try ir.writeRef(decl, &ref_map, bin.lhs, config, w);
-                try config.setColor(w, .reset);
+                try ir.writeRef(decl, &ref_map, bin.lhs, term);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, bin.rhs, config, w);
+                try ir.writeRef(decl, &ref_map, bin.rhs, term);
                 try w.writeByte('\n');
             },
             .ret => {
-                try config.setColor(w, INST);
+                try term.setColor(INST);
                 try w.writeAll("    ret ");
-                if (data[i].un != .none) try ir.writeRef(decl, &ref_map, data[i].un, config, w);
+                if (data[i].un != .none) try ir.writeRef(decl, &ref_map, data[i].un, term);
                 try w.writeByte('\n');
             },
             .load => {
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.writeAll("load ");
-                try ir.writeRef(decl, &ref_map, data[i].un, config, w);
+                try ir.writeRef(decl, &ref_map, data[i].un, term);
                 try w.writeByte('\n');
             },
             .bit_or,
@@ -583,12 +586,12 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             .mod,
             => {
                 const bin = data[i].bin;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.print("{s} ", .{@tagName(tag)});
-                try ir.writeRef(decl, &ref_map, bin.lhs, config, w);
-                try config.setColor(w, .reset);
+                try ir.writeRef(decl, &ref_map, bin.lhs, term);
+                try term.setColor(.reset);
                 try w.writeAll(", ");
-                try ir.writeRef(decl, &ref_map, bin.rhs, config, w);
+                try ir.writeRef(decl, &ref_map, bin.rhs, term);
                 try w.writeByte('\n');
             },
             .bit_not,
@@ -598,33 +601,34 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8,
             .sext,
             => {
                 const un = data[i].un;
-                try ir.writeNewRef(gpa, decl, &ref_map, ref, config, w);
+                try ir.writeNewRef(gpa, decl, &ref_map, ref, term);
                 try w.print("{s} ", .{@tagName(tag)});
-                try ir.writeRef(decl, &ref_map, un, config, w);
+                try ir.writeRef(decl, &ref_map, un, term);
                 try w.writeByte('\n');
             },
             .label_addr, .jmp_val => {},
         }
     }
-    try config.setColor(w, .reset);
+    try term.setColor(.reset);
     try w.writeAll("}\n\n");
 }
 
-fn writeType(ir: Ir, ty_ref: Interner.Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeType(ir: Ir, ty_ref: Interner.Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     const ty = ir.interner.get(ty_ref);
-    try config.setColor(w, TYPE);
+    try term.setColor(TYPE);
     switch (ty) {
         .ptr_ty, .noreturn_ty, .void_ty, .func_ty => try w.writeAll(@tagName(ty)),
         .int_ty => |bits| try w.print("i{d}", .{bits}),
         .float_ty => |bits| try w.print("f{d}", .{bits}),
         .array_ty => |info| {
             try w.print("[{d} * ", .{info.len});
-            try ir.writeType(info.child, .no_color, w);
+            try ir.writeType(info.child, .{ .mode = .no_color, .writer = w });
             try w.writeByte(']');
         },
         .vector_ty => |info| {
             try w.print("<{d} * ", .{info.len});
-            try ir.writeType(info.child, .no_color, w);
+            try ir.writeType(info.child, .{ .mode = .no_color, .writer = w });
             try w.writeByte('>');
         },
         .record_ty => |elems| {
@@ -632,7 +636,7 @@ fn writeType(ir: Ir, ty_ref: Interner.Ref, config: std.Io.tty.Config, w: *std.Io
             try w.writeAll("{ ");
             for (elems, 0..) |elem, i| {
                 if (i != 0) try w.writeAll(", ");
-                try ir.writeType(elem, config, w);
+                try ir.writeType(elem, .{ .mode = .no_color, .writer = w });
             }
             try w.writeAll(" }");
         },
@@ -640,8 +644,9 @@ fn writeType(ir: Ir, ty_ref: Interner.Ref, config: std.Io.tty.Config, w: *std.Io
     }
 }
 
-fn writeValue(ir: Ir, val: Interner.Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
-    try config.setColor(w, LITERAL);
+fn writeValue(ir: Ir, val: Interner.Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
+    try term.setColor(LITERAL);
     const key = ir.interner.get(val);
     switch (key) {
         .null => return w.writeAll("nullptr_t"),
@@ -656,43 +661,46 @@ fn writeValue(ir: Ir, val: Interner.Ref, config: std.Io.tty.Config, w: *std.Io.W
     }
 }
 
-fn writeRef(ir: Ir, decl: *const Decl, ref_map: *RefMap, ref: Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeRef(ir: Ir, decl: *const Decl, ref_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     assert(ref != .none);
     const index = @intFromEnum(ref);
     const ty_ref = decl.instructions.items(.ty)[index];
     if (decl.instructions.items(.tag)[index] == .constant) {
-        try ir.writeType(ty_ref, config, w);
+        try ir.writeType(ty_ref, term);
         const v_ref = decl.instructions.items(.data)[index].constant;
         try w.writeByte(' ');
-        try ir.writeValue(v_ref, config, w);
+        try ir.writeValue(v_ref, term);
         return;
     } else if (decl.instructions.items(.tag)[index] == .symbol) {
         const name = decl.instructions.items(.data)[index].label;
-        try ir.writeType(ty_ref, config, w);
-        try config.setColor(w, REF);
+        try ir.writeType(ty_ref, term);
+        try term.setColor(REF);
         try w.print(" @{s}", .{name});
         return;
     }
-    try ir.writeType(ty_ref, config, w);
-    try config.setColor(w, REF);
+    try ir.writeType(ty_ref, term);
+    try term.setColor(REF);
     const ref_index = ref_map.getIndex(ref).?;
     try w.print(" %{d}", .{ref_index});
 }
 
-fn writeNewRef(ir: Ir, gpa: Allocator, decl: *const Decl, ref_map: *RefMap, ref: Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeNewRef(ir: Ir, gpa: Allocator, decl: *const Decl, ref_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     try ref_map.put(gpa, ref, {});
     try w.writeAll("    ");
-    try ir.writeRef(decl, ref_map, ref, config, w);
-    try config.setColor(w, .reset);
+    try ir.writeRef(decl, ref_map, ref, term);
+    try term.setColor(.reset);
     try w.writeAll(" = ");
-    try config.setColor(w, INST);
+    try term.setColor(INST);
 }
 
-fn writeLabel(decl: *const Decl, label_map: *RefMap, ref: Ref, config: std.Io.tty.Config, w: *std.Io.Writer) !void {
+fn writeLabel(decl: *const Decl, label_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void {
+    const w = term.writer;
     assert(ref != .none);
     const index = @intFromEnum(ref);
     const label = decl.instructions.items(.data)[index].label;
-    try config.setColor(w, REF);
+    try term.setColor(REF);
     const label_index = label_map.getIndex(ref).?;
     try w.print("{s}.{d}", .{ label, label_index });
 }

package/compiler/aro/include/ptrcheck.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#if defined(__has_feature) && __has_feature(bounds_attributes)
+  #define __has_ptrcheck 1
+#else
+  #define __has_ptrcheck 0
+#endif
+
+#if __has_ptrcheck
+
+#define __single __attribute__((__single__))
+#define __unsafe_indexable __attribute__((__unsafe_indexable__))
+
+#else
+
+#define __single
+#define __unsafe_indexable
+#define __counted_by(N)
+#define __counted_by_or_null(N)
+#define __sized_by(N)
+#define __sized_by_or_null(N)
+#define __ended_by(E)
+
+#define __terminated_by(T)
+#define __null_terminated
+
+/* __ptrcheck_abi_assume_indexable and __ptrcheck_abi_assume_bidi_indexable intentionally not defined */
+#define __ptrcheck_abi_assume_single()
+#define __ptrcheck_abi_assume_unsafe_indexable()
+
+#define __unsafe_forge_bidi_indexable(T, P, S) ((T)(P))
+#define __unsafe_forge_single(T, P) ((T)(P))
+#define __unsafe_forge_terminated_by(T, P, E) ((T)(P))
+#define __unsafe_forge_null_terminated(T, P) ((T)(P))
+
+#define __terminated_by_to_indexable(P) (P)
+#define __unsafe_terminated_by_to_indexable(P) (P)
+#define __null_terminated_to_indexable(P) (P)
+#define __unsafe_null_terminated_to_indexable(P) (P)
+#define __unsafe_terminated_by_from_indexable(T, P, ...) (P)
+#define __unsafe_null_terminated_from_indexable(P, ...) (P)
+
+#define __array_decay_dicards_count_in_parameters
+
+#define __ptrcheck_unavailable
+#define __ptrcheck_unavailable_r(REPLACEMENT)
+
+
+#endif

package/compiler/aro/main.zig

@@ -1,8 +1,9 @@
 const std = @import("std");
-const Io = std.Io;
-const Allocator = mem.Allocator;
 const mem = std.mem;
 const process = std.process;
+const Allocator = mem.Allocator;
+const build_options = @import("build_options");
+
 const aro = @import("aro");
 const Compilation = aro.Compilation;
 const Diagnostics = aro.Diagnostics;
@@ -11,14 +12,15 @@ const Toolchain = aro.Toolchain;
 const assembly_backend = @import("assembly_backend");
 
 var debug_allocator: std.heap.DebugAllocator(.{
-    .stack_trace_frames = 0,
+    .stack_trace_frames = if (build_options.debug_allocations and std.debug.sys_can_stack_trace) 10 else 0,
+    .resize_stack_traces = build_options.debug_allocations,
     // A unique value so that when a default-constructed
-    // DebugAllocator is incorrectly passed to testing allocator, or
+    // GeneralPurposeAllocator is incorrectly passed to testing allocator, or
     // vice versa, panic occurs.
     .canary = @truncate(0xc647026dc6875134),
 }) = .{};
 
-pub fn main(init: std.process.Init.Minimal) u8 {
+pub fn main(init: process.Init.Minimal) u8 {
     const gpa = if (@import("builtin").link_libc)
         std.heap.c_allocator
     else
@@ -31,7 +33,10 @@ pub fn main(init: std.process.Init.Minimal) u8 {
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
 
-    var threaded: std.Io.Threaded = .init(gpa, .{});
+    var threaded: std.Io.Threaded = .init(gpa, .{
+        .argv0 = .init(init.args),
+        .environ = init.environ,
+    });
     defer threaded.deinit();
     const io = threaded.io();
 
@@ -43,7 +48,11 @@ pub fn main(init: std.process.Init.Minimal) u8 {
         return 1;
     };
 
-    const aro_name = process.executablePathAlloc(io, gpa) catch {
+    var environ_map = std.process.Environ.createMap(init.environ, gpa) catch |err|
+        std.process.fatal("failed to parse environment variables: {t}", .{err});
+    defer environ_map.deinit();
+
+    const aro_name = std.process.executableDirPathAlloc(io, gpa) catch {
         std.debug.print("unable to find Aro executable path\n", .{});
         if (fast_exit) process.exit(1);
         return 1;
@@ -51,15 +60,21 @@ pub fn main(init: std.process.Init.Minimal) u8 {
     defer gpa.free(aro_name);
 
     var stderr_buf: [1024]u8 = undefined;
-    var stderr = Io.File.stderr().writer(&stderr_buf);
+    var stderr = std.Io.File.stderr().writer(io, &stderr_buf);
     var diagnostics: Diagnostics = .{
         .output = .{ .to_writer = .{
-            .color = .detect(stderr.file),
+            .mode = std.Io.Terminal.Mode.detect(io, stderr.file, false, false) catch .no_color,
             .writer = &stderr.interface,
         } },
     };
 
-    var comp = Compilation.initDefault(gpa, arena, io, &diagnostics, Io.Dir.cwd()) catch |er| switch (er) {
+    var comp = Compilation.init(.{
+        .gpa = gpa,
+        .arena = arena,
+        .io = io,
+        .diagnostics = &diagnostics,
+        .environ_map = &environ_map,
+    }) catch |er| switch (er) {
         error.OutOfMemory => {
             std.debug.print("out of memory\n", .{});
             if (fast_exit) process.exit(1);
@@ -85,6 +100,7 @@ pub fn main(init: std.process.Init.Minimal) u8 {
             if (fast_exit) process.exit(1);
             return 1;
         },
+        error.Canceled => unreachable,
     };
     if (fast_exit) process.exit(@intFromBool(comp.diagnostics.errors != 0));
     return @intFromBool(diagnostics.errors != 0);

package/compiler/build_runner.zig

@@ -424,6 +424,7 @@ pub fn main(init: process.Init.Minimal) !void {
                     fatal("unable to parse jobs count '{s}': {t}", .{ text, err });
                 if (n < 1) fatal("number of jobs must be at least 1", .{});
                 threaded.setAsyncLimit(.limited(n));
+                graph.max_jobs = n;
             } else if (mem.eql(u8, arg, "--")) {
                 builder.args = argsRest(args, arg_idx);
                 break;

package/compiler/objdump.zig

@@ -0,0 +1,93 @@
+const std = @import("std");
+const Io = std.Io;
+const fatal = std.process.fatal;
+const mem = std.mem;
+const assert = std.debug.assert;
+
+var stdout_buffer: [4000]u8 = undefined;
+
+pub fn main(init: std.process.Init) !void {
+    const io = init.io;
+    const args = try init.minimal.args.toSlice(init.arena.allocator());
+
+    var opt_input_path: ?[]const u8 = null;
+    var i: usize = 1;
+    while (i < args.len) : (i += 1) {
+        const arg = args[i];
+        if (mem.startsWith(u8, arg, "-")) {
+            if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
+                return Io.File.stdout().writeStreamingAll(io, usage);
+            } else {
+                fatal("unrecognized argument: {s}", .{arg});
+            }
+        } else if (opt_input_path == null) {
+            opt_input_path = arg;
+        } else {
+            fatal("unexpected positional: {s}", .{arg});
+        }
+    }
+
+    const input_path = opt_input_path orelse fatal("missing input file path positional argument", .{});
+
+    var file = std.Io.Dir.cwd().openFile(io, input_path, .{}) catch |err|
+        fatal("failed to open {s}: {t}", .{ input_path, err });
+    defer file.close(io);
+
+    var buffer: [4000]u8 = undefined;
+    var file_reader = file.reader(io, &buffer);
+    var stdout_writer = std.Io.File.stdout().writerStreaming(io, &stdout_buffer);
+    dump(&file_reader.interface, &stdout_writer.interface) catch |err| switch (err) {
+        error.ReadFailed => return file_reader.err.?,
+        error.WriteFailed => return stdout_writer.err.?,
+        error.UnknownFile => fatal("unrecognized file: {s}", .{input_path}),
+        else => |e| return e,
+    };
+    try stdout_writer.flush();
+}
+
+fn dump(r: *Io.Reader, w: *Io.Writer) !void {
+    try r.fill(4);
+    elf: {
+        if (!mem.eql(u8, r.buffered()[0..4], std.elf.MAGIC)) break :elf;
+        return elf.dump(r, w);
+    }
+    macho: {
+        if (mem.readInt(u32, r.buffered()[0..4], .little) != std.macho.MH_MAGIC_64) break :macho;
+        return macho.dump(r, w);
+    }
+    wasm: {
+        comptime assert(std.wasm.magic.len == 4);
+        if (!mem.eql(u8, r.buffered()[0..4], &std.wasm.magic)) break :wasm;
+        return wasm.dump(r, w);
+    }
+    return error.UnknownFile;
+}
+
+const elf = struct {
+    fn dump(r: *Io.Reader, w: *Io.Writer) !void {
+        _ = r;
+        try w.writeAll("TODO dump elf file\n");
+    }
+};
+
+const macho = struct {
+    fn dump(r: *Io.Reader, w: *Io.Writer) !void {
+        _ = r;
+        try w.writeAll("TODO dump macho file\n");
+    }
+};
+
+const wasm = struct {
+    fn dump(r: *Io.Reader, w: *Io.Writer) !void {
+        _ = r;
+        try w.writeAll("TODO dump wasm file\n");
+    }
+};
+
+const usage =
+    \\Usage: zig objdump [options] file
+    \\
+    \\Options:
+    \\  -h, --help                              Print this help and exit
+    \\
+;

package/compiler/reduce.zig

@@ -291,7 +291,11 @@ fn termToInteresting(term: std.process.Child.Term) Interestingness {
             std.debug.print("interestingness check terminated with signal {t}\n", .{sig});
             return .boring;
         },
-        else => {
+        .stopped => |sig| {
+            std.debug.print("interestingness check stopped with signal {t}\n", .{sig});
+            return .boring;
+        },
+        .unknown => {
             std.debug.print("interestingness check aborted unexpectedly\n", .{});
             return .boring;
         },

package/compiler/resinator/compile.zig

@@ -2746,7 +2746,7 @@ pub const Compiler = struct {
         // 1. Any permutation that does not have PRELOAD in it just uses the
         //    default flags.
         const initial_flags = flags.*;
-        var flags_set = std.enums.EnumSet(rc.CommonResourceAttributes).initEmpty();
+        var flags_set = std.enums.EnumSet(rc.CommonResourceAttributes).empty;
         for (tokens) |token| {
             const attribute = rc.CommonResourceAttributes.map.get(token.slice(source)).?;
             flags_set.insert(attribute);
@@ -2769,7 +2769,7 @@ pub const Compiler = struct {
         // 3. If none of DISCARDABLE, SHARED, or PURE is specified, then PRELOAD
         //    implies `flags &= ~SHARED` and LOADONCALL implies `flags |= SHARED`
         const shared_set = comptime blk: {
-            var set = std.enums.EnumSet(rc.CommonResourceAttributes).initEmpty();
+            var set = std.enums.EnumSet(rc.CommonResourceAttributes).empty;
             set.insert(.discardable);
             set.insert(.shared);
             set.insert(.pure);