ziglang · andrewrk · Oct 29, 2025 · Mar 25, 2025 · Mar 25, 2025 · Mar 27, 2025
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -413,7 +413,6 @@ set(ZIG_STAGE2_SOURCES
     lib/std/Thread/Futex.zig
     lib/std/Thread/Mutex.zig
     lib/std/Thread/Pool.zig
-    lib/std/Thread/ResetEvent.zig
     lib/std/Thread/WaitGroup.zig
     lib/std/array_hash_map.zig
     lib/std/array_list.zig

diff --git a/README.md b/README.md
@@ -76,23 +76,15 @@ This produces a `zig2` executable in the current working directory. This is a
 [without LLVM extensions](https://github.com/ziglang/zig/issues/16270), and is
 therefore lacking these features:
 - Release mode optimizations
-- [aarch64 machine code backend](https://github.com/ziglang/zig/issues/21172)
-- [@cImport](https://github.com/ziglang/zig/issues/20630)
-- [zig translate-c](https://github.com/ziglang/zig/issues/20875)
-- [Ability to compile assembly files](https://github.com/ziglang/zig/issues/21169)
 - [Some ELF linking features](https://github.com/ziglang/zig/issues/17749)
-- [Most COFF/PE linking features](https://github.com/ziglang/zig/issues/17751)
+- [Some COFF/PE linking features](https://github.com/ziglang/zig/issues/17751)
 - [Some WebAssembly linking features](https://github.com/ziglang/zig/issues/17750)
-- [Ability to create import libs from def files](https://github.com/ziglang/zig/issues/17807)
 - [Ability to create static archives from object files](https://github.com/ziglang/zig/issues/9828)
+- [Ability to compile assembly files](https://github.com/ziglang/zig/issues/21169)
 - Ability to compile C, C++, Objective-C, and Objective-C++ files
 
-However, a compiler built this way does provide a C backend, which may be
-useful for creating system packages of Zig projects using the system C
-toolchain. **In this case, LLVM is not needed!**
-
-Furthermore, a compiler built this way provides an LLVM backend that produces
-bitcode files, which may be compiled into object files via a system Clang
+Even when built this way, Zig provides an LLVM backend that produces bitcode
+files, which may be optimized and compiled into object files via a system Clang
 package. This can be used to produce system packages of Zig applications
 without the Zig package dependency on LLVM.
 

diff --git a/ci/x86_64-windows-debug.ps1 b/ci/x86_64-windows-debug.ps1
@@ -95,7 +95,7 @@ Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
+& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
 CheckLastExitCode
 
 & .\test-x86_64-windows-msvc.exe

diff --git a/ci/x86_64-windows-release.ps1 b/ci/x86_64-windows-release.ps1
@@ -113,7 +113,7 @@ Enter-VsDevShell -VsInstallPath "C:\Program Files (x86)\Microsoft Visual Studio\
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
+& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib ws2_32.lib
 CheckLastExitCode
 
 & .\test-x86_64-windows-msvc.exe

diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const assert = std.debug.assert;
 const EpochSeconds = std.time.epoch.EpochSeconds;
 const mem = std.mem;
@@ -113,7 +114,7 @@ pub const Environment = struct {
             if (parsed > max_timestamp) return error.InvalidEpoch;
             return .{ .provided = parsed };
         } else {
-            const timestamp = std.math.cast(u64, std.time.timestamp()) orelse return error.InvalidEpoch;
+            const timestamp = std.math.cast(u64, 0) orelse return error.InvalidEpoch;
             return .{ .system = std.math.clamp(timestamp, 0, max_timestamp) };
         }
     }
@@ -124,6 +125,7 @@ const Compilation = @This();
 gpa: Allocator,
 /// Allocations in this arena live all the way until `Compilation.deinit`.
 arena: Allocator,
+io: Io,
 diagnostics: *Diagnostics,
 
 code_gen_options: CodeGenOptions = .default,
@@ -157,21 +159,23 @@ type_store: TypeStore = .{},
 ms_cwd_source_id: ?Source.Id = null,
 cwd: std.fs.Dir,
 
-pub fn init(gpa: Allocator, arena: Allocator, diagnostics: *Diagnostics, cwd: std.fs.Dir) Compilation {
+pub fn init(gpa: Allocator, arena: Allocator, io: Io, diagnostics: *Diagnostics, cwd: std.fs.Dir) Compilation {
     return .{
         .gpa = gpa,
         .arena = arena,
+        .io = io,
         .diagnostics = diagnostics,
         .cwd = cwd,
     };
 }
 
 /// Initialize Compilation with default environment,
 /// pragma handlers and emulation mode set to target.
-pub fn initDefault(gpa: Allocator, arena: Allocator, diagnostics: *Diagnostics, cwd: std.fs.Dir) !Compilation {
+pub fn initDefault(gpa: Allocator, arena: Allocator, io: Io, diagnostics: *Diagnostics, cwd: std.fs.Dir) !Compilation {
     var comp: Compilation = .{
         .gpa = gpa,
         .arena = arena,
+        .io = io,
         .diagnostics = diagnostics,
         .environment = try Environment.loadAll(gpa),
         .cwd = cwd,
@@ -222,14 +226,14 @@ pub const SystemDefinesMode = enum {
     include_system_defines,
 };
 
-fn generateSystemDefines(comp: *Compilation, w: *std.Io.Writer) !void {
+fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void {
     const define = struct {
-        fn define(_w: *std.Io.Writer, name: []const u8) !void {
+        fn define(_w: *Io.Writer, name: []const u8) !void {
             try _w.print("#define {s} 1\n", .{name});
         }
     }.define;
     const defineStd = struct {
-        fn defineStd(_w: *std.Io.Writer, name: []const u8, is_gnu: bool) !void {
+        fn defineStd(_w: *Io.Writer, name: []const u8, is_gnu: bool) !void {
             if (is_gnu) {
                 try _w.print("#define {s} 1\n", .{name});
             }
@@ -957,7 +961,7 @@ fn generateSystemDefines(comp: *Compilation, w: *std.Io.Writer) !void {
 pub fn generateBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefinesMode) AddSourceError!Source {
     try comp.type_store.initNamedTypes(comp);
 
-    var allocating: std.Io.Writer.Allocating = try .initCapacity(comp.gpa, 2 << 13);
+    var allocating: Io.Writer.Allocating = try .initCapacity(comp.gpa, 2 << 13);
     defer allocating.deinit();
 
     comp.writeBuiltinMacros(system_defines_mode, &allocating.writer) catch |err| switch (err) {
@@ -971,7 +975,7 @@ pub fn generateBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefi
     return comp.addSourceFromOwnedBuffer("<builtin>", contents, .user);
 }
 
-fn writeBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefinesMode, w: *std.Io.Writer) !void {
+fn writeBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefinesMode, w: *Io.Writer) !void {
     if (system_defines_mode == .include_system_defines) {
         try w.writeAll(
             \\#define __VERSION__ "Aro
@@ -1026,7 +1030,7 @@ fn writeBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefinesMode
     }
 }
 
-fn generateFloatMacros(w: *std.Io.Writer, prefix: []const u8, semantics: target_util.FPSemantics, ext: []const u8) !void {
+fn generateFloatMacros(w: *Io.Writer, prefix: []const u8, semantics: target_util.FPSemantics, ext: []const u8) !void {
     const denormMin = semantics.chooseValue(
         []const u8,
         .{
@@ -1101,7 +1105,7 @@ fn generateFloatMacros(w: *std.Io.Writer, prefix: []const u8, semantics: target_
     try w.print("#define __{s}_MIN__ {s}{s}\n", .{ prefix, min, ext });
 }
 
-fn generateTypeMacro(comp: *const Compilation, w: *std.Io.Writer, name: []const u8, qt: QualType) !void {
+fn generateTypeMacro(comp: *const Compilation, w: *Io.Writer, name: []const u8, qt: QualType) !void {
     try w.print("#define {s} ", .{name});
     try qt.print(comp, w);
     try w.writeByte('\n');
@@ -1136,7 +1140,7 @@ fn generateFastOrLeastType(
     bits: usize,
     kind: enum { least, fast },
     signedness: std.builtin.Signedness,
-    w: *std.Io.Writer,
+    w: *Io.Writer,
 ) !void {
     const ty = comp.intLeastN(bits, signedness); // defining the fast types as the least types is permitted
 
@@ -1166,7 +1170,7 @@ fn generateFastOrLeastType(
     try comp.generateFmt(prefix, w, ty);
 }
 
-fn generateFastAndLeastWidthTypes(comp: *Compilation, w: *std.Io.Writer) !void {
+fn generateFastAndLeastWidthTypes(comp: *Compilation, w: *Io.Writer) !void {
     const sizes = [_]usize{ 8, 16, 32, 64 };
     for (sizes) |size| {
         try comp.generateFastOrLeastType(size, .least, .signed, w);
@@ -1176,7 +1180,7 @@ fn generateFastAndLeastWidthTypes(comp: *Compilation, w: *std.Io.Writer) !void {
     }
 }
 
-fn generateExactWidthTypes(comp: *Compilation, w: *std.Io.Writer) !void {
+fn generateExactWidthTypes(comp: *Compilation, w: *Io.Writer) !void {
     try comp.generateExactWidthType(w, .schar);
 
     if (QualType.short.sizeof(comp) > QualType.char.sizeof(comp)) {
@@ -1224,7 +1228,7 @@ fn generateExactWidthTypes(comp: *Compilation, w: *std.Io.Writer) !void {
     }
 }
 
-fn generateFmt(comp: *const Compilation, prefix: []const u8, w: *std.Io.Writer, qt: QualType) !void {
+fn generateFmt(comp: *const Compilation, prefix: []const u8, w: *Io.Writer, qt: QualType) !void {
     const unsigned = qt.signedness(comp) == .unsigned;
     const modifier = qt.formatModifier(comp);
     const formats = if (unsigned) "ouxX" else "di";
@@ -1233,15 +1237,15 @@ fn generateFmt(comp: *const Compilation, prefix: []const u8, w: *std.Io.Writer,
     }
 }
 
-fn generateSuffixMacro(comp: *const Compilation, prefix: []const u8, w: *std.Io.Writer, qt: QualType) !void {
+fn generateSuffixMacro(comp: *const Compilation, prefix: []const u8, w: *Io.Writer, qt: QualType) !void {
     return w.print("#define {s}_C_SUFFIX__ {s}\n", .{ prefix, qt.intValueSuffix(comp) });
 }
 
 /// Generate the following for a type:
 ///     Name macro (e.g. #define __UINT32_TYPE__ unsigned int)
 ///     Format strings (e.g. #define __UINT32_FMTu__ "u")
 ///     Suffix macro (e.g. #define __UINT32_C_SUFFIX__ U)
-fn generateExactWidthType(comp: *Compilation, w: *std.Io.Writer, original_qt: QualType) !void {
+fn generateExactWidthType(comp: *Compilation, w: *Io.Writer, original_qt: QualType) !void {
     var qt = original_qt;
     const width = qt.sizeof(comp) * 8;
     const unsigned = qt.signedness(comp) == .unsigned;
@@ -1274,7 +1278,7 @@ pub fn hasHalfPrecisionFloatABI(comp: *const Compilation) bool {
     return comp.langopts.allow_half_args_and_returns or target_util.hasHalfPrecisionFloatABI(comp.target);
 }
 
-fn generateIntMax(comp: *const Compilation, w: *std.Io.Writer, name: []const u8, qt: QualType) !void {
+fn generateIntMax(comp: *const Compilation, w: *Io.Writer, name: []const u8, qt: QualType) !void {
     const unsigned = qt.signedness(comp) == .unsigned;
     const max: u128 = switch (qt.bitSizeof(comp)) {
         8 => if (unsigned) std.math.maxInt(u8) else std.math.maxInt(i8),
@@ -1298,7 +1302,7 @@ pub fn wcharMax(comp: *const Compilation) u32 {
     };
 }
 
-fn generateExactWidthIntMax(comp: *Compilation, w: *std.Io.Writer, original_qt: QualType) !void {
+fn generateExactWidthIntMax(comp: *Compilation, w: *Io.Writer, original_qt: QualType) !void {
     var qt = original_qt;
     const bit_count: u8 = @intCast(qt.sizeof(comp) * 8);
     const unsigned = qt.signedness(comp) == .unsigned;
@@ -1315,16 +1319,16 @@ fn generateExactWidthIntMax(comp: *Compilation, w: *std.Io.Writer, original_qt:
     return comp.generateIntMax(w, name, qt);
 }
 
-fn generateIntWidth(comp: *Compilation, w: *std.Io.Writer, name: []const u8, qt: QualType) !void {
+fn generateIntWidth(comp: *Compilation, w: *Io.Writer, name: []const u8, qt: QualType) !void {
     try w.print("#define __{s}_WIDTH__ {d}\n", .{ name, qt.sizeof(comp) * 8 });
 }
 
-fn generateIntMaxAndWidth(comp: *Compilation, w: *std.Io.Writer, name: []const u8, qt: QualType) !void {
+fn generateIntMaxAndWidth(comp: *Compilation, w: *Io.Writer, name: []const u8, qt: QualType) !void {
     try comp.generateIntMax(w, name, qt);
     try comp.generateIntWidth(w, name, qt);
 }
 
-fn generateSizeofType(comp: *Compilation, w: *std.Io.Writer, name: []const u8, qt: QualType) !void {
+fn generateSizeofType(comp: *Compilation, w: *Io.Writer, name: []const u8, qt: QualType) !void {
     try w.print("#define {s} {d}\n", .{ name, qt.sizeof(comp) });
 }
 
@@ -1805,7 +1809,7 @@ pub const IncludeType = enum {
     angle_brackets,
 };
 
-fn getPathContents(comp: *Compilation, path: []const u8, limit: std.Io.Limit) ![]u8 {
+fn getPathContents(comp: *Compilation, path: []const u8, limit: Io.Limit) ![]u8 {
     if (mem.indexOfScalar(u8, path, 0) != null) {
         return error.FileNotFound;
     }
@@ -1815,11 +1819,12 @@ fn getPathContents(comp: *Compilation, path: []const u8, limit: std.Io.Limit) ![
     return comp.getFileContents(file, limit);
 }
 
-fn getFileContents(comp: *Compilation, file: std.fs.File, limit: std.Io.Limit) ![]u8 {
+fn getFileContents(comp: *Compilation, file: std.fs.File, limit: Io.Limit) ![]u8 {
+    const io = comp.io;
     var file_buf: [4096]u8 = undefined;
-    var file_reader = file.reader(&file_buf);
+    var file_reader = file.reader(io, &file_buf);
 
-    var allocating: std.Io.Writer.Allocating = .init(comp.gpa);
+    var allocating: Io.Writer.Allocating = .init(comp.gpa);
     defer allocating.deinit();
     if (file_reader.getSize()) |size| {
         const limited_size = limit.minInt64(size);
@@ -1846,7 +1851,7 @@ pub fn findEmbed(
     includer_token_source: Source.Id,
     /// angle bracket vs quotes
     include_type: IncludeType,
-    limit: std.Io.Limit,
+    limit: Io.Limit,
     opt_dep_file: ?*DepFile,
 ) !?[]u8 {
     if (std.fs.path.isAbsolute(filename)) {
@@ -2010,8 +2015,7 @@ pub fn locSlice(comp: *const Compilation, loc: Source.Location) []const u8 {
 pub fn getSourceMTimeUncached(comp: *const Compilation, source_id: Source.Id) ?u64 {
     const source = comp.getSource(source_id);
     if (comp.cwd.statFile(source.path)) |stat| {
-        const mtime = @divTrunc(stat.mtime, std.time.ns_per_s);
-        return std.math.cast(u64, mtime);
+        return std.math.cast(u64, stat.mtime.toSeconds());
     } else |_| {
         return null;
     }

diff --git a/lib/compiler/aro/aro/Driver.zig b/lib/compiler/aro/aro/Driver.zig
@@ -273,6 +273,7 @@ pub fn parseArgs(
     macro_buf: *std.ArrayList(u8),
     args: []const []const u8,
 ) (Compilation.Error || std.Io.Writer.Error)!bool {
+    const io = d.comp.io;
     var i: usize = 1;
     var comment_arg: []const u8 = "";
     var hosted: ?bool = null;
@@ -772,7 +773,7 @@ pub fn parseArgs(
                 opts.arch_os_abi, @errorName(e),
             }),
         };
-        d.comp.target = std.zig.system.resolveTargetQuery(query) catch |e| {
+        d.comp.target = std.zig.system.resolveTargetQuery(io, query) catch |e| {
             return d.fatal("unable to resolve target: {s}", .{errorDescription(e)});
         };
     }
@@ -916,8 +917,7 @@ pub fn errorDescription(e: anyerror) []const u8 {
         error.NotDir => "is not a directory",
         error.NotOpenForReading => "file is not open for reading",
         error.NotOpenForWriting => "file is not open for writing",
-        error.InvalidUtf8 => "path is not valid UTF-8",
-        error.InvalidWtf8 => "path is not valid WTF-8",
+        error.BadPathName => "bad path name",
         error.FileBusy => "file is busy",
         error.NameTooLong => "file name is too long",
         error.AccessDenied => "access denied",