@zigc/lib 0.17.0-dev.215 → 0.17.0-dev.228

package/std/bit_set.zig

@@ -8,50 +8,55 @@
 //!
 //! There are five variants defined here:
 //!
-//! IntegerBitSet:
+//! Integer:
 //!   A bit set with static size, which is backed by a single integer.
 //!   This set is good for sets with a small size, but may generate
 //!   inefficient code for larger sets, especially in debug mode.
 //!
-//! ArrayBitSet:
+//! Array:
 //!   A bit set with static size, which is backed by an array of usize.
 //!   This set is good for sets with a larger size, but may use
 //!   more bytes than necessary if your set is small.
 //!
-//! StaticBitSet:
-//!   Picks either IntegerBitSet or ArrayBitSet depending on the requested
+//! Static:
+//!   Picks either Integer or Array depending on the requested
 //!   size.  The interfaces of these two types match exactly, except for fields.
 //!
-//! DynamicBitSet:
+//! Dynamic:
 //!   A bit set with runtime-known size, backed by an allocated slice
 //!   of usize.
 //!
-//! DynamicBitSetUnmanaged:
-//!   A variant of DynamicBitSet which does not store a pointer to its
-//!   allocator, in order to save space.
+//! DynamicManaged:
+//!   A variant of Dynamic which stores an allocator, using it when needed.
 
 const std = @import("std.zig");
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const builtin = @import("builtin");
 
+/// Deprecated: use `Static`.
+pub const StaticBitSet = Static;
+
 /// Returns the optimal static bit set type for the specified number
 /// of elements: either `IntegerBitSet` or `ArrayBitSet`,
 /// both of which fulfill the same interface.
 /// The returned type will perform no allocations,
 /// can be copied by value, and does not require deinitialization.
