@zigc/lib 0.17.0-dev.56 → 0.17.0-dev.607

package/std/zig/system/x86.zig

@@ -232,7 +232,7 @@ fn detectIntelProcessor(cpu: *Target.Cpu, family: u32, model: u32, brand_id: u32
                     cpu.model = &Target.x86.cpu.lunarlake;
                     return;
                 },
-                0xcc => {
+                0xcc, 0xd5 => {
                     cpu.model = &Target.x86.cpu.pantherlake;
                     return;
                 },
@@ -307,6 +307,20 @@ fn detectIntelProcessor(cpu: *Target.Cpu, family: u32, model: u32, brand_id: u32
             cpu.model = &Target.x86.cpu.pentium4;
             return;
         },
+        18 => switch (model) {
+            0x01, 0x03 => {
+                cpu.model = &Target.x86.cpu.novalake;
+                return;
+            },
+            else => return, // Unknown CPU Model
+        },
+        19 => switch (model) {
+            0x01 => {
+                cpu.model = &Target.x86.cpu.diamondrapids;
+                return;
+            },
+            else => return, // Unknown CPU Model
+        },
         else => return, // Unknown CPU Model
     }
 }
@@ -412,6 +426,8 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
     // AMX requires additional context to be saved by the OS.
     const has_amx_save = xcr0.xtilecfg and xcr0.xtiledata;
 
+    const has_apx_save = xcr0.apx;
+
     setFeature(cpu, .avx, has_avx_save);
     setFeature(cpu, .fma, bit(leaf.ecx, 12) and has_avx_save);
     // Only enable XSAVE if OS has enabled support for saving YMM state.
@@ -470,7 +486,20 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
         }
     }
 
