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

package/std/json/static.zig

@@ -32,6 +32,7 @@ pub const ParseOptions = struct {
     /// The default for `parseFromSlice` or `parseFromTokenSource` with a `*std.json.Scanner` input
     /// is the length of the input slice, which means `error.ValueTooLong` will never be returned.
     /// The default for `parseFromTokenSource` with a `*std.json.Reader` is `std.json.default_max_value_len`.
+    /// Ignored for values that don't need allocation or are not copied (see `allocate`).
     /// Ignored for `parseFromValue` and `parseFromValueLeaky`.
     max_value_len: ?usize = null,
 
@@ -286,20 +287,20 @@ pub fn innerParse(
                 },
             };
 
-            inline for (unionInfo.fields) |u_field| {
-                if (std.mem.eql(u8, u_field.name, field_name)) {
+            inline for (unionInfo.field_names, unionInfo.field_types) |u_field_name, u_field_type| {
+                if (std.mem.eql(u8, u_field_name, field_name)) {
                     // Free the name token now in case we're using an allocator that optimizes freeing the last allocated object.
                     // (Recursing into innerParse() might trigger more allocations.)
                     freeAllocated(allocator, name_token.?);
                     name_token = null;
-                    if (u_field.type == void) {
+                    if (u_field_type == void) {
                         // void isn't really a json type, but we can support void payload union tags with {} as a value.
                         if (.object_begin != try source.next()) return error.UnexpectedToken;
                         if (.object_end != try source.next()) return error.UnexpectedToken;
-                        result = @unionInit(T, u_field.name, {});
+                        result = @unionInit(T, u_field_name, {});
                     } else {
                         // Recurse.
-                        result = @unionInit(T, u_field.name, try innerParse(u_field.type, allocator, source, options));
+                        result = @unionInit(T, u_field_name, try innerParse(u_field_type, allocator, source, options));
                     }
                     break;
                 }
@@ -318,8 +319,8 @@ pub fn innerParse(
                 if (.array_begin != try source.next()) return error.UnexpectedToken;
 
                 var r: T = undefined;
-                inline for (0..structInfo.fields.len) |i| {
-                    r[i] = try innerParse(structInfo.fields[i].type, allocator, source, options);
+                inline for (structInfo.field_types, 0..) |field_type, i| {
+                    r[i] = try innerParse(field_type, allocator, source, options);
                 }
 
                 if (.array_end != try source.next()) return error.UnexpectedToken;
@@ -334,7 +335,7 @@ pub fn innerParse(
             if (.object_begin != try source.next()) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.field_names.len]bool = @splat(false);
 
             while (true) {
                 var name_token: ?Token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
@@ -348,9 +349,14 @@ pub fn innerParse(
                     },
                 };
 
-                inline for (structInfo.fields, 0..) |field, i| {
-                    if (field.is_comptime) @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ field.name);
-                    if (std.mem.eql(u8, field.name, field_name)) {
+                inline for (
+                    structInfo.field_names,
+                    structInfo.field_types,
+                    structInfo.field_attrs,
+                    0..,
+                ) |f_name, f_type, f_attrs, i| {
+                    if (f_attrs.@"comptime") @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ f_name);
+                    if (std.mem.eql(u8, f_name, field_name)) {
                         // Free the name token now in case we're using an allocator that optimizes freeing the last allocated object.
                         // (Recursing into innerParse() might trigger more allocations.)
                         freeAllocated(allocator, name_token.?);
@@ -360,14 +366,14 @@ pub fn innerParse(
                                 .use_first => {
                                     // Parse and ignore the redundant value.
                                     // We don't want to skip the value, because we want type checking.
-                                    _ = try innerParse(field.type, allocator, source, options);
+                                    _ = try innerParse(f_type, allocator, source, options);
                                     break;
                                 },
                                 .@"error" => return error.DuplicateField,
                                 .use_last => {},
                             }
                         }
-                        @field(r, field.name) = try innerParse(field.type, allocator, source, options);
+                        @field(r, f_name) = try innerParse(f_type, allocator, source, options);
                         fields_seen[i] = true;
                         break;
                     }
@@ -490,10 +496,10 @@ pub fn innerParse(
                             if (ptrInfo.sentinel()) |s| {
                                 // Use our own array list so we can append the sentinel.
                                 var value_list = ArrayList(u8).init(allocator);
-                                _ = try source.allocNextIntoArrayList(&value_list, .alloc_always);
+                                _ = try source.allocNextIntoArrayListMax(&value_list, .alloc_always, options.max_value_len.?);
                                 return try value_list.toOwnedSliceSentinel(s);
                             }
-                            if (ptrInfo.is_const) {
+                            if (ptrInfo.attrs.@"const") {
                                 switch (try source.nextAllocMax(allocator, options.allocate.?, options.max_value_len.?)) {
                                     inline .string, .allocated_string => |slice| return slice,
                                     else => unreachable,
@@ -613,16 +619,16 @@ pub fn innerParseFromValue(
             const kv = it.next().?;
             const field_name = kv.key_ptr.*;
 
-            inline for (unionInfo.fields) |u_field| {
-                if (std.mem.eql(u8, u_field.name, field_name)) {
-                    if (u_field.type == void) {
+            inline for (unionInfo.field_names, unionInfo.field_types) |u_field_name, u_field_type| {
+                if (std.mem.eql(u8, u_field_name, field_name)) {
+                    if (u_field_type == void) {
                         // void isn't really a json type, but we can support void payload union tags with {} as a value.
                         if (kv.value_ptr.* != .object) return error.UnexpectedToken;
                         if (kv.value_ptr.*.object.count() != 0) return error.UnexpectedToken;
-                        return @unionInit(T, u_field.name, {});
+                        return @unionInit(T, u_field_name, {});
                     }
                     // Recurse.
-                    return @unionInit(T, u_field.name, try innerParseFromValue(u_field.type, allocator, kv.value_ptr.*, options));
+                    return @unionInit(T, u_field_name, try innerParseFromValue(u_field_type, allocator, kv.value_ptr.*, options));
                 }
             }
             // Didn't match anything.
@@ -632,11 +638,11 @@ pub fn innerParseFromValue(
         .@"struct" => |structInfo| {
             if (structInfo.is_tuple) {
                 if (source != .array) return error.UnexpectedToken;
-                if (source.array.items.len != structInfo.fields.len) return error.UnexpectedToken;
+                if (source.array.items.len != structInfo.field_names.len) return error.UnexpectedToken;
 
                 var r: T = undefined;
-                inline for (0..structInfo.fields.len, source.array.items) |i, item| {
-                    r[i] = try innerParseFromValue(structInfo.fields[i].type, allocator, item, options);
+                inline for (0..structInfo.field_names.len, source.array.items) |i, item| {
+                    r[i] = try innerParseFromValue(structInfo.field_types[i], allocator, item, options);
                 }
 
                 return r;
@@ -649,17 +655,22 @@ pub fn innerParseFromValue(
             if (source != .object) return error.UnexpectedToken;
 
             var r: T = undefined;
-            var fields_seen = [_]bool{false} ** structInfo.fields.len;
+            var fields_seen: [structInfo.field_names.len]bool = @splat(false);
 
             var it = source.object.iterator();
             while (it.next()) |kv| {
                 const field_name = kv.key_ptr.*;
 
-                inline for (structInfo.fields, 0..) |field, i| {
-                    if (field.is_comptime) @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ field.name);
-                    if (std.mem.eql(u8, field.name, field_name)) {
+                inline for (
+                    structInfo.field_names,
+                    structInfo.field_types,
+                    structInfo.field_attrs,
+                    0..,
+                ) |f_name, f_type, f_attrs, i| {
+                    if (f_attrs.@"comptime") @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ f_name);
+                    if (std.mem.eql(u8, f_name, field_name)) {
                         assert(!fields_seen[i]); // Can't have duplicate keys in a Value.object.
-                        @field(r, field.name) = try innerParseFromValue(field.type, allocator, kv.value_ptr.*, options);
+                        @field(r, f_name) = try innerParseFromValue(f_type, allocator, kv.value_ptr.*, options);
                         fields_seen[i] = true;
                         break;
                     }
@@ -782,11 +793,17 @@ fn sliceToEnum(comptime T: type, slice: []const u8) !T {
     return std.enums.fromInt(T, n) orelse return error.InvalidEnumTag;
 }
 
-fn fillDefaultStructValues(comptime T: type, r: *T, fields_seen: *[@typeInfo(T).@"struct".fields.len]bool) !void {
-    inline for (@typeInfo(T).@"struct".fields, 0..) |field, i| {
+fn fillDefaultStructValues(comptime T: type, r: *T, fields_seen: *[@typeInfo(T).@"struct".field_names.len]bool) !void {
+    const info = @typeInfo(T).@"struct";
+    inline for (
+        info.field_names,
+        info.field_types,
+        info.field_attrs,
+        0..,
+    ) |field_name, field_type, field_attrs, i| {
         if (!fields_seen[i]) {
-            if (field.defaultValue()) |default| {
-                @field(r, field.name) = default;
+            if (field_attrs.defaultValue(field_type)) |default| {
+                @field(r, field_name) = default;
             } else {
                 return error.MissingField;
             }

package/std/json.zig

@@ -1,7 +1,7 @@
 //! JSON parsing and stringification conforming to RFC 8259. https://datatracker.ietf.org/doc/html/rfc8259
 //!
 //! The low-level `Scanner` API produces `Token`s from an input slice or successive slices of inputs,
-//! The `Reader` API connects a `std.Io.GenericReader` to a `Scanner`.
+//! The `Reader` API connects a `std.Io.Reader` to a `Scanner`.
 //!
 //! The high-level `parseFromSlice` and `parseFromTokenSource` deserialize a JSON document into a Zig type.
 //! Parse into a dynamically-typed `Value` to load any JSON value for runtime inspection.

package/std/{builtin → lang}/assembly.zig

@@ -1553,6 +1553,77 @@ pub const Clobbers = switch (@import("builtin").cpu.arch) {
         r14: bool = false,
         r15: bool = false,
     },
+    .m88k => packed struct {
+        /// Whether the inline assembly code may perform stores to memory
+        /// addresses other than those derived from input pointer provenance.
+        memory: bool = false,
+
+        r0: bool = false,
+        r1: bool = false,
+        r2: bool = false,
+        r3: bool = false,
+        r4: bool = false,
+        r5: bool = false,
+        r6: bool = false,
+        r7: bool = false,
+        r8: bool = false,
+        r9: bool = false,
+        r10: bool = false,
+        r11: bool = false,
+        r12: bool = false,
+        r13: bool = false,
+        r14: bool = false,
+        r15: bool = false,
+        r16: bool = false,
+        r17: bool = false,
+        r18: bool = false,
+        r19: bool = false,
+        r20: bool = false,
+        r21: bool = false,
+        r22: bool = false,
+        r23: bool = false,
+        r24: bool = false,
+        r25: bool = false,
+        r26: bool = false,
+        r27: bool = false,
+        r28: bool = false,
+        r29: bool = false,
+        r30: bool = false,
+        r31: bool = false,
+
+        x0: bool = false,
+        x1: bool = false,
+        x2: bool = false,
+        x3: bool = false,
+        x4: bool = false,
+        x5: bool = false,
+        x6: bool = false,
+        x7: bool = false,
+        x8: bool = false,
+        x9: bool = false,
+        x10: bool = false,
+        x11: bool = false,
+        x12: bool = false,
+        x13: bool = false,
+        x14: bool = false,
+        x15: bool = false,
+        x16: bool = false,
+        x17: bool = false,
+        x18: bool = false,
+        x19: bool = false,
+        x20: bool = false,
+        x21: bool = false,
+        x22: bool = false,
+        x23: bool = false,
+        x24: bool = false,
+        x25: bool = false,
+        x26: bool = false,
+        x27: bool = false,
+        x28: bool = false,
+        x29: bool = false,
+        x30: bool = false,
+        x31: bool = false,
+    },
     .m68k => packed struct {
         /// Whether the inline assembly code may perform stores to memory
         /// addresses other than those derived from input pointer provenance.

package/std/{builtin.zig → lang.zig}

@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 const std = @import("std.zig");
 const root = @import("root");
 
-pub const assembly = @import("builtin/assembly.zig");
+pub const assembly = @import("lang/assembly.zig");
 
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
@@ -93,7 +93,7 @@ pub const AtomicRmwOp = 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 CodeModel = enum {
+pub const CodeModel = enum(u4) {
     default,
     extreme,
     kernel,
@@ -292,6 +292,8 @@ pub const CallingConvention = union(enum(u8)) {
     m68k_rtd: CommonOptions,
     m68k_interrupt: CommonOptions,
 
+    m88k_sysv: CommonOptions,
+
     /// The standard `microblaze`/`microblazeel` calling convention.
     microblaze_std: CommonOptions,
     microblaze_interrupt: MicroblazeInterruptOptions,
@@ -594,13 +596,8 @@ pub const Type = union(enum) {
     /// therefore must be kept in sync with the compiler implementation.
     pub const Pointer = struct {
         size: Size,
-        is_const: bool,
-        is_volatile: bool,
-        /// `null` means implicit alignment, which is equivalent to `@alignOf(child)`.
-        alignment: ?usize,
-        address_space: AddressSpace,
+        attrs: Attributes,
         child: type,
-        is_allowzero: bool,
 
         /// The type of the sentinel is the element type of the pointer, which is
         /// the value of the `child` field in this struct. However there is no way
@@ -665,44 +662,40 @@ 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 StructField = struct {
-        name: [:0]const u8,
-        type: type,
-        /// The type of the default value is the type of this struct field, which
-        /// is the value of the `type` field in this struct. However there is no
-        /// way to refer to that type here, so we use `*const anyopaque`.
-        /// See also: `defaultValue`.
-        default_value_ptr: ?*const anyopaque,
-        is_comptime: bool,
-        /// `null` means the field alignment was not explicitly specified. The
-        /// field will still be aligned to at least `@alignOf` its `type`.
-        alignment: ?usize,
-
-        /// Loads the field's default value from `default_value_ptr`.
-        /// Returns `null` if the field has no default value.
-        pub inline fn defaultValue(comptime sf: StructField) ?sf.type {
-            const dp: *const sf.type = @ptrCast(@alignCast(sf.default_value_ptr orelse return null));
-            return dp.*;
-        }
+    pub const Struct = struct {
+        is_tuple: bool,
+        layout: ContainerLayout,
+        /// Always `null` if `layout != .@"packed"`.
+        backing_integer: ?type,
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
-        pub const Attributes = struct {
+        field_names: []const [:0]const u8,
+        /// Guaranteed to have the same length as `field_names`.
+        field_types: []const type,
+        /// Guaranteed to have the same length as `field_names`.
+        field_attrs: []const FieldAttributes,
+
+        decl_names: []const [:0]const u8,
+
+        pub const FieldAttributes = struct {
             @"comptime": bool = false,
+            /// `null` means the field alignment is not explicitly specified. The field will still
+            /// be aligned to at least `@alignOf` the field type.
             @"align": ?usize = null,
+            /// The type of the default value is the type of this struct field. However, that type
+            /// is not known here, so we use a type-erased pointer instead, which must be cast to
+            /// a pointer to the field type.
+            ///
+            /// See also: `defaultValue`.
             default_value_ptr: ?*const anyopaque = null,
-        };
-    };
 
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const Struct = struct {
-        layout: ContainerLayout,
-        /// Only valid if layout is .@"packed"
-        backing_integer: ?type = null,
-        fields: []const StructField,
-        decls: []const Declaration,
-        is_tuple: bool,
+            /// Loads the field's default value from `default_value_ptr`.
+            /// `FieldType` must exactly match the corresponding element of `Struct.field_types`.
+            /// Returns `null` if the field has no default value.
+            pub inline fn defaultValue(comptime attrs: FieldAttributes, comptime FieldType: type) ?FieldType {
+                const dp: *const FieldType = @ptrCast(@alignCast(attrs.default_value_ptr orelse return null));
+                return dp.*;
+            }
+        };
     };
 
     /// This data structure is used by the Zig language code generation and
@@ -720,48 +713,25 @@ 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 Error = struct {
-        name: [:0]const u8,
-    };
-
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const ErrorSet = ?[]const Error;
-
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const EnumField = struct {
-        name: [:0]const u8,
-        value: comptime_int,
+    pub const ErrorSet = struct {
+        error_names: ?[]const [:0]const u8,
     };
 
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
     pub const Enum = struct {
         tag_type: type,
-        fields: []const EnumField,
-        decls: []const Declaration,
-        is_exhaustive: bool,
+        mode: Mode,
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
-        pub const Mode = enum { exhaustive, nonexhaustive };
-    };
+        field_names: []const [:0]const u8,
+        /// Guaranteed to have the same length as `field_names`.
+        field_values: []const comptime_int,
 
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const UnionField = struct {
-        name: [:0]const u8,
-        type: type,
-        /// `null` means the field alignment was not explicitly specified. The
-        /// field will still be aligned to at least `@alignOf` its `type`.
-        alignment: ?usize,
+        decl_names: []const [:0]const u8,
 
         /// This data structure is used by the Zig language code generation and
         /// therefore must be kept in sync with the compiler implementation.
-        pub const Attributes = struct {
-            @"align": ?usize = null,
-        };
+        pub const Mode = enum { exhaustive, nonexhaustive };
     };
 
     /// This data structure is used by the Zig language code generation and
@@ -769,36 +739,42 @@ pub const Type = union(enum) {
     pub const Union = struct {
         layout: ContainerLayout,
         tag_type: ?type,
-        fields: []const UnionField,
-        decls: []const Declaration,
+        /// Always `null` if `layout != .@"packed"`.
+        backing_integer: ?type,
+
+        field_names: []const [:0]const u8,
+        /// Guaranteed to have the same length as `field_names`.
+        field_types: []const type,
+        /// Guaranteed to have the same length as `field_names`.
+        field_attrs: []const FieldAttributes,
+
+        decl_names: []const [:0]const u8,
+
+        pub const FieldAttributes = struct {
+            /// `null` means the field alignment is not explicitly specified. The field will still
+            /// be aligned to at least `@alignOf` the field type.
+            @"align": ?usize = null,
+        };
     };
 
     /// This data structure is used by the Zig language code generation and
     /// therefore must be kept in sync with the compiler implementation.
     pub const Fn = struct {
-        calling_convention: CallingConvention,
+        attrs: Attributes,
         is_generic: bool,
-        is_var_args: bool,
-        /// TODO change the language spec to make this not optional.
+        /// `null` means the return type is generic, i.e. it depends on a function argument.
         return_type: ?type,
-        params: []const Param,
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
-        pub const Param = struct {
-            is_generic: bool,
-            is_noalias: bool,
-            type: ?type,
-
-            /// This data structure is used by the Zig language code generation and
-            /// therefore must be kept in sync with the compiler implementation.
-            pub const Attributes = struct {
-                @"noalias": bool = false,
-            };
+        /// A `null` element represents either an `anytype` parameter, or a parameter with a generic
+        /// type, i.e. where the type depends on a previous function argument.
+        param_types: []const ?type,
+        /// Guaranteed to have the same length as `param_types`.
+        param_attrs: []const ParamAttributes,
+
+        pub const ParamAttributes = struct {
+            @"noalias": bool = false,
         };
 
-        /// This data structure is used by the Zig language code generation and
-        /// therefore must be kept in sync with the compiler implementation.
         pub const Attributes = struct {
             @"callconv": CallingConvention = .auto,
             varargs: bool = false,
@@ -808,7 +784,7 @@ 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 Opaque = struct {
-        decls: []const Declaration,
+        decl_names: []const [:0]const u8,
     };
 
     /// This data structure is used by the Zig language code generation and
@@ -829,12 +805,6 @@ pub const Type = union(enum) {
         len: comptime_int,
         child: type,
     };
-
-    /// This data structure is used by the Zig language code generation and
-    /// therefore must be kept in sync with the compiler implementation.
-    pub const Declaration = struct {
-        name: [:0]const u8,
-    };
 };
 
 /// This data structure is used by the Zig language code generation and
@@ -871,7 +841,7 @@ pub const OutputMode = 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 LinkMode = enum {
+pub const LinkMode = enum(u1) {
     static,
     dynamic,
 };

package/std/leb128.zig

@@ -9,7 +9,7 @@ const testing = std.testing;
 /// An example use case of this is in emitting DWARF info where one wants to make a ULEB128 field
 /// "relocatable", meaning that it becomes possible to later go back and patch the number to be a
 /// different value without shifting all the following code.
-pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: std.meta.Int(.unsigned, l * 7)) void {
+pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.unsigned, l * 7)) void {
     writeUnsignedExtended(ptr, int);
 }
 
@@ -65,7 +65,7 @@ test writeUnsignedFixed {
 /// An example use case of this is in emitting DWARF info where one wants to make a ILEB128 field
 /// "relocatable", meaning that it becomes possible to later go back and patch the number to be a
 /// different value without shifting all the following code.
-pub fn writeSignedFixed(comptime l: usize, ptr: *[l]u8, int: std.meta.Int(.signed, l * 7)) void {
+pub fn writeSignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.signed, l * 7)) void {
     const T = @TypeOf(int);
     const U = if (@typeInfo(T).int.bits < 8) u8 else T;
     var value: U = @intCast(int);

package/std/math/acos.zig

@@ -337,6 +337,8 @@ fn acosBinary128(x: f128) f128 {
 }
 
 test "acosBinary16.special" {
+    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
+
     try testing.expectApproxEqAbs(0x1.92p0, acosBinary16(0x0p+0), math.floatEpsAt(f16, 0x1.92p0));
     try testing.expectApproxEqAbs(0x1.92p1, acosBinary16(-0x1p+0), math.floatEpsAt(f16, 0x1.92p1));
     try testing.expectEqual(0x0p+0, acosBinary16(0x1p+0));
@@ -348,6 +350,8 @@ test "acosBinary16.special" {
 }
 
 test "acosBinary16" {
+    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
+
     try testing.expectApproxEqAbs(0x1.834p0, acosBinary16(0x1.db4p-5), math.floatEpsAt(f16, 0x1.834p0));
     try testing.expectApproxEqAbs(0x1.d48p0, acosBinary16(-0x1.068p-2), math.floatEpsAt(f16, 0x1.d48p0));
     try testing.expectApproxEqAbs(0x1.b7cp0, acosBinary16(-0x1.2c4p-3), math.floatEpsAt(f16, 0x1.b7cp0));
@@ -444,6 +448,8 @@ test "acosBinary128.special" {
 }
 
 test "acosBinary128" {
+    if (builtin.cpu.arch.isSPARC()) return error.SkipZigTest;
+
     try testing.expectApproxEqAbs(0x1.250e9a58f049eeafa99db4360c88p1, acosBinary128(-0x1.511bdb99a3c4373bedf834ef4f68p-1), math.floatEpsAt(f128, 0x1.250e9a58f049eeafa99db4360c88p1));
     try testing.expectApproxEqAbs(0x1.2786664b1c676c99437b68590004p1, acosBinary128(-0x1.5879cc3ad6dfd2a52e9891c69808p-1), math.floatEpsAt(f128, 0x1.2786664b1c676c99437b68590004p1));
     try testing.expectApproxEqAbs(0x1.cb190cd361c7c03a09c470b4caebp-1, acosBinary128(0x1.3f988ba64a7eb97a751c5f0b3077p-1), math.floatEpsAt(f128, 0x1.cb190cd361c7c03a09c470b4caebp-1));

package/std/math/asin.zig

@@ -326,6 +326,8 @@ fn asinBinary128(x: f128) f128 {
 }
 
 test "asinBinary16.special" {
+    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
+
     try testing.expectApproxEqAbs(0x1.92p0, asinBinary16(0x1p+0), math.floatEpsAt(f16, 0x1.92p0));
     try testing.expectApproxEqAbs(-0x1.92p0, asinBinary16(-0x1p+0), math.floatEpsAt(f16, -0x1.92p0));
     try testing.expectEqual(0x0p+0, asinBinary16(0x0p+0));
@@ -338,6 +340,8 @@ test "asinBinary16.special" {
 }
 
 test "asinBinary16" {
+    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
+
     try testing.expectApproxEqAbs(-0x1.e4cp-6, asinBinary16(-0x1.e4cp-6), math.floatEpsAt(f16, -0x1.e4cp-6));
     try testing.expectApproxEqAbs(0x1.2a8p0, asinBinary16(0x1.d68p-1), math.floatEpsAt(f16, 0x1.2a8p0));
     try testing.expectApproxEqAbs(-0x1.eep-1, asinBinary16(-0x1.a4cp-1), math.floatEpsAt(f16, -0x1.eep-1));
@@ -438,6 +442,8 @@ test "asinBinary128.special" {
 }
 
 test "asinBinary128" {
+    if (builtin.cpu.arch.isSPARC()) return error.SkipZigTest;
+
     try testing.expectApproxEqAbs(0x1.87e9c740d7837f8e8fa667988fbep-3, asinBinary128(0x1.85868ce287ca0196b01c25fec5ffp-3), math.floatEpsAt(f128, 0x1.87e9c740d7837f8e8fa667988fbep-3));
     try testing.expectApproxEqAbs(0x1.bd11a474e864213b48e0f005f1f4p-1, asinBinary128(0x1.8718d6d30b4daed08d04ef59f478p-1), math.floatEpsAt(f128, 0x1.bd11a474e864213b48e0f005f1f4p-1));
     try testing.expectApproxEqAbs(0x1.20b56f8b42649fe72d1f8d68a378p-1, asinBinary128(0x1.11a67640cd7f0ba5d5e362f3abfap-1), math.floatEpsAt(f128, 0x1.20b56f8b42649fe72d1f8d68a378p-1));

package/std/math/atan.zig

@@ -11,6 +11,7 @@
 // https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/atanf.c
 // https://github.com/ARM-software/optimized-routines/blob/master/math/aarch64/advsimd/atan.c
 
+const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const mem = std.mem;
@@ -480,6 +481,8 @@ fn atanBinary128(x: f128) f128 {
 }
 
 test "atanBinary16.special" {
+    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
+
     try testing.expectEqual(0x0p+0, atanBinary16(0x0p+0));
     try testing.expectEqual(-0x0p+0, atanBinary16(-0x0p+0));
     try testing.expectApproxEqAbs(0x1.92p-1, atanBinary16(0x1p+0), math.floatEpsAt(f16, 0x1.92p-1));
@@ -490,6 +493,8 @@ test "atanBinary16.special" {
 }
 
 test "atanBinary16" {
+    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
+
     try testing.expectApproxEqAbs(-0x1.74cp-2, atanBinary16(-0x1.864p-2), math.floatEpsAt(f16, -0x1.74cp-2));
     try testing.expectApproxEqAbs(-0x1.374p0, atanBinary16(-0x1.59cp1), math.floatEpsAt(f16, -0x1.374p0));
     try testing.expectApproxEqAbs(-0x1.11cp0, atanBinary16(-0x1.d2cp0), math.floatEpsAt(f16, -0x1.11cp0));