@zigc/lib 0.17.0-dev.813 → 0.17.0-dev.836

package/build-web/fuzz.zig

@@ -285,10 +285,10 @@ fn updateStats() error{OutOfMemory}!void {
     , .{
         hdr.n_runs,
         hdr.unique_runs,
-        @as(f64, @floatFromInt(hdr.unique_runs)) / @as(f64, @floatFromInt(hdr.n_runs)),
+        @as(f64, @floatFromInt(hdr.unique_runs)) / @as(f64, @floatFromInt(hdr.n_runs)) * 100,
         covered_src_locs,
         total_src_locs,
-        @as(f64, @floatFromInt(covered_src_locs)) / @as(f64, @floatFromInt(total_src_locs)),
+        @as(f64, @floatFromInt(covered_src_locs)) / @as(f64, @floatFromInt(total_src_locs)) * 100,
         avg_speed,
     });
     defer gpa.free(html);

package/c/math.zig

@@ -37,6 +37,7 @@ comptime {
         symbol(&hypotf, "hypotf");
         symbol(&hypotl, "hypotl");
         symbol(&lrintl, "lrintl");
+        symbol(&lroundl, "lroundl");
         symbol(&modfl, "modfl");
         symbol(&rintl, "rintl");
     }
@@ -76,6 +77,8 @@ comptime {
         symbol(&log1pf, "log1pf");
         symbol(&lrint, "lrint");
         symbol(&lrintf, "lrintf");
+        symbol(&lround, "lround");
+        symbol(&lroundf, "lroundf");
         symbol(&modf, "modf");
         symbol(&nan, "nan");
         symbol(&nanf, "nanf");
@@ -278,6 +281,18 @@ fn lrintl(x: c_longdouble) callconv(.c) c_long {
     return @trunc(rintl(x));
 }
 
+fn lround(x: f64) callconv(.c) c_long {
+    return @round(x);
+}
+
+fn lroundf(x: f32) callconv(.c) c_long {
+    return @round(x);
+}
+
+fn lroundl(x: c_longdouble) callconv(.c) c_long {
+    return @round(x);
+}
+
 fn modfGeneric(comptime T: type, x: T, iptr: *T) T {
     if (math.isNegativeInf(x)) {
         iptr.* = -math.inf(T);

package/compiler/Maker/Step/Compile.zig

@@ -861,7 +861,7 @@ fn lowerZigArgs(
         "--error-limit", try allocPrint(arena, "{d}", .{err_limit}),
     };
 
-    try addFlag(gpa, zig_args, "incremental", graph.incremental);
+    try addFlag(gpa, zig_args, "incremental", conf_comp.flags4.incremental.toBool() orelse graph.incremental);
 
     try zig_args.append(gpa, "--listen=-");
 
@@ -984,6 +984,11 @@ fn addFlag(gpa: Allocator, args: *std.ArrayList([]const u8), comptime name: []co
     try args.append(gpa, if (cond) "-f" ++ name else "-fno-" ++ name);
 }
 
+fn addArchFlag(gpa: Allocator, args: *std.ArrayList([]const u8), comptime name: []const u8, opt: ?bool) !void {
+    const cond = opt orelse return;
+    try args.append(gpa, if (cond) "-m" ++ name else "-mno-" ++ name);
+}
+
 fn checkCompileErrors(arena: Allocator, maker: *Maker, step_index: Configuration.Step.Index) Step.ExtendedMakeError!void {
     const step = maker.stepByIndex(step_index);
     const conf = &maker.scanned_config.configuration;
@@ -1249,9 +1254,9 @@ fn appendModuleFlags(
     try addFlag(gpa, zig_args, "fuzz", m.flags.fuzz.toBool());
     try addFlag(gpa, zig_args, "valgrind", m.flags2.valgrind.toBool());
     try addFlag(gpa, zig_args, "PIC", m.flags2.pic.toBool());
-    try addFlag(gpa, zig_args, "red-zone", m.flags2.red_zone.toBool());
     try addFlag(gpa, zig_args, "no-builtin", m.flags2.no_builtin.toBool());
 
+    try addArchFlag(gpa, zig_args, "red-zone", m.flags2.red_zone.toBool());
     {
         try zig_args.ensureUnusedCapacity(gpa, 6);
 

package/compiler/configurer.zig

@@ -797,6 +797,7 @@ fn serialize(b: *std.Build, wc: *Configuration.Wip, writer: *Io.Writer) !void {
                                 .generated_llvm_bc = c.generated_llvm_bc != .none,
                                 .generated_llvm_ir = c.generated_llvm_ir != .none,
                                 .generated_h = c.generated_h != .none,
+                                .incremental = .init(c.incremental),
                             },
                             .root_module = try s.addModule(c.root_module),
                             .root_name = try wc.addString(c.name),

package/compiler_rt/divdf3.zig

@@ -4,7 +4,7 @@
 
 const std = @import("std");
 const compiler_rt = @import("../compiler_rt.zig");
-const symbol = @import("../compiler_rt.zig").symbol;
+const symbol = compiler_rt.symbol;
 
 const normalize = compiler_rt.normalize;
 const wideMultiply = compiler_rt.wideMultiply;
@@ -189,14 +189,13 @@ inline fn div(a: f64, b: f64) f64 {
 
     const writtenExponent = quotientExponent +% exponentBias;
 
+    const round = @intFromBool((residual << 1) >= bSignificand);
+
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
         return @bitCast(infRep | quotientSign);
     } else if (writtenExponent < 1) {
         if (writtenExponent == 0) {
-            // Check whether the rounded result is normal.
-            const round = @intFromBool((residual << 1) > bSignificand);
-            // Clear the implicit bit.
             var absResult = quotient & significandMask;
             // Round.
             absResult += round;
@@ -205,11 +204,16 @@ inline fn div(a: f64, b: f64) f64 {
                 return @bitCast(absResult | quotientSign);
             }
         }
-        // Flush denormals to zero.  In the future, it would be nice to add
-        // code to round them correctly.
-        return @bitCast(quotientSign);
+
+        const roundedQuotient = quotient +% round;
+        const shiftAmount: u32 = @intCast(1 - writtenExponent);
+        if (shiftAmount > significandBits + 1) {
+            return @bitCast(quotientSign);
+        }
+
+        const denormQuotient = roundedQuotient >> @as(std.math.Log2Int(Z), @intCast(shiftAmount));
+        return @bitCast((denormQuotient & significandMask) | quotientSign);
     } else {
-        const round = @intFromBool((residual << 1) > bSignificand);
         // Clear the implicit bit
         var absResult = quotient & significandMask;
         // Insert the exponent

package/compiler_rt/divsf3.zig

@@ -5,7 +5,7 @@
 const std = @import("std");
 
 const compiler_rt = @import("../compiler_rt.zig");
-const symbol = @import("../compiler_rt.zig").symbol;
+const symbol = compiler_rt.symbol;
 const normalize = compiler_rt.normalize;
 
 comptime {
@@ -170,14 +170,14 @@ inline fn div(a: f32, b: f32) f32 {
 
     const writtenExponent = quotientExponent +% exponentBias;
 
+    const round = @intFromBool((residual << 1) >= bSignificand);
+
     if (writtenExponent >= maxExponent) {
         // If we have overflowed the exponent, return infinity.
         return @bitCast(infRep | quotientSign);
     } else if (writtenExponent < 1) {
         if (writtenExponent == 0) {
             // Check whether the rounded result is normal.
-            const round = @intFromBool((residual << 1) > bSignificand);
-            // Clear the implicit bit.
             var absResult = quotient & significandMask;
             // Round.
             absResult += round;
@@ -186,11 +186,16 @@ inline fn div(a: f32, b: f32) f32 {
                 return @bitCast(absResult | quotientSign);
             }
         }
-        // Flush denormals to zero.  In the future, it would be nice to add
-        // code to round them correctly.
-        return @bitCast(quotientSign);
+
+        const roundedQuotient = quotient +% round;
+        const shiftAmount: u32 = @intCast(1 - writtenExponent);
+        if (shiftAmount > significandBits + 1) {
+            return @bitCast(quotientSign);
+        }
+
+        const denormQuotient = roundedQuotient >> @as(std.math.Log2Int(Z), @intCast(shiftAmount));
+        return @bitCast((denormQuotient & significandMask) | quotientSign);
     } else {
-        const round = @intFromBool((residual << 1) > bSignificand);
         // Clear the implicit bit
         var absResult = quotient & significandMask;
         // Insert the exponent

package/lldb/pretty_printers.py

@@ -707,7 +707,7 @@ def root_InternPool_Index_SummaryProvider(value, _=None):
     return re.sub(
         expr_path_re,
         lambda matchobj: getattr(unwrapped.GetValueForExpressionPath(matchobj[1]), matchobj[2]).strip(matchobj[3] or ''),
-        summary.summary.removeprefix('.').removeprefix('@"').removesuffix('"').replace(r'\"', '"'),
+        summary.value.removeprefix('.').removeprefix('@"').removesuffix('"').replace(r'\"', '"'),
     )
 
 class root_InternPool_Index_SynthProvider:
@@ -773,7 +773,7 @@ class root_InternPool_Index_Unwrapped_SynthProvider:
                 trailing_type = encoding_trailing.GetValueAsType()
                 trailing_bytes, trailing_data = bytearray(trailing_type.size), lldb.SBData()
                 def eval_config(config_name):
-                    expr = encoding_config.GetChildMemberWithName(config_name).summary.removeprefix('.').removeprefix('@"').removesuffix('"').replace(r'\"', '"')
+                    expr = encoding_config.GetChildMemberWithName(config_name).value.removeprefix('.').removeprefix('@"').removesuffix('"').replace(r'\"', '"')
                     if 'payload.' in expr:
                         return self.payload.EvaluateExpression(expr.replace('payload.', '@this().'))
                     elif expr.startswith('trailing.'):
@@ -848,7 +848,8 @@ def root_InternPool_String_SummaryProvider(value, _=None):
     if local_value is None:
         wrapped = 0
         local_value = locals_value.child[0]
-    string = local_value.GetChildMemberWithName('shared').GetChildMemberWithName('strings').GetChildMemberWithName('view').GetChildMemberWithName('0').child[wrapped & (1 << tid_shift_32) - 1].address_of
+    shared = local_value.GetChildMemberWithName('shared')
+    string = shared.GetChildMemberWithName('string_bytes').GetChildMemberWithName('view').GetChildMemberWithName('0').child[shared.GetChildMemberWithName('strings').GetChildMemberWithName('view').GetChildMemberWithName('0').child[wrapped & (1 << tid_shift_32) - 1].unsigned].address_of
     string.format = lldb.eFormatCString
     return string.value
 
@@ -878,13 +879,13 @@ class root_InternPool_Nav_Index_SynthProvider:
         wrapped = self.value.unsigned
         if wrapped == (1 << 32) - 1: return
         ip = self.value.CreateValueFromType(self.value.type).GetChildMemberWithName('debug_state').GetChildMemberWithName('intern_pool').GetNonSyntheticValue().GetChildMemberWithName('?')
-        tid_shift_32 = ip.GetChildMemberWithName('tid_shift_32').unsigned
+        tid_shift_30 = ip.GetChildMemberWithName('tid_shift_30').unsigned
         locals_value = ip.GetChildMemberWithName('locals').GetSyntheticValue()
-        local_value = locals_value.child[wrapped >> tid_shift_32]
+        local_value = locals_value.child[wrapped >> tid_shift_30]
         if local_value is None:
             wrapped = 0
             local_value = locals_value.child[0]
-        self.nav = local_value.GetChildMemberWithName('shared').GetChildMemberWithName('navs').GetChildMemberWithName('view').child[wrapped & (1 << tid_shift_32) - 1]
+        self.nav = local_value.GetChildMemberWithName('shared').GetChildMemberWithName('navs').GetChildMemberWithName('view').child[wrapped & (1 << tid_shift_30) - 1]
     def has_children(self): return False if self.nav is None else self.nav.GetNumChildren(1) > 0
     def num_children(self): return 0 if self.nav is None else self.nav.GetNumChildren()
     def get_child_index(self, name): return -1 if self.nav is None else self.nav.GetIndexOfChildWithName(name)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.813",
+  "version": "0.17.0-dev.836",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Configuration.zig

@@ -1016,7 +1016,8 @@ pub const Step = extern struct {
             generated_llvm_bc: bool,
             generated_llvm_ir: bool,
             generated_h: bool,
-            _: u9 = 0,
+            incremental: DefaultingBool,
+            _: u7 = 0,
         };
 
         pub fn isDynamicLibrary(compile: *const Compile) bool {

package/std/Build/Step/Compile.zig

@@ -234,6 +234,12 @@ is_linking_libcpp: bool = false,
 /// builtin fuzzer, see the `fuzz` flag in `Module`.
 sanitize_coverage_trace_pc_guard: ?bool = null,
 
+/// Enable or disable incremental compilation.
+///
+/// Incremental compilation reduces compile time by mutating an existing build artifact. Non-
+/// incremental compilation is slower but preserves previous build artifacts.
+incremental: ?bool = null,
+
 emit_directory: Configuration.OptionalGeneratedFileIndex = .none,
 generated_docs: Configuration.OptionalGeneratedFileIndex = .none,
 generated_asm: Configuration.OptionalGeneratedFileIndex = .none,

package/std/Build.zig

@@ -1839,7 +1839,7 @@ fn tryFindProgram(b: *Build, full_path: []const u8) ?[]const u8 {
             while (it.next()) |ext| {
                 if (!supportedWindowsProgramExtension(ext)) continue;
 
-                const extended_path = try mem.concat(arena, &.{ full_path, ext });
+                const extended_path = try mem.concat(arena, u8, &.{ full_path, ext });
 
                 if (Io.Dir.cwd().access(io, extended_path, .{ .execute = true })) |_| {
                     return extended_path;

package/std/Target.zig

@@ -2341,7 +2341,8 @@ pub fn supportsAddressSpace(
         .lut => arch == .propeller and std.Target.propeller.featureSetHas(target.cpu.features, .p2),
 
         .global, .local, .shared => is_gpu,
-        .constant => is_gpu and (context == null or context == .constant),
+        .constant => (is_gpu and (context == null or context == .constant)) or
+            (is_spirv and (context == null or context == .constant or context == .pointer)),
         .param => is_nvptx,
         .input, .output, .uniform, .push_constant, .storage_buffer, .physical_storage_buffer => is_spirv,
     };

package/std/compress/zstd.zig

@@ -121,17 +121,6 @@ fn testExpectDecompressError(err: anyerror, compressed: []const u8) !void {
     try std.testing.expectError(err, zstd_stream.err orelse {});
 }
 
-test Decompress {
-    const uncompressed = @embedFile("testdata/rfc8478.txt");
-    const compressed3 = @embedFile("testdata/rfc8478.txt.zst.3");
-    const compressed19 = @embedFile("testdata/rfc8478.txt.zst.19");
-
-    try testExpectDecompress(uncompressed, compressed3);
-    try testExpectDecompress(uncompressed, compressed19);
-    try std.testing.expectEqual(uncompressed.len, testDiscard(std.testing.allocator, compressed3));
-    try std.testing.expectEqual(uncompressed.len, testDiscard(std.testing.allocator, compressed19));
-}
-
 test "partial magic number" {
     const input_raw =
         "\x28\xb5\x2f"; // 3 bytes of the 4-byte zstandard frame magic number

package/std/hash/auto_hash.zig

@@ -76,6 +76,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
     switch (@typeInfo(Key)) {
         .noreturn,
         .@"opaque",
+        .spirv,
         .undefined,
         .null,
         .comptime_float,

package/std/lang.zig

@@ -578,6 +578,7 @@ pub const Type = union(enum) {
     @"anyframe": AnyFrame,
     vector: Vector,
     enum_literal,
+    spirv: Spirv,
 
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
@@ -781,6 +782,59 @@ pub const Type = union(enum) {
         };
     };
 
+    /// This data structure is used by the Zig language code generation and
+    /// therefore must be kept in sync with the compiler implementation.
+    pub const Spirv = union(enum(u2)) {
+        sampler,
+        image: Image,
+        sampled_image: type,
+        runtime_array: type,
+
+        pub const Image = struct {
+            usage: Usage,
+            format: Format,
+            dim: Dimensionality,
+            depth: Depth,
+            access: Access,
+            arrayed: bool,
+            multisampled: bool,
+
+            pub const Usage = union(enum(u2)) {
+                unknown: type,
+                sampled: type,
+                storage,
+            };
+
+            pub const Format = enum(u4) {
+                unknown,
+                rgba32f,
+                rgba32i,
+                rgba32u,
+                rgba16f,
+                rgba16i,
+                rgba16u,
+                rgba8unorm,
+                rgba8snorm,
+                rgba8i,
+                rgba8u,
+                r32f,
+                r32i,
+                r32u,
+            };
+
+            pub const Dimensionality = enum(u2) {
+                @"1d",
+                @"2d",
+                @"3d",
+                cube,
+            };
+
+            pub const Depth = enum(u2) { unknown, depth, not_depth };
+
+            pub const Access = enum(u2) { unknown, read_only, write_only, read_write };
+        };
+    };
+
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
     pub const Opaque = struct {

package/std/mem.zig

@@ -352,6 +352,7 @@ pub fn zeroes(comptime T: type) T {
         .noreturn,
         .undefined,
         .@"opaque",
+        .spirv,
         .frame,
         .@"anyframe",
         => {

package/std/meta.zig

@@ -14,31 +14,14 @@ test {
     _ = TrailerFlags;
 }
 
-/// Returns the variant of an enum type, `T`, which is named `str`, or `null` if no such variant exists.
+/// Returns the variant of an enum type corresponding to the provided tag name,
+/// or `null` if no such variant exists.
 pub fn stringToEnum(comptime T: type, tag_name: []const u8) ?T {
-    // Using StaticStringMap here is more performant, but it will start to take too
-    // long to compile if the enum is large enough, due to the current limits of comptime
-    // performance when doing things like constructing lookup maps at comptime.
-    // TODO The '100' here is arbitrary and should be increased when possible:
-    // - https://github.com/ziglang/zig/issues/4055
-    // - https://github.com/ziglang/zig/issues/3863
-    if (@typeInfo(T).@"enum".field_names.len <= 100) {
-        return std.StaticStringMap(T).initEnum().get(tag_name);
-    } else {
-        inline for (@typeInfo(T).@"enum".field_names) |name| {
-            if (mem.eql(u8, tag_name, name)) {
-                return @field(T, name);
-            }
-        }
-        return null;
-    }
+    return std.StaticStringMap(T).initEnum().get(tag_name);
 }
 
 test stringToEnum {
-    const E1 = enum {
-        A,
-        B,
-    };
+    const E1 = enum { A, B };
     try testing.expect(E1.A == stringToEnum(E1, "A").?);
     try testing.expect(E1.B == stringToEnum(E1, "B").?);
     try testing.expect(null == stringToEnum(E1, "C"));

package/std/start.zig

@@ -19,7 +19,9 @@ comptime {
     // decls there get run.
     _ = root;
 
-    if (builtin.output_mode == .Lib and builtin.link_mode == .dynamic) {
+    if (builtin.zig_backend == .stage2_spirv) {
+        // Do nothing
+    } else if (builtin.output_mode == .Lib and builtin.link_mode == .dynamic) {
         const dll_main_crt_startup = if (builtin.abi.isGnu()) "DllMainCRTStartup" else "_DllMainCRTStartup";
         if (native_os == .windows and !builtin.link_libc and !@hasDecl(root, dll_main_crt_startup)) {
             @export(&DllMainCRTStartup, .{ .name = dll_main_crt_startup });

package/std/static_string_map.zig

@@ -241,7 +241,10 @@ pub fn StaticStringMapWithEql(
             return self.kvs.values[self.getIndex(str) orelse return null];
         }
 
-        fn getIndex(self: Self, str: []const u8) ?usize {
+        /// Returns the index corresponding to the `str` within the
+        /// generated `kvs`, or `null` if `str` was not found.
+        /// The returned index is unrelated to the input `kvs_list`.
+        pub fn getIndex(self: Self, str: []const u8) ?usize {
             const kvs = self.kvs.*;
             if (kvs.len == 0)
                 return null;
@@ -279,6 +282,14 @@ pub fn StaticStringMapWithEql(
             };
         }
 
+        /// Returns the index within the generated `kvs` corresponding to the
+        /// key-value pair where key is the longest prefix of `str`, or `null`
+        /// if no such key-value pair was found. The returned index is unrelated
+        /// to the input `kvs_list`.
+        ///
+        /// This is effectively an O(N) algorithm which loops from `max_len` to
+        /// `min_len` and calls `getIndex()` to check all keys with the given
+        /// len.
         pub fn getLongestPrefixIndex(self: Self, str: []const u8) ?usize {
             if (self.kvs.len == 0)
                 return null;
@@ -294,11 +305,15 @@ pub fn StaticStringMapWithEql(
             return null;
         }
 
+        /// Returns the slice of keys from the generated `kvs`, which may
+        /// be in a different order than the input `kvs_list`.
         pub fn keys(self: Self) []const []const u8 {
             const kvs = self.kvs.*;
             return kvs.keys[0..kvs.len];
         }
 
+        /// Returns the slice of values from the generated `kvs`, which may
+        /// be in a different order than the input `kvs_list`.
         pub fn values(self: Self) []const V {
             const kvs = self.kvs.*;
             return kvs.values[0..kvs.len];
@@ -504,6 +519,20 @@ test "comptime-only value" {
     try testing.expect(map.get("d") == null);
 }
 
+test "getIndex" {
+    const slice = [_]TestKV{
+        .{ "longer", .A },
+        .{ "short", .B },
+    };
+    const map = TestMap.initComptime(slice);
+
+    // This index can be different than the index of the "short" KV in `slice`
+    const short_index = map.getIndex("short").?;
+    try testing.expectEqualStrings("short", map.keys()[short_index]);
+    try testing.expectEqual(.B, map.values()[short_index]);
+    try testing.expectEqual(null, map.getIndex("missing"));
+}
+
 test "getLongestPrefix" {
     const slice = [_]TestKV{
         .{ "a", .A },

package/std/testing.zig

@@ -79,6 +79,7 @@ fn expectEqualInner(comptime T: type, expected: T, actual: T) !void {
     switch (@typeInfo(@TypeOf(actual))) {
         .noreturn,
         .@"opaque",
+        .spirv,
         .frame,
         .@"anyframe",
         => @compileError("value of type " ++ @typeName(@TypeOf(actual)) ++ " encountered"),
@@ -737,6 +738,7 @@ fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpe
     switch (@typeInfo(@TypeOf(actual))) {
         .noreturn,
         .@"opaque",
+        .spirv,
         .frame,
         .@"anyframe",
         => @compileError("value of type " ++ @typeName(@TypeOf(actual)) ++ " encountered"),

package/std/zig/AstGen.zig

@@ -9327,6 +9327,16 @@ fn builtinCall(
             });
             return rvalue(gz, ri, result, node);
         },
+        .SpirvType => {
+            const spirv_type_options_ty = try gz.addStdLangValue(node, .spirv_type_options);
+            const operand = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = spirv_type_options_ty } }, params[0], .type);
+            const result = try gz.addExtendedPayload(.reify_spirv_type, Zir.Inst.ReifySpirvType{
+                .src_line = gz.astgen.source_line,
+                .node = node,
+                .operand = operand,
+            });
+            return rvalue(gz, ri, result, node);
+        },
 
         .panic => {
             try emitDbgNode(gz, node);

package/std/zig/AstRlAnnotate.zig

@@ -1079,6 +1079,10 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast.
             _ = try astrl.expr(args[3], block, ResultInfo.type_only);
             return false;
         },
+        .SpirvType => {
+            _ = try astrl.expr(args[0], block, ResultInfo.type_only);
+            return false;
+        },
         .Vector => {
             _ = try astrl.expr(args[0], block, ResultInfo.type_only);
             _ = try astrl.expr(args[1], block, ResultInfo.type_only);

package/std/zig/AstSmith.zig

@@ -238,9 +238,6 @@ fn pegToken(a: *AstSmith, tag: Token.Tag) SourceError!void {
 
     switch (lexeme[0]) {
         '_', 'a'...'z', 'A'...'Z', '0'...'9' => try a.preservePegEndOfWord(),
-        '*' => if (a.tokens_len > 0 and a.source_buf[a.source_len - 1] == '*') {
-            try a.addSourceByte(' ');
-        },
         '.' => if (a.tokens_len > 0 and switch (a.source_buf[a.source_len - 1]) {
             '.' => true,
             '0'...'9', 'a'...'z', 'A'...'Z' => a.token_tag_buf[a.tokens_len - 1] == .number_literal,
@@ -1810,7 +1807,7 @@ fn pegPrefixTypeOp(a: *AstSmith) SourceError!void {
 }
 
 /// SuffixOp
-///     <- LBRACKET Expr (DOT2 (Expr? (COLON Expr)?)?)? RBRACKET
+///     <- LBRACKET Expr (DOT2 Expr? (COLON Expr)?)? RBRACKET
 ///      / DOT IDENTIFIER
 ///      / DOTASTERISK
 ///      / DOTQUESTIONMARK
@@ -1820,12 +1817,14 @@ fn pegSuffixOp(a: *AstSmith) SourceError!void {
             try a.pegToken(.l_bracket);
             try a.pegExpr();
 
-            const components = a.smith.value(u2);
-            if (components >= 1) try a.pegToken(.ellipsis2);
-            if (components >= 2) try a.pegExpr();
-            if (components >= 3) {
-                try a.pegToken(.colon);
-                try a.pegExpr();
+            if (a.smith.value(bool)) {
+                try a.pegToken(.ellipsis2);
+                if (a.smith.value(bool))
+                    try a.pegExpr();
+                if (a.smith.value(bool)) {
+                    try a.pegToken(.colon);
+                    try a.pegExpr();
+                }
             }
 
             try a.pegToken(.r_bracket);

package/std/zig/BuiltinFn.zig

@@ -114,6 +114,7 @@ pub const Tag = enum {
     Struct,
     Union,
     Enum,
+    SpirvType,
     type_info,
     type_name,
     TypeOf,
@@ -971,6 +972,13 @@ pub const list = list: {
                 .param_count = 4,
             },
         },
+        .{
+            "@SpirvType",
+            .{
+                .tag = .SpirvType,
+                .param_count = 1,
+            },
+        },
         .{
             "@typeInfo",
             .{

package/std/zig/Parse.zig

@@ -3137,7 +3137,7 @@ fn parsePtrModifiers(p: *Parse) !PtrModifiers {
 }
 
 /// SuffixOp
-///     <- LBRACKET Expr (DOT2 (Expr? (COLON Expr)?)?)? RBRACKET
+///     <- LBRACKET Expr (DOT2 Expr? (COLON Expr)?)? RBRACKET
 ///      / DOT IDENTIFIER
 ///      / DOTASTERISK
 ///      / DOTQUESTIONMARK

package/std/zig/Zir.zig

@@ -2055,6 +2055,9 @@ pub const Inst = struct {
         /// `operand` is payload index to `ReifyEnum`.
         /// `small` contains `NameStrategy`.
         reify_enum,
+        /// Implements builtin `@SpirvType`.
+        /// `operand` is payload index to `ReifyFn`.
+        reify_spirv_type,
         /// Implements the `@cmpxchgStrong` and `@cmpxchgWeak` builtins.
         /// `small` 0=>weak 1=>strong
         /// `operand` is payload index to `Cmpxchg`.
@@ -3269,6 +3272,14 @@ pub const Inst = struct {
         field_values: Ref,
     };
 
+    pub const ReifySpirvType = struct {
+        src_line: u32,
+        /// This node is absolute, because `reify` instructions are tracked across updates, and
+        /// this simplifies the logic for getting source locations for types.
+        node: Ast.Node.Index,
+        operand: Ref,
+    };
+
     /// Trailing:
     /// 0. multi_cases_len: u32, // If has_multi_cases is set.
     /// 1. payload_capture_placeholder: Inst.Index, // If payload_capture_inst_is_placeholder is set.
@@ -3584,6 +3595,7 @@ pub const Inst = struct {
         fn_attributes,
         container_layout,
         enum_mode,
+        spirv_type_options,
         // Values
         calling_convention_c,
         calling_convention_inline,
@@ -4389,6 +4401,7 @@ fn findTrackableInner(
                 .reify_enum,
                 .reify_struct,
                 .reify_union,
+                .reify_spirv_type,
                 => return contents.other.append(gpa, inst),
 
                 // Type declarations need tracking.
@@ -5181,6 +5194,7 @@ pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void {
             .reify_enum,
             .reify_struct,
             .reify_union,
+            .reify_spirv_type,
             => {}, // tracked in order, as the owner instructions of explicit container types
             else => unreachable, // assertion failure; not trackable
         },

package/std/zip.zig

@@ -164,50 +164,6 @@ pub const EndRecord = extern struct {
     }
 };
 
-pub const Decompress = struct {
-    interface: Reader,
-    state: union {
-        inflate: flate.Decompress,
-        store: *Reader,
-    },
-
-    pub fn init(reader: *Reader, method: CompressionMethod, buffer: []u8) Reader {
-        return switch (method) {
-            .store => .{
-                .state = .{ .store = reader },
-                .interface = .{
-                    .context = undefined,
-                    .vtable = &.{ .stream = streamStore },
-                    .buffer = buffer,
-                    .end = 0,
-                    .seek = 0,
-                },
-            },
-            .deflate => .{
-                .state = .{ .inflate = .init(reader, .raw) },
-                .interface = .{
-                    .context = undefined,
-                    .vtable = &.{ .stream = streamDeflate },
-                    .buffer = buffer,
-                    .end = 0,
-                    .seek = 0,
-                },
-            },
-            else => unreachable,
-        };
-    }
-
-    fn streamStore(r: *Reader, w: *Writer, limit: std.Io.Limit) Reader.StreamError!usize {
-        const d: *Decompress = @fieldParentPtr("interface", r);
-        return d.store.read(w, limit);
-    }
-
-    fn streamDeflate(r: *Reader, w: *Writer, limit: std.Io.Limit) Reader.StreamError!usize {
-        const d: *Decompress = @fieldParentPtr("interface", r);
-        return flate.Decompress.read(&d.inflate, w, limit);
-    }
-};
-
 fn isBadFilename(filename: []const u8) bool {
     if (filename.len == 0 or filename[0] == '/')
         return true;

package/std/zon/Serializer.zig

@@ -854,6 +854,7 @@ fn canSerializeTypeInner(
         .frame,
         .@"anyframe",
         .@"opaque",
+        .spirv,
         => false,
 
         .@"enum" => |@"enum"| @"enum".mode == .exhaustive,

package/std/zon/parse.zig

@@ -1173,7 +1173,9 @@ const Parser = struct {
 };
 
 fn intFromFloatExact(T: type, value: anytype) ?T {
-    if (value > std.math.maxInt(T) or value < std.math.minInt(T)) {
+    const max: @TypeOf(value) = @floatFromInt(std.math.maxInt(T));
+    const min: @TypeOf(value) = @floatFromInt(std.math.minInt(T));
+    if (value > max or value < min) {
         return null;
     }
 
@@ -1213,6 +1215,7 @@ fn canParseTypeInner(
         .frame,
         .@"anyframe",
         .@"opaque",
+        .spirv,
         .comptime_int,
         .comptime_float,
         .enum_literal,
@@ -2447,6 +2450,7 @@ test "std.zon intFromFloatExact" {
     try std.testing.expectEqual(@as(u8, 10), intFromFloatExact(u8, @as(f32, 10.0)).?);
     try std.testing.expectEqual(@as(i8, -123), intFromFloatExact(i8, @as(f64, @as(f64, -123.0))).?);
     try std.testing.expectEqual(@as(i16, 45), intFromFloatExact(i16, @as(f128, @as(f128, 45.0))).?);
+    try std.testing.expectEqual(@as(u128, 67), intFromFloatExact(u128, @as(f128, @as(f128, 67.0))).?);
 
     // Out of range
     try std.testing.expectEqual(@as(?u4, null), intFromFloatExact(u4, @as(f32, 16.0)));
@@ -2489,6 +2493,10 @@ test "std.zon parse int" {
         @as(u65, 36893488147419103231),
         try fromSlice(u65, gpa, "368934_881_474191032_31", null, .{}),
     );
+    try std.testing.expectEqual(
+        @as(u128, 340282366920938463463374607431768211455),
+        try fromSlice(u128, gpa, "340282366920938463463374607431768211455", null, .{}),
+    );
 
     // Test big integer limits
     try std.testing.expectEqual(

package/libc/mingw/math/lroundl.c

@@ -1,37 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the mingw-w64 runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-#include <math.h>
-#include <limits.h>
-#include <errno.h>
-
-long
-lroundl (long double x)
-{
-  long double res;
-
-  if (x >= 0.0L)
-    {
-      res = ceill (x);
-      if (res - x > 0.5L)
-	res -= 1.0;
-    }
-  else
-    {
-      res = ceill (-x);
-      if (res + x > 0.5L)
-	res -= 1.0L;
-      res = -res;
-    }
-  if (!isfinite (res)
-      || res > (long double)LONG_MAX
-      || res < (long double)LONG_MIN)
-    {
-      errno = ERANGE;
-      /* Undefined behaviour, so we could return anything.  */
-      /* return res > 0.0L ? LONG_MAX : LONG_MIN;  */
-    }
-  return (long) res;
-}

package/libc/musl/src/math/aarch64/lround.c

@@ -1,8 +0,0 @@
-#include <math.h>
-
-long lround(double x)
-{
-	long n;
-	__asm__ ("fcvtas %x0, %d1" : "=r"(n) : "w"(x));
-	return n;
-}

package/libc/musl/src/math/aarch64/lroundf.c

@@ -1,8 +0,0 @@
-#include <math.h>
-
-long lroundf(float x)
-{
-	long n;
-	__asm__ ("fcvtas %x0, %s1" : "=r"(n) : "w"(x));
-	return n;
-}

package/libc/musl/src/math/lround.c

@@ -1,6 +0,0 @@
-#include <math.h>
-
-long lround(double x)
-{
-	return round(x);
-}

package/libc/musl/src/math/lroundf.c

@@ -1,6 +0,0 @@
-#include <math.h>
-
-long lroundf(float x)
-{
-	return roundf(x);
-}

package/libc/musl/src/math/lroundl.c

@@ -1,6 +0,0 @@
-#include <math.h>
-
-long lroundl(long double x)
-{
-	return roundl(x);
-}

package/libc/musl/src/math/powerpc64/lround.c

@@ -1,18 +0,0 @@
-#include <math.h>
-
-#ifdef __VSX__
-
-long lround(double x)
-{
-	long n;
-	__asm__ (
-		"xsrdpi %1, %1\n"
-		"fctid %0, %1\n" : "=d"(n), "+d"(x));
-	return n;
-}
-
-#else
-
-#include "../lround.c"
-
-#endif

package/libc/musl/src/math/powerpc64/lroundf.c

@@ -1,18 +0,0 @@
-#include <math.h>
-
-#ifdef __VSX__
-
-long lroundf(float x)
-{
-	long n;
-	__asm__ (
-		"xsrdpi %1, %1\n"
-		"fctid %0, %1\n" : "=d"(n), "+f"(x));
-	return n;
-}
-
-#else
-
-#include "../lroundf.c"
-
-#endif