-    if (max_level >= 0x7) {
+    if (max_ext_level >= 0x80000021) {
+        leaf = cpuid(0x80000021, 0);
+
+        // AMD uses a different bit for prefetchi.
+        setFeature(cpu, .prefetchi, bit(leaf.eax, 20));
+    } else {
+        for ([_]Target.x86.Feature{
+            .prefetchi,
+        }) |feat| {
+            setFeature(cpu, feat, false);
+        }
+    }
+
+    const has_avx10 = if (max_level >= 0x7) has_avx10: {
         leaf = cpuid(0x7, 0);
 
         setFeature(cpu, .fsgsbase, bit(leaf.ebx, 0));
@@ -484,7 +513,6 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
         setFeature(cpu, .rtm, bit(leaf.ebx, 11));
         // AVX512 is only supported if the OS supports the context save for it.
         setFeature(cpu, .avx512f, bit(leaf.ebx, 16) and has_avx512_save);
-        setFeature(cpu, .evex512, bit(leaf.ebx, 16) and has_avx512_save);
         setFeature(cpu, .avx512dq, bit(leaf.ebx, 17) and has_avx512_save);
         setFeature(cpu, .rdseed, bit(leaf.ebx, 18));
         setFeature(cpu, .adx, bit(leaf.ebx, 19));
@@ -556,15 +584,20 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
             setFeature(cpu, .avxneconvert, bit(leaf.edx, 5) and has_avx_save);
             setFeature(cpu, .amx_complex, bit(leaf.edx, 8) and has_amx_save);
             setFeature(cpu, .avxvnniint16, bit(leaf.edx, 10) and has_avx_save);
-            setFeature(cpu, .prefetchi, bit(leaf.edx, 14));
+            // This needs to account for prefetchi already being detected above on AMD.
+            setFeature(cpu, .prefetchi, cpu.has(.x86, .prefetchi) or bit(leaf.edx, 14));
             setFeature(cpu, .usermsr, bit(leaf.edx, 15));
             // APX
-            setFeature(cpu, .egpr, bit(leaf.edx, 21));
-            setFeature(cpu, .push2pop2, bit(leaf.edx, 21));
-            setFeature(cpu, .ppx, bit(leaf.edx, 21));
-            setFeature(cpu, .ndd, bit(leaf.edx, 21));
-            setFeature(cpu, .ccmp, bit(leaf.edx, 21));
-            setFeature(cpu, .cf, bit(leaf.edx, 21));
+            setFeature(cpu, .egpr, bit(leaf.edx, 21) and has_apx_save);
+            setFeature(cpu, .push2pop2, bit(leaf.edx, 21) and has_apx_save);
+            setFeature(cpu, .ppx, bit(leaf.edx, 21) and has_apx_save);
+            setFeature(cpu, .ndd, bit(leaf.edx, 21) and has_apx_save);
+            setFeature(cpu, .ccmp, bit(leaf.edx, 21) and has_apx_save);
+            setFeature(cpu, .nf, bit(leaf.edx, 21) and has_apx_save);
+            setFeature(cpu, .cf, bit(leaf.edx, 21) and has_apx_save);
+            setFeature(cpu, .zu, bit(leaf.edx, 21) and has_apx_save);
+
+            break :has_avx10 bit(leaf.edx, 19);
         } else {
             for ([_]Target.x86.Feature{
                 .sha512,
@@ -582,19 +615,23 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
                 .avxneconvert,
                 .amx_complex,
                 .avxvnniint16,
-                .prefetchi,
+                // prefetchi already handled earlier.
                 .usermsr,
                 .egpr,
                 .push2pop2,
                 .ppx,
                 .ndd,
                 .ccmp,
+                .nf,
                 .cf,
+                .zu,
             }) |feat| {
                 setFeature(cpu, feat, false);
             }
         }
-    } else {
+
+        break :has_avx10 false;
+    } else has_avx10: {
         for ([_]Target.x86.Feature{
             .fsgsbase,
             .sgx,
@@ -605,7 +642,6 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
             .invpcid,
             .rtm,
             .avx512f,
-            .evex512,
             .avx512dq,
             .rdseed,
             .adx,
@@ -664,18 +700,22 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
             .avxneconvert,
             .amx_complex,
             .avxvnniint16,
-            .prefetchi,
+            // prefetchi already handled earlier.
             .usermsr,
             .egpr,
             .push2pop2,
             .ppx,
             .ndd,
             .ccmp,
+            .nf,
             .cf,
+            .zu,
         }) |feat| {
             setFeature(cpu, feat, false);
         }
-    }
+
+        break :has_avx10 false;
+    };
 
     if (max_level >= 0xD and has_avx_save) {
         leaf = cpuid(0xD, 0x1);
@@ -721,10 +761,14 @@ fn detectNativeFeatures(cpu: *Target.Cpu, os_tag: Target.Os.Tag) void {
     if (max_level >= 0x24) {
         leaf = cpuid(0x24, 0);
 
-        setFeature(cpu, .avx10_1, bit(leaf.ebx, 18));
+        const avx_ver = leaf.ebx & 0xff;
+
+        setFeature(cpu, .avx10_1, has_avx10 and avx_ver >= 1);
+        setFeature(cpu, .avx10_2, has_avx10 and avx_ver >= 2);
     } else {
         for ([_]Target.x86.Feature{
             .avx10_1,
+            .avx10_2,
         }) |feat| {
             setFeature(cpu, feat, false);
         }

package/std/zig/system.zig

@@ -28,6 +28,8 @@ pub const Executor = union(enum) {
 };
 
 pub const GetExternalExecutorOptions = struct {
+    host_cpu_arch: std.Target.Cpu.Arch,
+    host_os_tag: std.Target.Os.Tag,
     allow_darling: bool = true,
     allow_qemu: bool = true,
     allow_rosetta: bool = true,
@@ -39,24 +41,21 @@ pub const GetExternalExecutorOptions = struct {
 
 /// Return whether or not the given host is capable of running executables of
 /// the other target.
-pub fn getExternalExecutor(
-    io: Io,
-    host: *const std.Target,
-    candidate: *const std.Target,
-    options: GetExternalExecutorOptions,
-) Executor {
-    const os_match = host.os.tag == candidate.os.tag;
+pub fn getExternalExecutor(io: Io, candidate: *const std.Target, options: GetExternalExecutorOptions) Executor {
+    const host_os_tag = options.host_os_tag;
+    const host_cpu_arch = options.host_cpu_arch;
+    const os_match = host_os_tag == candidate.os.tag;
     const cpu_ok = cpu_ok: {
-        if (host.cpu.arch == candidate.cpu.arch)
+        if (host_cpu_arch == candidate.cpu.arch)
             break :cpu_ok true;
 
-        if (host.cpu.arch == .x86_64 and candidate.cpu.arch == .x86)
+        if (host_cpu_arch == .x86_64 and candidate.cpu.arch == .x86)
             break :cpu_ok true;
 
-        if (host.cpu.arch == .aarch64 and candidate.cpu.arch == .arm)
+        if (host_cpu_arch == .aarch64 and candidate.cpu.arch == .arm)
             break :cpu_ok true;
 
-        if (host.cpu.arch == .aarch64_be and candidate.cpu.arch == .armeb)
+        if (host_cpu_arch == .aarch64_be and candidate.cpu.arch == .armeb)
             break :cpu_ok true;
 
         // TODO additionally detect incompatible CPU features.
@@ -83,7 +82,7 @@ pub fn getExternalExecutor(
     // If the OS match and OS is macOS and CPU is arm64, we can use Rosetta 2
     // to emulate the foreign architecture.
     if (options.allow_rosetta and os_match and
-        (host.os.tag == .maccatalyst or host.os.tag == .macos) and host.cpu.arch == .aarch64)
+        (host_os_tag == .maccatalyst or host_os_tag == .macos) and host_cpu_arch == .aarch64)
     {
         switch (candidate.cpu.arch) {
             .x86_64 => return .rosetta,
@@ -173,13 +172,13 @@ pub fn getExternalExecutor(
         .windows => {
             if (options.allow_wine) {
                 const wine_supported = switch (candidate.cpu.arch) {
-                    .thumb => switch (host.cpu.arch) {
+                    .thumb => switch (host_cpu_arch) {
                         .arm, .thumb, .aarch64 => true,
                         else => false,
                     },
-                    .aarch64 => host.cpu.arch == .aarch64,
-                    .x86 => host.cpu.arch.isX86(),
-                    .x86_64 => host.cpu.arch == .x86_64,
+                    .aarch64 => host_cpu_arch == .aarch64,
+                    .x86 => host_cpu_arch.isX86(),
+                    .x86_64 => host_cpu_arch == .x86_64,
                     else => false,
                 };
                 return if (wine_supported) .{ .wine = "wine" } else bad_result;
@@ -191,7 +190,7 @@ pub fn getExternalExecutor(
                 // This check can be loosened once darling adds a QEMU-based emulation
                 // layer for non-host architectures:
                 // https://github.com/darlinghq/darling/issues/863
-                if (candidate.cpu.arch != host.cpu.arch) {
+                if (candidate.cpu.arch != host_cpu_arch) {
                     return bad_result;
                 }
                 return .{ .darling = "darling" };
@@ -461,14 +460,8 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target {
             result.cpu.features.removeFeature(@intFromEnum(Target.arm.Feature.vfp2));
         }
 
-        // https://github.com/llvm/llvm-project/issues/135283
-        if (result.cpu.arch.isMIPS() and result.abi.float() == .soft) {
-            result.cpu.features.addFeature(@intFromEnum(Target.mips.Feature.soft_float));
-        }
-
-        // https://github.com/llvm/llvm-project/issues/168992
-        if (result.cpu.arch == .s390x) {
-            result.cpu.features.removeFeature(@intFromEnum(Target.s390x.Feature.vector));
+        if (result.cpu.arch.isXtensa() and result.abi == .call0) {
+            result.cpu.features.removeFeature(@intFromEnum(Target.xtensa.Feature.windowed));
         }
     }
 

package/std/zig/target.zig

@@ -76,15 +76,12 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .mips64el, .os = .linux, .abi = .muslabi64, .os_ver = .{ .major = 2, .minor = 3, .patch = 48 } },
     .{ .arch = .mips64el, .os = .linux, .abi = .muslabin32, .os_ver = .{ .major = 2, .minor = 6, .patch = 0 } },
     .{ .arch = .mips64el, .os = .openbsd, .abi = .none, .os_ver = .{ .major = 4, .minor = 7, .patch = 0 } },
-    .{ .arch = .powerpc, .os = .linux, .abi = .gnueabi, .os_ver = .{ .major = 1, .minor = 3, .patch = 45 }, .glibc_triple = "powerpc-linux-gnu-soft" },
-    .{ .arch = .powerpc, .os = .linux, .abi = .gnueabihf, .os_ver = .{ .major = 1, .minor = 3, .patch = 45 }, .glibc_triple = "powerpc-linux-gnu" },
     .{ .arch = .powerpc, .os = .linux, .abi = .musleabi, .os_ver = .{ .major = 1, .minor = 3, .patch = 45 } },
     .{ .arch = .powerpc, .os = .linux, .abi = .musleabihf, .os_ver = .{ .major = 1, .minor = 3, .patch = 45 } },
     .{ .arch = .powerpc, .os = .netbsd, .abi = .eabi, .os_ver = .{ .major = 6, .minor = 0, .patch = 0 } },
     .{ .arch = .powerpc, .os = .netbsd, .abi = .eabihf, .os_ver = .{ .major = 1, .minor = 4, .patch = 0 } },
     .{ .arch = .powerpc, .os = .openbsd, .abi = .eabihf, .os_ver = .{ .major = 2, .minor = 8, .patch = 0 } },
     .{ .arch = .powerpc64, .os = .freebsd, .abi = .none, .os_ver = .{ .major = 8, .minor = 0, .patch = 0 } },
-    .{ .arch = .powerpc64, .os = .linux, .abi = .gnu, .os_ver = .{ .major = 2, .minor = 6, .patch = 0 } },
     .{ .arch = .powerpc64, .os = .linux, .abi = .musl, .os_ver = .{ .major = 2, .minor = 6, .patch = 0 } },
     .{ .arch = .powerpc64, .os = .openbsd, .abi = .none, .os_ver = .{ .major = 6, .minor = 8, .patch = 0 } },
     .{ .arch = .powerpc64le, .os = .freebsd, .abi = .none, .os_ver = .{ .major = 13, .minor = 0, .patch = 0 } },
@@ -245,7 +242,7 @@ pub fn glibcArchNameHeaders(arch: std.Target.Cpu.Arch) [:0]const u8 {
         .arm, .armeb => "arm",
         .loongarch64 => "loongarch",
         .mips, .mipsel, .mips64, .mips64el => "mips",
-        .powerpc, .powerpc64, .powerpc64le => "powerpc",
+        .powerpc64le => "powerpc",
         .riscv32, .riscv64 => "riscv",
         .sparc, .sparc64 => "sparc",
         .x86, .x86_64 => "x86",

package/std/zig/tokenizer.zig

@@ -64,7 +64,6 @@ pub const Token = struct {
 
     pub const Tag = enum {
         invalid,
-        invalid_periodasterisks,
         identifier,
         string_literal,
         multiline_string_literal_line,
@@ -109,7 +108,6 @@ pub const Token = struct {
         minus_pipe_equal,
         asterisk,
         asterisk_equal,
-        asterisk_asterisk,
         asterisk_percent,
         asterisk_percent_equal,
         asterisk_pipe,
@@ -197,7 +195,6 @@ pub const Token = struct {
                 .container_doc_comment,
                 => null,
 
-                .invalid_periodasterisks => ".**",
                 .bang => "!",
                 .pipe => "|",
                 .pipe_pipe => "||",
@@ -236,7 +233,6 @@ pub const Token = struct {
                 .minus_pipe_equal => "-|=",
                 .asterisk => "*",
                 .asterisk_equal => "*=",
-                .asterisk_asterisk => "**",
                 .asterisk_percent => "*%",
                 .asterisk_percent_equal => "*%=",
                 .asterisk_pipe => "*|",
@@ -386,7 +382,6 @@ pub const Tokenizer = struct {
         angle_bracket_angle_bracket_right,
         period,
         period_2,
-        period_asterisk,
         saw_at_sign,
         invalid,
     };
@@ -569,10 +564,6 @@ pub const Tokenizer = struct {
                         result.tag = .asterisk_equal;
                         self.index += 1;
                     },
-                    '*' => {
-                        result.tag = .asterisk_asterisk;
-                        self.index += 1;
-                    },
                     '%' => continue :state .asterisk_percent,
                     '|' => continue :state .asterisk_pipe,
                     else => result.tag = .asterisk,
@@ -915,7 +906,10 @@ pub const Tokenizer = struct {
                 self.index += 1;
                 switch (self.buffer[self.index]) {
                     '.' => continue :state .period_2,
-                    '*' => continue :state .period_asterisk,
+                    '*' => {
+                        result.tag = .period_asterisk;
+                        self.index += 1;
+                    },
                     else => result.tag = .period,
                 }
             },
@@ -931,14 +925,6 @@ pub const Tokenizer = struct {
                 }
             },
 
-            .period_asterisk => {
-                self.index += 1;
-                switch (self.buffer[self.index]) {
-                    '*' => result.tag = .invalid_periodasterisks,
-                    else => result.tag = .period_asterisk,
-                }
-            },
-
             .slash => {
                 self.index += 1;
                 switch (self.buffer[self.index]) {
@@ -1343,31 +1329,6 @@ test "correctly parse pointer assignment" {
     });
 }
 
-test "correctly parse pointer dereference followed by asterisk" {
-    try testTokenize("\"b\".* ** 10", &.{
-        .string_literal,
-        .period_asterisk,
-        .asterisk_asterisk,
-        .number_literal,
-    });
-
-    try testTokenize("(\"b\".*)** 10", &.{
-        .l_paren,
-        .string_literal,
-        .period_asterisk,
-        .r_paren,
-        .asterisk_asterisk,
-        .number_literal,
-    });
-
-    try testTokenize("\"b\".*** 10", &.{
-        .string_literal,
-        .invalid_periodasterisks,
-        .asterisk_asterisk,
-        .number_literal,
-    });
-}
-
 test "range literals" {
     try testTokenize("0...9", &.{ .number_literal, .ellipsis3, .number_literal });
     try testTokenize("'0'...'9'", &.{ .char_literal, .ellipsis3, .char_literal });

package/std/zig.zig

@@ -33,6 +33,7 @@ pub const AstRlAnnotate = @import("zig/AstRlAnnotate.zig");
 pub const LibCInstallation = @import("zig/LibCInstallation.zig");
 pub const WindowsSdk = @import("zig/WindowsSdk.zig");
 pub const LibCDirs = @import("zig/LibCDirs.zig");
+pub const PkgConfig = @import("zig/PkgConfig.zig");
 pub const target = @import("zig/target.zig");
 pub const llvm = @import("zig/llvm.zig");
 
@@ -146,7 +147,10 @@ pub fn lineDelta(source: []const u8, start: usize, end: usize) isize {
 
 pub const BinNameOptions = struct {
     root_name: []const u8,
-    target: *const std.Target,
+    cpu_arch: std.Target.Cpu.Arch,
+    os_tag: std.Target.Os.Tag,
+    ofmt: std.Target.ObjectFormat,
+    abi: std.Target.Abi,
     output_mode: std.builtin.OutputMode,
     link_mode: ?std.builtin.LinkMode = null,
     version: ?std.SemanticVersion = null,
@@ -155,10 +159,12 @@ pub const BinNameOptions = struct {
 /// Returns the standard file system basename of a binary generated by the Zig compiler.
 pub fn binNameAlloc(allocator: Allocator, options: BinNameOptions) error{OutOfMemory}![]u8 {
     const root_name = options.root_name;
-    const t = options.target;
-    switch (t.ofmt) {
+    switch (options.ofmt) {
         .coff => switch (options.output_mode) {
-            .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, t.exeFileExt() }),
+            .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{
+                root_name,
+                options.os_tag.exeFileExt(options.cpu_arch),
+            }),
             .Lib => {
                 const suffix = switch (options.link_mode orelse .static) {
                     .static => ".lib",
@@ -173,16 +179,16 @@ pub fn binNameAlloc(allocator: Allocator, options: BinNameOptions) error{OutOfMe
             .Lib => {
                 switch (options.link_mode orelse .static) {
                     .static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
-                        t.libPrefix(), root_name,
+                        options.os_tag.libPrefix(options.abi), root_name,
                     }),
                     .dynamic => {
                         if (options.version) |ver| {
                             return std.fmt.allocPrint(allocator, "{s}{s}.so.{d}.{d}.{d}", .{
-                                t.libPrefix(), root_name, ver.major, ver.minor, ver.patch,
+                                options.os_tag.libPrefix(options.abi), root_name, ver.major, ver.minor, ver.patch,
                             });
                         } else {
                             return std.fmt.allocPrint(allocator, "{s}{s}.so", .{
-                                t.libPrefix(), root_name,
+                                options.os_tag.libPrefix(options.abi), root_name,
                             });
                         }
                     },
@@ -195,16 +201,16 @@ pub fn binNameAlloc(allocator: Allocator, options: BinNameOptions) error{OutOfMe
             .Lib => {
                 switch (options.link_mode orelse .static) {
                     .static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
-                        t.libPrefix(), root_name,
+                        options.os_tag.libPrefix(options.abi), root_name,
                     }),
                     .dynamic => {
                         if (options.version) |ver| {
                             return std.fmt.allocPrint(allocator, "{s}{s}.{d}.{d}.{d}.dylib", .{
-                                t.libPrefix(), root_name, ver.major, ver.minor, ver.patch,
+                                options.os_tag.libPrefix(options.abi), root_name, ver.major, ver.minor, ver.patch,
                             });
                         } else {
                             return std.fmt.allocPrint(allocator, "{s}{s}.dylib", .{
-                                t.libPrefix(), root_name,
+                                options.os_tag.libPrefix(options.abi), root_name,
                             });
                         }
                     },
@@ -213,11 +219,14 @@ pub fn binNameAlloc(allocator: Allocator, options: BinNameOptions) error{OutOfMe
             .Obj => return std.fmt.allocPrint(allocator, "{s}.o", .{root_name}),
         },
         .wasm => switch (options.output_mode) {
-            .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, t.exeFileExt() }),
+            .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{
+                root_name,
+                options.os_tag.exeFileExt(options.cpu_arch),
+            }),
             .Lib => {
                 switch (options.link_mode orelse .static) {
                     .static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
-                        t.libPrefix(), root_name,
+                        options.os_tag.libPrefix(options.abi), root_name,
                     }),
                     .dynamic => return std.fmt.allocPrint(allocator, "{s}.wasm", .{root_name}),
                 }
@@ -231,10 +240,10 @@ pub fn binNameAlloc(allocator: Allocator, options: BinNameOptions) error{OutOfMe
         .plan9 => switch (options.output_mode) {
             .Exe => return allocator.dupe(u8, root_name),
             .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{
-                root_name, t.ofmt.fileExt(t.cpu.arch),
+                root_name, options.ofmt.fileExt(options.cpu_arch),
             }),
             .Lib => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
-                t.libPrefix(), root_name,
+                options.os_tag.libPrefix(options.abi), root_name,
             }),
         },
     }
@@ -374,9 +383,9 @@ pub const Subsystem = enum {
     pub const EfiRuntimeDriver: Subsystem = .efi_runtime_driver;
 };
 
-pub const CompressDebugSections = enum { none, zlib, zstd };
+pub const CompressDebugSections = enum(u2) { none, zlib, zstd };
 
-pub const RcIncludes = enum {
+pub const RcIncludes = enum(u2) {
     /// Use MSVC if available, fall back to MinGW.
     any,
     /// Use MSVC include paths (MSVC install + Windows SDK, must be present on the system).
@@ -672,7 +681,7 @@ pub fn putAstErrorsIntoBundle(
 
 pub fn resolveTargetQueryOrFatal(io: Io, target_query: std.Target.Query) std.Target {
     return std.zig.system.resolveTargetQuery(io, target_query) catch |err|
-        std.process.fatal("unable to resolve target: {s}", .{@errorName(err)});
+        std.process.fatal("unable to resolve target: {t}", .{err});
 }
 
 pub fn parseTargetQueryOrReportFatalError(
@@ -744,9 +753,9 @@ pub fn parseTargetQueryOrReportFatalError(
 pub const EnvVar = enum {
     ZIG_GLOBAL_CACHE_DIR,
     ZIG_LOCAL_CACHE_DIR,
+    ZIG_LOCAL_PKG_DIR,
     ZIG_LIB_DIR,
     ZIG_LIBC,
-    ZIG_BUILD_RUNNER,
     ZIG_BUILD_ERROR_STYLE,
     ZIG_BUILD_MULTILINE_ERRORS,
     ZIG_VERBOSE_LINK,
@@ -763,6 +772,7 @@ pub const EnvVar = enum {
     CPLUS_INCLUDE_PATH,
     LIBRARY_PATH,
     CC,
+    PKG_CONFIG,
 
     // Terminal integration
     NO_COLOR,
@@ -810,7 +820,6 @@ pub const SimpleComptimeReason = enum(u32) {
     compile_error_string,
     inline_assembly_code,
     atomic_order,
-    array_mul_factor,
     slice_cat_operand,
     inline_call_target,
     generic_call_target,
@@ -876,7 +885,7 @@ pub const SimpleComptimeReason = enum(u32) {
     casted_to_comptime_enum,
     casted_to_comptime_int,
     casted_to_comptime_float,
-    std_builtin_decl,
+    std_lang_decl,
 
     pub fn message(r: SimpleComptimeReason) []const u8 {
         return switch (r) {
@@ -898,7 +907,6 @@ pub const SimpleComptimeReason = enum(u32) {
             .compile_error_string => "compile error string must be comptime-known",
             .inline_assembly_code => "inline assembly code must be comptime-known",
             .atomic_order         => "atomic order must be comptime-known",
-            .array_mul_factor     => "array multiplication factor must be comptime-known",
             .slice_cat_operand    => "slice being concatenated must be comptime-known",
             .inline_call_target   => "function being called inline must be comptime-known",
             .generic_call_target  => "generic function being called must be comptime-known",
@@ -960,7 +968,7 @@ pub const SimpleComptimeReason = enum(u32) {
             .casted_to_comptime_enum      => "value casted to enum with 'comptime_int' tag type must be comptime-known",
             .casted_to_comptime_int       => "value casted to 'comptime_int' must be comptime-known",
             .casted_to_comptime_float     => "value casted to 'comptime_float' must be comptime-known",
-            .std_builtin_decl             => "'std.builtin' declaration values must be comptime-known",
+            .std_lang_decl                => "'std.lang' declaration values must be comptime-known",
             // zig fmt: on
         };
     }
@@ -1158,6 +1166,74 @@ pub const ClangCliParam = struct {
     }
 };
 
+pub const AllocPrintCmdOptions = struct {
+    cwd: ?[]const u8 = null,
+    parent_env: ?*const std.process.Environ.Map = null,
+    child_env: ?*const std.process.Environ.Map = null,
+};
+
+pub fn allocPrintCmd(gpa: Allocator, argv: []const []const u8, options: AllocPrintCmdOptions) Allocator.Error![]u8 {
+    const shell = struct {
+        fn escape(writer: *Io.Writer, string: []const u8, is_argv0: bool) !void {
+            for (string) |c| {
+                if (switch (c) {
+                    else => true,
+                    '%', '+'...':', '@'...'Z', '_', 'a'...'z' => false,
+                    '=' => is_argv0,
+                }) break;
+            } else return writer.writeAll(string);
+
+            try writer.writeByte('"');
+            for (string) |c| {
+                if (switch (c) {
+                    std.ascii.control_code.nul => break,
+                    '!', '"', '$', '\\', '`' => true,
+                    else => !std.ascii.isPrint(c),
+                }) try writer.writeByte('\\');
+                switch (c) {
+                    std.ascii.control_code.nul => unreachable,
+                    std.ascii.control_code.bel => try writer.writeByte('a'),
+                    std.ascii.control_code.bs => try writer.writeByte('b'),
+                    std.ascii.control_code.ht => try writer.writeByte('t'),
+                    std.ascii.control_code.lf => try writer.writeByte('n'),
+                    std.ascii.control_code.vt => try writer.writeByte('v'),
+                    std.ascii.control_code.ff => try writer.writeByte('f'),
+                    std.ascii.control_code.cr => try writer.writeByte('r'),
+                    std.ascii.control_code.esc => try writer.writeByte('E'),
+                    ' '...'~' => try writer.writeByte(c),
+                    else => try writer.print("{o:0>3}", .{c}),
+                }
+            }
+            try writer.writeByte('"');
+        }
+    };
+
+    var aw: Io.Writer.Allocating = .init(gpa);
+    defer aw.deinit();
+    const writer = &aw.writer;
+    if (options.cwd) |path| {
+        writer.print("cd {s} && ", .{path}) catch return error.OutOfMemory;
+    }
+    if (options.child_env) |child_env| {
+        for (child_env.keys(), child_env.values()) |key, value| {
+            if (options.parent_env) |parent_env| {
+                if (parent_env.get(key)) |process_value| {
+                    if (std.mem.eql(u8, value, process_value)) continue;
+                }
+            }
+            writer.print("{s}=", .{key}) catch return error.OutOfMemory;
+            shell.escape(writer, value, false) catch return error.OutOfMemory;
+            writer.writeByte(' ') catch return error.OutOfMemory;
+        }
+    }
+    shell.escape(writer, argv[0], true) catch return error.OutOfMemory;
+    for (argv[1..]) |arg| {
+        writer.writeByte(' ') catch return error.OutOfMemory;
+        shell.escape(writer, arg, false) catch return error.OutOfMemory;
+    }
+    return aw.toOwnedSlice();
+}
+
 test {
     _ = Ast;
     _ = AstRlAnnotate;