-pub fn StaticBitSet(comptime size: usize) type {
+pub fn Static(comptime size: usize) type {
     if (size <= @bitSizeOf(usize)) {
-        return IntegerBitSet(size);
+        return Integer(size);
     } else {
-        return ArrayBitSet(usize, size);
+        return Array(usize, size);
     }
 }
 
+/// Deprecated: use `Integer`.
+pub const IntegerBitSet = Integer;
+
 /// A bit set with static size, which is backed by a single integer.
 /// This set is good for sets with a small size, but may generate
 /// inefficient code for larger sets, especially in debug mode.
-pub fn IntegerBitSet(comptime size: u16) type {
+pub fn Integer(comptime size: u16) type {
     return packed struct(MaskInt) {
         const Self = @This();
 
@@ -328,21 +333,24 @@ pub fn IntegerBitSet(comptime size: u16) type {
     };
 }
 
+/// Deprecated: use `Array`.
+pub const ArrayBitSet = Array;
+
 /// A bit set with static size, which is backed by an array of usize.
 /// This set is good for sets with a larger size, but may use
 /// more bytes than necessary if your set is small.
-pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
+pub fn Array(comptime MaskIntType: type, comptime size: usize) type {
     const mask_info: std.builtin.Type = @typeInfo(MaskIntType);
 
     // Make sure the mask int is indeed an int
-    if (mask_info != .int) @compileError("ArrayBitSet can only operate on integer masks, but was passed " ++ @typeName(MaskIntType));
+    if (mask_info != .int) @compileError("Array can only operate on integer masks, but was passed " ++ @typeName(MaskIntType));
 
     // It must also be unsigned.
-    if (mask_info.int.signedness != .unsigned) @compileError("ArrayBitSet requires an unsigned integer mask type, but was passed " ++ @typeName(MaskIntType));
+    if (mask_info.int.signedness != .unsigned) @compileError("Array requires an unsigned integer mask type, but was passed " ++ @typeName(MaskIntType));
 
     // And it must not be empty.
     if (MaskIntType == u0)
-        @compileError("ArrayBitSet requires a sized integer for its mask int.  u0 does not work.");
+        @compileError("Array requires a sized integer for its mask int.  u0 does not work.");
 
     const byte_size = std.mem.byte_size_in_bits;
 
@@ -352,7 +360,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         var desired_bits = std.math.ceilPowerOfTwoAssert(usize, @bitSizeOf(MaskIntType));
         if (desired_bits < byte_size) desired_bits = byte_size;
         const FixedMaskType = std.meta.Int(.unsigned, desired_bits);
-        @compileError("ArrayBitSet was passed integer type " ++ @typeName(MaskIntType) ++
+        @compileError("Array was passed integer type " ++ @typeName(MaskIntType) ++
             ", which is not a power of two.  Please round this up to a power of two integer size (i.e. " ++ @typeName(FixedMaskType) ++ ").");
     }
 
@@ -363,7 +371,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         var desired_bits = @sizeOf(MaskIntType) * byte_size;
         desired_bits = std.math.ceilPowerOfTwoAssert(usize, desired_bits);
         const FixedMaskType = std.meta.Int(.unsigned, desired_bits);
-        @compileError("ArrayBitSet was passed integer type " ++ @typeName(MaskIntType) ++
+        @compileError("Array was passed integer type " ++ @typeName(MaskIntType) ++
             ", which contains padding bits.  Please round this up to an unpadded integer size (i.e. " ++ @typeName(FixedMaskType) ++ ").");
     }
 
@@ -673,7 +681,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         }
 
         pub fn Iterator(comptime options: IteratorOptions) type {
-            return BitSetIterator(MaskInt, options);
+            return GenericIterator(MaskInt, options);
         }
 
         fn maskBit(index: usize) MaskInt {
@@ -688,9 +696,12 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
     };
 }
 
+/// Deprecated: use `Dynamic`.
+pub const DynamicBitSetUnmanaged = Dynamic;
+
 /// A bit set with runtime-known size, backed by an allocated slice
 /// of usize.  The allocator must be tracked externally by the user.
-pub const DynamicBitSetUnmanaged = struct {
+pub const Dynamic = struct {
     const Self = @This();
 
     /// The integer type used to represent a mask in this bit set
@@ -1074,7 +1085,7 @@ pub const DynamicBitSetUnmanaged = struct {
     }
 
     pub fn Iterator(comptime options: IteratorOptions) type {
-        return BitSetIterator(MaskInt, options);
+        return GenericIterator(MaskInt, options);
     }
 
     fn maskBit(index: usize) MaskInt {
@@ -1091,10 +1102,16 @@ pub const DynamicBitSetUnmanaged = struct {
     }
 };
 
+/// Deprecated: use `DynamicManaged` or `Dynamic` (will need to update callsites).
+pub const DynamicBitSet = DynamicManaged;
+
 /// A bit set with runtime-known size, backed by an allocated slice
-/// of usize.  Thin wrapper around DynamicBitSetUnmanaged which keeps
+/// of usize.  Thin wrapper around Dynamic which keeps
 /// track of the allocator instance.
-pub const DynamicBitSet = struct {
+///
+/// Deprecated in favor of `Dynamic` which accepts an `Allocator`
+/// as a parameter when needed instead of storing it.
+pub const DynamicManaged = struct {
     const Self = @This();
 
     /// The integer type used to represent a mask in this bit set
@@ -1104,12 +1121,12 @@ pub const DynamicBitSet = struct {
     pub const ShiftInt = std.math.Log2Int(MaskInt);
 
     allocator: Allocator,
-    unmanaged: DynamicBitSetUnmanaged = .{},
+    unmanaged: Dynamic = .{},
 
     /// Creates a bit set with no elements present.
     pub fn initEmpty(allocator: Allocator, bit_length: usize) !Self {
         return Self{
-            .unmanaged = try DynamicBitSetUnmanaged.initEmpty(allocator, bit_length),
+            .unmanaged = try .initEmpty(allocator, bit_length),
             .allocator = allocator,
         };
     }
@@ -1117,7 +1134,7 @@ pub const DynamicBitSet = struct {
     /// Creates a bit set with all elements present.
     pub fn initFull(allocator: Allocator, bit_length: usize) !Self {
         return Self{
-            .unmanaged = try DynamicBitSetUnmanaged.initFull(allocator, bit_length),
+            .unmanaged = try .initFull(allocator, bit_length),
             .allocator = allocator,
         };
     }
@@ -1247,7 +1264,7 @@ pub const DynamicBitSet = struct {
         return self.unmanaged.iterator(options);
     }
 
-    pub const Iterator = DynamicBitSetUnmanaged.Iterator;
+    pub const Iterator = Dynamic.Iterator;
 };
 
 /// Options for configuring an iterator over a bit set
@@ -1274,7 +1291,7 @@ pub const IteratorOptions = struct {
 };
 
 // The iterator is reusable between several bit set types
-fn BitSetIterator(comptime MaskInt: type, comptime options: IteratorOptions) type {
+fn GenericIterator(comptime MaskInt: type, comptime options: IteratorOptions) type {
     const ShiftInt = std.math.Log2Int(MaskInt);
     const kind = options.kind;
     const direction = options.direction;
@@ -1713,37 +1730,37 @@ fn testStaticBitSet(comptime Set: type) !void {
     try testPureBitSet(Set);
 }
 
-test IntegerBitSet {
+test Integer {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (comptime builtin.cpu.has(.riscv, .v) and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/24300
 
-    try testStaticBitSet(IntegerBitSet(0));
-    try testStaticBitSet(IntegerBitSet(1));
-    try testStaticBitSet(IntegerBitSet(2));
-    try testStaticBitSet(IntegerBitSet(5));
-    try testStaticBitSet(IntegerBitSet(8));
-    try testStaticBitSet(IntegerBitSet(32));
-    try testStaticBitSet(IntegerBitSet(64));
-    try testStaticBitSet(IntegerBitSet(127));
+    try testStaticBitSet(Integer(0));
+    try testStaticBitSet(Integer(1));
+    try testStaticBitSet(Integer(2));
+    try testStaticBitSet(Integer(5));
+    try testStaticBitSet(Integer(8));
+    try testStaticBitSet(Integer(32));
+    try testStaticBitSet(Integer(64));
+    try testStaticBitSet(Integer(127));
 }
 
-test ArrayBitSet {
+test Array {
     inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) |size| {
-        try testStaticBitSet(ArrayBitSet(u8, size));
-        try testStaticBitSet(ArrayBitSet(u16, size));
-        try testStaticBitSet(ArrayBitSet(u32, size));
-        try testStaticBitSet(ArrayBitSet(u64, size));
-        try testStaticBitSet(ArrayBitSet(u128, size));
+        try testStaticBitSet(Array(u8, size));
+        try testStaticBitSet(Array(u16, size));
+        try testStaticBitSet(Array(u32, size));
+        try testStaticBitSet(Array(u64, size));
+        try testStaticBitSet(Array(u128, size));
     }
 }
 
-test DynamicBitSetUnmanaged {
+test Dynamic {
     const allocator = std.testing.allocator;
-    var a = try DynamicBitSetUnmanaged.initEmpty(allocator, 300);
+    var a: Dynamic = try .initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
     a.deinit(allocator);
 
-    a = try DynamicBitSetUnmanaged.initEmpty(allocator, 0);
+    a = try .initEmpty(allocator, 0);
     defer a.deinit(allocator);
     for ([_]usize{ 1, 2, 31, 32, 33, 0, 65, 64, 63, 500, 254, 3000 }) |size| {
         const old_len = a.capacity();
@@ -1769,17 +1786,17 @@ test DynamicBitSetUnmanaged {
         }
         try testing.expectEqual(@as(usize, 0), empty.count());
 
-        var full = try DynamicBitSetUnmanaged.initFull(allocator, size);
+        var full: Dynamic = try .initFull(allocator, size);
         defer full.deinit(allocator);
         try testing.expectEqual(@as(usize, size), full.count());
 
         try testEql(empty, full, size);
         {
-            var even = try DynamicBitSetUnmanaged.initEmpty(allocator, size);
+            var even: Dynamic = try .initEmpty(allocator, size);
             defer even.deinit(allocator);
             fillEven(&even, size);
 
-            var odd = try DynamicBitSetUnmanaged.initEmpty(allocator, size);
+            var odd: Dynamic = try .initEmpty(allocator, size);
             defer odd.deinit(allocator);
             fillOdd(&odd, size);
 
@@ -1790,13 +1807,13 @@ test DynamicBitSetUnmanaged {
     }
 }
 
-test DynamicBitSet {
+test DynamicManaged {
     const allocator = std.testing.allocator;
-    var a = try DynamicBitSet.initEmpty(allocator, 300);
+    var a: DynamicManaged = try .initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
     a.deinit();
 
-    a = try DynamicBitSet.initEmpty(allocator, 0);
+    a = try .initEmpty(allocator, 0);
     defer a.deinit();
     for ([_]usize{ 1, 2, 31, 32, 33, 0, 65, 64, 63, 500, 254, 3000 }) |size| {
         const old_len = a.capacity();
@@ -1822,7 +1839,7 @@ test DynamicBitSet {
         }
         try testing.expectEqual(@as(usize, 0), tmp.count());
 
-        var b = try DynamicBitSet.initFull(allocator, size);
+        var b: DynamicManaged = try .initFull(allocator, size);
         defer b.deinit();
         try testing.expectEqual(@as(usize, size), b.count());
 
@@ -1831,10 +1848,10 @@ test DynamicBitSet {
     }
 }
 
-test StaticBitSet {
-    try testing.expectEqual(IntegerBitSet(0), StaticBitSet(0));
-    try testing.expectEqual(IntegerBitSet(5), StaticBitSet(5));
-    try testing.expectEqual(IntegerBitSet(@bitSizeOf(usize)), StaticBitSet(@bitSizeOf(usize)));
-    try testing.expectEqual(ArrayBitSet(usize, @bitSizeOf(usize) + 1), StaticBitSet(@bitSizeOf(usize) + 1));
-    try testing.expectEqual(ArrayBitSet(usize, 500), StaticBitSet(500));
+test Static {
+    try testing.expectEqual(Integer(0), Static(0));
+    try testing.expectEqual(Integer(5), Static(5));
+    try testing.expectEqual(Integer(@bitSizeOf(usize)), Static(@bitSizeOf(usize)));
+    try testing.expectEqual(Array(usize, @bitSizeOf(usize) + 1), Static(@bitSizeOf(usize) + 1));
+    try testing.expectEqual(Array(usize, 500), Static(500));
 }

package/std/c.zig

@@ -1664,12 +1664,12 @@ pub const MSF = switch (native_os) {
         pub const ASYNC = 1;
         pub const INVALIDATE = 2;
     },
-    .openbsd => struct {
+    .openbsd, .haiku => struct {
         pub const ASYNC = 1;
         pub const SYNC = 2;
         pub const INVALIDATE = 4;
     },
-    .haiku, .netbsd, .illumos => struct {
+    .netbsd, .illumos => struct {
         pub const ASYNC = 1;
         pub const INVALIDATE = 2;
         pub const SYNC = 4;

package/std/crypto/codecs/base64_hex_ct.zig

@@ -3,7 +3,7 @@
 //! This is designed to be used in cryptographic applications where timing attacks are a concern.
 const std = @import("std");
 const testing = std.testing;
-const StaticBitSet = std.StaticBitSet;
+const StaticBitSet = std.bit_set.Static;
 
 pub const Error = error{
     /// An invalid character was found in the input.

package/std/crypto/ml_kem.zig

@@ -1456,8 +1456,6 @@ fn randPolyNormalized(rnd: anytype) Poly {
 }
 
 test "MulHat" {
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     var rnd = RndGen.init(0);
 
     for (0..100) |_| {
@@ -1612,8 +1610,6 @@ test "Polynomial packing" {
 }
 
 test "Test inner PKE" {
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     var seed: [32]u8 = undefined;
     var pt: [32]u8 = undefined;
     for (&seed, &pt, 0..) |*s, *p, i| {
@@ -1635,8 +1631,6 @@ test "Test inner PKE" {
 }
 
 test "Test happy flow" {
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     var seed: [64]u8 = undefined;
     for (&seed, 0..) |*s, i| {
         s.* = @as(u8, @intCast(i));
@@ -1661,23 +1655,14 @@ test "Test happy flow" {
 // Code to test NIST Known Answer Tests (KAT), see PQCgenKAT.c.
 
 test "NIST KAT test d00.Kyber512" {
-    if (comptime builtin.cpu.has(.loongarch, .lsx)) return error.SkipZigTest;
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     try testNistKat(d00.Kyber512, "e9c2bd37133fcb40772f81559f14b1f58dccd1c816701be9ba6214d43baf4547");
 }
 
 test "NIST KAT test d00.Kyber1024" {
-    if (comptime builtin.cpu.has(.loongarch, .lsx)) return error.SkipZigTest;
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     try testNistKat(d00.Kyber1024, "89248f2f33f7f4f7051729111f3049c409a933ec904aedadf035f30fa5646cd5");
 }
 
 test "NIST KAT test d00.Kyber768" {
-    if (comptime builtin.cpu.has(.loongarch, .lsx)) return error.SkipZigTest;
-    if (comptime builtin.cpu.has(.s390x, .vector)) return error.SkipZigTest;
-
     try testNistKat(d00.Kyber768, "a1e122cad3c24bc51622e4c242d8b8acbcd3f618fee4220400605ca8f9ea02c2");
 }
 

package/std/enums.zig

@@ -247,7 +247,7 @@ pub fn EnumSet(comptime E: type) type {
         /// The element type for this set.
         pub const Key = Indexer.Key;
 
-        const BitSet = std.StaticBitSet(Indexer.count);
+        const BitSet = std.bit_set.Static(Indexer.count);
 
         /// The maximum number of items in this set.
         pub const len = Indexer.count;
@@ -445,7 +445,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         /// The number of possible keys in the map
         pub const len = Indexer.count;
 
-        const BitSet = std.StaticBitSet(Indexer.count);
+        const BitSet = std.bit_set.Static(Indexer.count);
 
         /// Bits determining whether items are in the map
         bits: BitSet = .empty,

package/std/fs/path.zig

@@ -897,7 +897,7 @@ pub fn resolveWindows(allocator: Allocator, paths: []const []const u8) Allocator
     var buf: [3]usize = undefined;
     var bit_set_allocator_state: std.heap.BufferFirstAllocator = .init(@ptrCast(&buf), allocator);
     const bit_set_allocator = bit_set_allocator_state.allocator();
-    var relevant_paths = try std.bit_set.DynamicBitSetUnmanaged.initEmpty(bit_set_allocator, paths.len);
+    var relevant_paths: std.bit_set.Dynamic = try .initEmpty(bit_set_allocator, paths.len);
     defer relevant_paths.deinit(bit_set_allocator);
 
     // Iterate the paths backwards, marking the relevant paths along the way.

package/std/math/float.zig

@@ -4,6 +4,68 @@ const assert = std.debug.assert;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
+/// A namespace for functions that deal with floats that provide greater than
+/// double precision (`f80`, `f128`, `c_longdouble`). Commonly referred to as
+/// `long double` in C.
+pub const long_double = struct {
+    const U80 = @Int(.unsigned, 80);
+
+    inline fn bitWidth(x: anytype) u16 {
+        const T = @TypeOf(x);
+        return switch (T) {
+            f80, f128, c_longdouble => @typeInfo(T).float.bits,
+            else => @compileError("Unsupported type: " ++ @typeName(T) ++ "\nPass a `f80`, `f128`, or `c_longdouble`."),
+        };
+    }
+
+    /// Returns the sign + exponent bits of a `long double`.
+    pub fn signExponent(x: anytype) u16 {
+        const bit_width = bitWidth(x);
+        switch (bit_width) {
+            80 => {
+                const bits: U80 = @bitCast(x);
+                return @intCast(bits >> 64);
+            },
+            128 => {
+                const bits: u128 = @bitCast(x);
+                return @intCast(bits >> 112);
+            },
+            // `c_longdouble` can have <80 bits on some targets, we want to error on that
+            else => @compileError(std.fmt.comptimePrint("`signExponent` supports floats of only `80` and `128` bit width, got bit width: {d}", .{bit_width})),
+        }
+    }
+
+    test "signExponent" {
+        try expectEqual(signExponent(@as(f80, -0.0)), 0x8000);
+        try expectEqual(signExponent(@as(f128, 0.0)), 0x0000);
+        try expectEqual(signExponent(@as(f128, 42.0)), 0x4004);
+        try expectEqual(signExponent(nan(c_longdouble)), 0x7FFF);
+    }
+
+    /// Takes the top 16 bits of a `long double`'s mantissa.
+    pub fn mantissaTop(x: anytype) u16 {
+        const bit_width = bitWidth(x);
+        switch (bit_width) {
+            80 => {
+                const bits: U80 = @bitCast(x);
+                return @intCast((bits >> 48) & 0xFFFF);
+            },
+            128 => {
+                const bits: u128 = @bitCast(x);
+                return @intCast((bits >> 96) & 0xFFFF);
+            },
+            // `c_longdouble` can have <80 bits on some targets, we want to error on that
+            else => @compileError(std.fmt.comptimePrint("`mantissaTop` supports floats of only `80` and `128` bit width, got bit width: {d}", .{bit_width})),
+        }
+    }
+
+    test "mantissaTop" {
+        try expectEqual(mantissaTop(@as(f80, -0.0)), 0x0000);
+        try expectEqual(mantissaTop(nan(f128)), 0x8000);
+        try expectEqual(mantissaTop(@as(f128, 42.0)), 0x5000);
+    }
+};
+
 pub fn FloatRepr(comptime Float: type) type {
     const fractional_bits = floatFractionalBits(Float);
     const exponent_bits = floatExponentBits(Float);

package/std/math/modf.zig

@@ -86,7 +86,7 @@ fn ModfTests(comptime T: type) type {
         }
         test "vector" {
             if (builtin.os.tag.isDarwin() and builtin.cpu.arch == .aarch64) return error.SkipZigTest;
-            if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
+            if (builtin.cpu.arch == .s390x) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194256
 
             const widths = [_]comptime_int{ 1, 2, 3, 4, 8, 16 };
 

package/std/math.zig

@@ -58,6 +58,7 @@ pub const floatMax = float.floatMax;
 pub const floatEps = float.floatEps;
 pub const floatEpsAt = float.floatEpsAt;
 pub const inf = float.inf;
+pub const long_double = float.long_double;
 pub const nan = float.nan;
 pub const snan = float.snan;
 

package/std/std.zig

@@ -9,7 +9,9 @@ pub const StaticStringMapWithEql = static_string_map.StaticStringMapWithEql;
 pub const Deque = @import("deque.zig").Deque;
 pub const DoublyLinkedList = @import("DoublyLinkedList.zig");
 pub const DynLib = @import("dynamic_library.zig").DynLib;
+/// Deprecated: use `bit_set.DynamicManaged`.
 pub const DynamicBitSet = bit_set.DynamicBitSet;
+/// Deprecated: use `bit_set.Dynamic`.
 pub const DynamicBitSetUnmanaged = bit_set.DynamicBitSetUnmanaged;
 pub const EnumArray = enums.EnumArray;
 pub const EnumMap = enums.EnumMap;
@@ -24,6 +26,7 @@ pub const Progress = @import("Progress.zig");
 pub const Random = @import("Random.zig");
 pub const SemanticVersion = @import("SemanticVersion.zig");
 pub const SinglyLinkedList = @import("SinglyLinkedList.zig");
+/// Deprecated: use `bit_set.Static`.
 pub const StaticBitSet = bit_set.StaticBitSet;
 pub const StringHashMap = hash_map.StringHashMap;
 pub const StringHashMapUnmanaged = hash_map.StringHashMapUnmanaged;

package/std/testing.zig

@@ -501,7 +501,7 @@ const BytesDiffer = struct {
         var row: usize = 0;
         while (expected_iterator.next()) |chunk| {
             // to avoid having to calculate diffs twice per chunk
-            var diffs: std.bit_set.IntegerBitSet(16) = .{ .mask = 0 };
+            var diffs: std.bit_set.Integer(16) = .{ .mask = 0 };
             for (chunk, 0..) |byte, col| {
                 const absolute_byte_index = col + row * 16;
                 const diff = if (absolute_byte_index < self.actual.len) self.actual[absolute_byte_index] != byte else true;

package/std/zig/target.zig

@@ -84,7 +84,6 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .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 +244,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",
+        .powerpc, .powerpc64le => "powerpc",
         .riscv32, .riscv64 => "riscv",
         .sparc, .sparc64 => "sparc",
         .x86, .x86_64 => "x86",

package/std/zon/parse.zig

@@ -3129,7 +3129,7 @@ test "std.zon free on error" {
 
 test "std.zon vector" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/15330
-    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .s390x) return error.SkipZigTest; // github.com/ziglang/zig/issues/25957
+    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .s390x) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/25957
 
     const gpa = std.testing.allocator;
 

package/compiler_rt/long_double.zig

@@ -1,37 +0,0 @@
-//! Utilities for dealing with the `long double` type (`f80` or `f128`)
-
-const std = @import("std");
-
-pub const U80 = std.meta.Int(.unsigned, 80);
-
-/// Returns the sign + exponent bits of a `long double`
-pub fn signExponent(x: anytype) u16 {
-    const T = @TypeOf(x);
-    switch (T) {
-        f80 => {
-            const bits: U80 = @bitCast(x);
-            return @intCast(bits >> 64);
-        },
-        f128 => {
-            const bits: u128 = @bitCast(x);
-            return @intCast(bits >> 112);
-        },
-        else => @compileError("`signExponent` supports only `f80` and `f128`, got: " ++ @typeName(T)),
-    }
-}
-
-/// Takes the top 16 bits of a `long double`'s mantissa
-pub fn mantissaTop(x: anytype) u16 {
-    const T = @TypeOf(x);
-    switch (T) {
-        f80 => {
-            const bits: U80 = @bitCast(x);
-            return @intCast((bits >> 48) & 0xFFFF);
-        },
-        f128 => {
-            const bits: u128 = @bitCast(x);
-            return @intCast((bits >> 96) & 0xFFFF);
-        },
-        else => @compileError("`mantissaTop` supports only `f80` and `f128`, got: " ++ @typeName(T)),
-    }
-}

package/libc/mingw/math/lrintl.c

@@ -1,18 +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>
-
-long lrintl (long double x) 
-{
-  long retval = 0l;
-#if __SIZEOF_LONG_DOUBLE__ == __SIZEOF_DOUBLE__
-    retval = lrint(x);
-#elif defined(_AMD64_) || defined(__x86_64__) || defined(_X86_) || defined(__i386__)
-  __asm__ __volatile__ ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");
-#endif
-  return retval;
-}
-

package/libc/mingw/math/rintl.c

@@ -1,16 +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>
-
-long double rintl (long double x) {
-  long double retval = 0.0L;
-#if __SIZEOF_LONG_DOUBLE__ == __SIZEOF_DOUBLE__
-    retval = rint(x);
-#elif defined(_AMD64_) || defined(__x86_64__) || defined(_X86_) || defined(__i386__)
-  __asm__ __volatile__ ("frndint;": "=t" (retval) : "0" (x));
-#endif
-  return retval;
-}

package/libc/musl/src/math/i386/lrintl.c

@@ -1,8 +0,0 @@
-#include <math.h>
-
-long lrintl(long double x)
-{
-	long r;
-	__asm__ ("fistpl %0" : "=m"(r) : "t"(x) : "st");
-	return r;
-}