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

package/std/os/linux.zig

@@ -35,10 +35,12 @@ const arch_bits = switch (native_arch) {
     .alpha => @import("linux/alpha.zig"),
     .arc, .arceb => @import("linux/arc.zig"),
     .arm, .armeb, .thumb, .thumbeb => @import("linux/arm.zig"),
+    .csky => @import("linux/csky.zig"),
     .hexagon => @import("linux/hexagon.zig"),
     .loongarch32 => @import("linux/loongarch32.zig"),
     .loongarch64 => @import("linux/loongarch64.zig"),
     .m68k => @import("linux/m68k.zig"),
+    .microblaze, .microblazeel => @import("linux/microblaze.zig"),
     .mips, .mipsel => @import("linux/mips.zig"),
     .mips64, .mips64el => switch (builtin.abi) {
         .gnuabin32, .muslabin32 => @import("linux/mipsn32.zig"),
@@ -50,6 +52,8 @@ const arch_bits = switch (native_arch) {
     .riscv32 => @import("linux/riscv32.zig"),
     .riscv64 => @import("linux/riscv64.zig"),
     .s390x => @import("linux/s390x.zig"),
+    .sh, .sheb => @import("linux/sh.zig"),
+    .sparc => @import("linux/sparc.zig"),
     .sparc64 => @import("linux/sparc64.zig"),
     .x86 => @import("linux/x86.zig"),
     .x86_64 => switch (builtin.abi) {
@@ -105,7 +109,7 @@ pub const user_desc = arch_bits.user_desc;
 
 pub const blkcnt_t = u64;
 pub const blksize_t = u32;
-pub const dev_t = u64;
+pub const dev_t = u32;
 pub const ino_t = u64;
 pub const mode_t = u32;
 pub const nlink_t = u32;
@@ -131,9 +135,12 @@ pub const SYS = switch (native_arch) {
     .arm, .armeb, .thumb, .thumbeb => syscalls.Arm,
     .csky => syscalls.CSky,
     .hexagon => syscalls.Hexagon,
+    .hppa => syscalls.Hppa,
+    .hppa64 => syscalls.Hppa64,
     .loongarch32 => syscalls.LoongArch32,
     .loongarch64 => syscalls.LoongArch64,
     .m68k => syscalls.M68k,
+    .microblaze, .microblazeel => syscalls.Microblaze,
     .mips, .mipsel => syscalls.MipsO32,
     .mips64, .mips64el => switch (builtin.abi) {
         .gnuabin32, .muslabin32 => syscalls.MipsN32,
@@ -145,6 +152,7 @@ pub const SYS = switch (native_arch) {
     .riscv32 => syscalls.RiscV32,
     .riscv64 => syscalls.RiscV64,
     .s390x => syscalls.S390x,
+    .sh, .sheb => syscalls.Sh,
     .sparc => syscalls.Sparc,
     .sparc64 => syscalls.Sparc64,
     .x86 => syscalls.X86,
@@ -222,7 +230,7 @@ pub const MAP = switch (native_arch) {
         UNINITIALIZED: bool = false,
         _: u5 = 0,
     },
-    .sparc64 => packed struct(u32) {
+    .sparc, .sparc64 => packed struct(u32) {
         TYPE: MAP_TYPE,
         FIXED: bool = false,
         ANONYMOUS: bool = false,
@@ -288,10 +296,15 @@ pub const MAP = switch (native_arch) {
     },
     .arc,
     .arceb,
+    .csky,
     .hexagon,
     .m68k,
+    .microblaze,
+    .microblazeel,
     .or1k,
     .s390x,
+    .sh,
+    .sheb,
     => packed struct(u32) {
         TYPE: MAP_TYPE,
         FIXED: bool = false,
@@ -442,7 +455,7 @@ pub const O = switch (native_arch) {
         TMPFILE: bool = false,
         _23: u9 = 0,
     },
-    .sparc64 => packed struct(u32) {
+    .sparc, .sparc64 => packed struct(u32) {
         ACCMODE: ACCMODE = .RDONLY,
         _2: u1 = 0,
         APPEND: bool = false,
@@ -518,9 +531,14 @@ pub const O = switch (native_arch) {
     },
     .arc,
     .arceb,
+    .csky,
     .hexagon,
+    .microblaze,
+    .microblazeel,
     .or1k,
     .s390x,
+    .sh,
+    .sheb,
     .xtensa,
     .xtensaeb,
     => packed struct(u32) {
@@ -1991,7 +2009,7 @@ pub const F = struct {
                 const SETLKW = 7;
             },
         },
-        .alpha, .sparc64 => struct {
+        .alpha, .sparc, .sparc64 => struct {
             const GETLK = 7;
             const SETLK = 8;
             const SETLKW = 9;
@@ -6582,7 +6600,7 @@ const TFD_TIMER = packed struct(u32) {
 };
 
 pub const TFD = switch (native_arch) {
-    .sparc64 => packed struct(u32) {
+    .sparc, .sparc64 => packed struct(u32) {
         _0: u14 = 0,
         NONBLOCK: bool = false,
         _15: u7 = 0,
@@ -6633,7 +6651,7 @@ pub const k_sigaction = switch (native_arch) {
         handler: k_sigaction_funcs.handler,
         mask: sigset_t,
     },
-    .hexagon, .loongarch32, .loongarch64, .or1k, .riscv32, .riscv64 => extern struct {
+    .csky, .hexagon, .loongarch32, .loongarch64, .or1k, .riscv32, .riscv64 => extern struct {
         handler: k_sigaction_funcs.handler,
         flags: c_ulong,
         mask: sigset_t,
@@ -6974,12 +6992,16 @@ pub const MINSIGSTKSZ = switch (native_arch) {
     .mipsel,
     .mips64,
     .mips64el,
+    .microblaze,
+    .microblazeel,
     .or1k,
     .powerpc,
     .powerpcle,
     .riscv32,
     .riscv64,
     .s390x,
+    .sh,
+    .sheb,
     .thumb,
     .thumbeb,
     .x86,
@@ -7012,12 +7034,16 @@ pub const SIGSTKSZ = switch (native_arch) {
     .mipsel,
     .mips64,
     .mips64el,
+    .microblaze,
+    .microblazeel,
     .or1k,
     .powerpc,
     .powerpcle,
     .riscv32,
     .riscv64,
     .s390x,
+    .sh,
+    .sheb,
     .thumb,
     .thumbeb,
     .x86,
@@ -8549,7 +8575,7 @@ pub const V = if (is_mips) enum(u32) {
     STOP = 14,
     LNEXT = 15,
     DISCARD = 16,
-} else if (arch_bits == .alpha) enum(u32) {
+} else if (native_arch == .alpha) enum(u32) {
     EOF = 0,
     EOL = 1,
     EOL2 = 2,
@@ -10715,6 +10741,7 @@ pub const AUDIT = struct {
             .loongarch32 => .LOONGARCH32,
             .loongarch64 => .LOONGARCH64,
             .m68k => .M68K,
+            .microblaze, .microblazeel => .MICROBLAZE,
             .mips => .MIPS,
             .mipsel => .MIPSEL,
             .mips64 => switch (native_abi) {
@@ -10731,9 +10758,11 @@ pub const AUDIT = struct {
             .powerpc64le => .PPC64LE,
             .riscv32 => .RISCV32,
             .riscv64 => .RISCV64,
+            .s390x => .S390X,
+            .sh => .SHEL,
+            .sheb => .SH,
             .sparc => .SPARC,
             .sparc64 => .SPARC64,
-            .s390x => .S390X,
             .x86 => .I386,
             .x86_64 => .X86_64,
             .xtensa => .XTENSA,

package/std/os/uefi/protocol/file.zig

@@ -125,6 +125,22 @@ pub const File = extern struct {
         }
     }
 
+    pub fn readSize(self: *File) ReadError!usize {
+        const zerobuf: [0]u8 = undefined;
+        var size: usize = 0;
+        switch (self._read(self, &size, &zerobuf)) {
+            .success, .buffer_too_small => return size,
+            .no_media => return error.NoMedia,
+            .device_error => return error.DeviceError,
+            .volume_corrupted => return error.VolumeCorrupted,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
+    }
+
+    /// If `self` is a directory entry and `buffer` is too small to contain the
+    /// next entry, this function returns `Error.BufferTooSmall`. You can call
+    /// `readSize` before or after to determine how big the buffer should be to
+    /// call this function.
     pub fn read(self: *File, buffer: []u8) ReadError!usize {
         var size: usize = buffer.len;
         switch (self._read(self, &size, buffer.ptr)) {

package/std/os.zig

@@ -15,19 +15,9 @@ pub fn targetRequiresLibC(target: *const std.Target) bool {
     if (target.requiresLibC()) return true;
     return switch (target.os.tag) {
         .linux => switch (target.cpu.arch) {
-            // https://codeberg.org/ziglang/zig/issues/30942
-            .csky,
             // https://codeberg.org/ziglang/zig/issues/30943
             .hppa,
             .hppa64,
-            // https://codeberg.org/ziglang/zig/issues/30944
-            .microblaze,
-            .microblazeel,
-            // https://codeberg.org/ziglang/zig/issues/30946
-            .sh,
-            .sheb,
-            // https://codeberg.org/ziglang/zig/issues/30945
-            .sparc,
             => true,
             else => false,
         },

package/std/start.zig

@@ -170,7 +170,7 @@ fn _start() callconv(.naked) noreturn {
             .loongarch32, .loongarch64 => ".cfi_undefined 1",
             .m68k => ".cfi_undefined %%pc",
             .m88k => ".cfi_undefined %%r1",
-            .microblaze, .microblazeel => ".cfi_undefined r15",
+            .microblaze, .microblazeel => "", // No CFI support.
             .mips, .mipsel, .mips64, .mips64el => ".cfi_undefined $ra",
             .or1k => ".cfi_undefined r9",
             .powerpc, .powerpcle, .powerpc64, .powerpc64le => ".cfi_undefined lr",
@@ -345,11 +345,11 @@ fn _start() callconv(.naked) noreturn {
             ,
             .microblaze, .microblazeel =>
             // r1 = SP, r15 = LR, r19 = FP, r20 = GP
-            \\ ori r15, r0, r0
-            \\ ori r19, r0, r0
+            \\ ori r15, r0, 0
+            \\ ori r19, r0, 0
             \\ mfs r20, rpc
-            \\ addik r20, r20, _GLOBAL_OFFSET_TABLE_ + 8
-            \\ ori r5, r1, r0
+            \\ addi r20, r20, _GLOBAL_OFFSET_TABLE_ + 8
+            \\ ori r5, r1, 0
             \\ andi r1, r1, -4
             \\ brlid r15, %[posixCallMainAndExit]
             ,

package/std/static_string_map.zig

@@ -100,6 +100,52 @@ pub fn StaticStringMapWithEql(
             }
         }
 
+        /// Returns a map backed by static, comptime allocated memory.
+        ///
+        /// `V` must be an enum. The enum's tag names will be used as the keys.
+        pub inline fn initEnum() Self {
+            comptime {
+                var self: Self = .{};
+
+                const field_names = @typeInfo(V).@"enum".field_names;
+                if (field_names.len == 0) return self;
+
+                // Since the KVs are sorted, a linearly-growing bound will never
+                // be sufficient for extreme cases. So we grow proportional to
+                // N*log2(N).
+                @setEvalBranchQuota(10 * field_names.len * std.math.log2_int_ceil(usize, field_names.len));
+
+                var sorted_keys: [field_names.len][]const u8 = field_names[0..field_names.len].*;
+                var sorted_vals: [field_names.len]V = undefined;
+                for (&sorted_vals, @typeInfo(V).@"enum".field_values) |*x, i| x.* = @enumFromInt(i);
+
+                for (field_names) |field_name| {
+                    self.min_len = @min(self.min_len, field_name.len);
+                    self.max_len = @max(self.max_len, field_name.len);
+                }
+
+                mem.sortUnstableContext(0, sorted_keys.len, SortContext{
+                    .keys = &sorted_keys,
+                    .vals = &sorted_vals,
+                });
+
+                const final_keys = sorted_keys;
+                const final_vals = sorted_vals;
+                self.kvs = &.{
+                    .keys = &final_keys,
+                    .values = &final_vals,
+                    .len = @intCast(field_names.len),
+                };
+
+                var len_indexes: [self.max_len + 1]u32 = undefined;
+                self.initLenIndexes(&len_indexes);
+                const final_len_indexes = len_indexes;
+                self.len_indexes = &final_len_indexes;
+                self.len_indexes_len = @intCast(len_indexes.len);
+                return self;
+            }
+        }
+
         /// Returns a map backed by memory allocated with `allocator`.
         ///
         /// Handles `kvs_list` the same way as `initComptime()`.
@@ -195,7 +241,7 @@ pub fn StaticStringMapWithEql(
             return self.kvs.values[self.getIndex(str) orelse return null];
         }
 
-        pub fn getIndex(self: Self, str: []const u8) ?usize {
+        fn getIndex(self: Self, str: []const u8) ?usize {
             const kvs = self.kvs.*;
             if (kvs.len == 0)
                 return null;
@@ -536,3 +582,15 @@ test "sorting kvs doesn't exceed eval branch quota" {
     });
     try testing.expectEqual(1, TypeToByteSizeLUT.get("t1"));
 }
+
+test "initEnum" {
+    const UnsortedEnum = enum { BB, A, CCC, DDD };
+    const map = StaticStringMap(UnsortedEnum).initEnum();
+    try testing.expect(map.has("A"));
+    try testing.expect(!map.has("a"));
+    try testing.expectEqual(.BB, map.get("BB"));
+    try testing.expectEqual(.A, map.get("A"));
+    try testing.expectEqual(.CCC, map.get("CCC"));
+    try testing.expectEqual(.DDD, map.get("DDD"));
+    try testing.expectEqual(null, map.getIndex("F"));
+}

package/std/zig/LibCInstallation.zig

@@ -421,7 +421,7 @@ fn findNativeCrtDirWindows(
     const arch_sub_dir = switch (target.cpu.arch) {
         .x86 => "x86",
         .x86_64 => "x64",
-        .arm, .armeb => "arm",
+        .thumb => "arm",
         .aarch64 => "arm64",
         else => return error.UnsupportedArchitecture,
     };
@@ -488,7 +488,7 @@ fn findNativeKernel32LibDir(
     const arch_sub_dir = switch (args.target.cpu.arch) {
         .x86 => "x86",
         .x86_64 => "x64",
-        .arm, .armeb => "arm",
+        .thumb => "arm",
         .aarch64 => "arm64",
         else => return error.UnsupportedArchitecture,
     };

package/std/zig/Parse.zig

@@ -2947,7 +2947,7 @@ fn parseAddrSpace(p: *Parse) !?Node.Index {
 /// such as in the case of anytype and `...`. Caller must look for rparen to find
 /// out when there are no more param decls left.
 ///
-/// ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime / !KEYWORD_comptime) (IDENTIFIER COLON / !(IDENTIFIER_COLON)) ParamType
+/// ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime / !KEYWORD_comptime) (IDENTIFIER COLON / !(IDENTIFIER COLON)) ParamType
 ///
 /// ParamType
 ///     <- KEYWORD_anytype

package/std/zig/PkgConfig.zig

@@ -95,6 +95,7 @@ pub const Parsed = struct {
     cflags: []const []const u8,
     libs: []const []const u8,
     unknown_flags: []const []const u8,
+    pthread: bool,
 };
 
 pub const ParseError = Allocator.Error || error{InvalidPkgConfigOutput};
@@ -105,6 +106,7 @@ pub fn parse(arena: Allocator, stdout: []const u8) ParseError!Parsed {
     var zig_libs: std.ArrayList([]const u8) = .empty;
     var unknown_flags: std.ArrayList([]const u8) = .empty;
     var arg_it = mem.tokenizeAny(u8, stdout, " \r\n\t");
+    var pthread = false;
 
     while (arg_it.next()) |arg| {
         if (mem.eql(u8, arg, "-I")) {
@@ -129,6 +131,8 @@ pub fn parse(arena: Allocator, stdout: []const u8) ParseError!Parsed {
             try zig_cflags.append(arena, arg);
         } else if (mem.cutPrefix(u8, arg, "-Wl,-rpath,")) |rest| {
             try zig_cflags.appendSlice(arena, &.{ "-rpath", rest });
+        } else if (mem.eql(u8, arg, "-pthread")) {
+            pthread = true;
         } else {
             try unknown_flags.append(arena, arg);
         }
@@ -142,5 +146,6 @@ pub fn parse(arena: Allocator, stdout: []const u8) ParseError!Parsed {
         .cflags = zig_cflags.toOwnedSliceAssert(),
         .libs = zig_libs.toOwnedSliceAssert(),
         .unknown_flags = unknown_flags.toOwnedSliceAssert(),
+        .pthread = pthread,
     };
 }

package/std/zig/system/darwin/macos.zig

@@ -411,7 +411,7 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
 
     const current_arch = builtin.cpu.arch;
     switch (current_arch) {
-        .aarch64, .aarch64_be => {
+        .aarch64 => {
             const model = switch (cpu_family) {
                 .ARM_CYCLONE => &Target.aarch64.cpu.apple_a7,
                 .ARM_TYPHOON => &Target.aarch64.cpu.apple_a8,
@@ -420,17 +420,21 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
                 .ARM_MONSOON_MISTRAL => &Target.aarch64.cpu.apple_a11,
                 .ARM_VORTEX_TEMPEST => &Target.aarch64.cpu.apple_a12,
                 .ARM_LIGHTNING_THUNDER => &Target.aarch64.cpu.apple_a13,
-                .ARM_FIRESTORM_ICESTORM => &Target.aarch64.cpu.apple_m1, // a14
-                .ARM_BLIZZARD_AVALANCHE => &Target.aarch64.cpu.apple_m2, // a15
-                .ARM_EVEREST_SAWTOOTH => &Target.aarch64.cpu.apple_m3, // a16
+                .ARM_FIRESTORM_ICESTORM => &Target.aarch64.cpu.apple_a14,
+                .ARM_BLIZZARD_AVALANCHE => &Target.aarch64.cpu.apple_a15,
+                .ARM_EVEREST_SAWTOOTH => &Target.aarch64.cpu.apple_a16,
                 .ARM_IBIZA => &Target.aarch64.cpu.apple_m3, // base
                 .ARM_PALMA => &Target.aarch64.cpu.apple_m3, // max
                 .ARM_LOBOS => &Target.aarch64.cpu.apple_m3, // pro
-                .ARM_COLL => &Target.aarch64.cpu.apple_a17, // a17 pro
+                .ARM_COLL => &Target.aarch64.cpu.apple_a17, // pro
                 .ARM_DONAN => &Target.aarch64.cpu.apple_m4, // base
                 .ARM_BRAVA => &Target.aarch64.cpu.apple_m4, // pro/max
-                .ARM_TAHITI => &Target.aarch64.cpu.apple_m4, // a18 pro
-                .ARM_TUPAI => &Target.aarch64.cpu.apple_m4, // a18
+                .ARM_TAHITI => &Target.aarch64.cpu.apple_a18, // pro
+                .ARM_TUPAI => &Target.aarch64.cpu.apple_a18, // base
+                .ARM_HIDRA => &Target.aarch64.cpu.apple_m5, // base
+                .ARM_SOTRA => &Target.aarch64.cpu.apple_m5, // pro/max
+                .ARM_THERA => &Target.aarch64.cpu.apple_a19, // pro
+                .ARM_TILOS => &Target.aarch64.cpu.apple_a19, // base
                 else => return null,
             };
 

package/std/zig/system.zig

@@ -152,7 +152,7 @@ pub fn getExternalExecutor(io: Io, candidate: *const std.Target, options: GetExt
                         // TODO: Actually check the SuperH version.
                         .sh => "qemu-sh4",
                         .sheb => "qemu-sh4eb",
-                        .sparc => if (candidate.cpu.has(.sparc, .v8plus)) "qemu-sparc32plus" else "qemu-sparc",
+                        .sparc => "qemu-sparc32plus",
                         .thumb => "qemu-arm",
                         .thumbeb => "qemu-armeb",
                         else => "qemu-" ++ @tagName(t),

package/zig.h

@@ -11,8 +11,6 @@
 #elif defined(__GNUC__)
 #define zig_gcc
 #define zig_gnuc
-#elif defined(__IBMC__)
-#define zig_xlc
 #elif defined(__TINYC__)
 #define zig_tinyc
 #elif defined(__slimcc__)
@@ -28,8 +26,18 @@
 #define zig_arm
 #elif defined(__arm__)
 #define zig_arm
+#elif defined(__arc__)
+#define zig_arc
+#elif defined(__csky__)
+#define zig_csky
 #elif defined(__hexagon__)
 #define zig_hexagon
+#elif defined(__hppa__) && defined(_LP64)
+#define zig_hppa64
+#define zig_hppa
+#elif defined(__hppa__)
+#define zig_hppa32
+#define zig_hppa
 #elif defined(__kvx__)
 #define zig_kvx
 #elif defined(__loongarch32)
@@ -42,6 +50,8 @@
 #define zig_m68k
 #elif defined(__m88k__)
 #define zig_m88k
+#elif defined(__microblaze__)
+#define zig_microblaze
 #elif defined(__mips64)
 #define zig_mips64
 #define zig_mips
@@ -64,6 +74,8 @@
 #define zig_riscv
 #elif defined(__s390x__)
 #define zig_s390x
+#elif defined(__sh__)
+#define zig_sh
 #elif defined(__sparc__) && defined(__arch64__)
 #define zig_sparc64
 #define zig_sparc
@@ -100,32 +112,30 @@
 #define zig_big_endian 1
 #endif
 
-#if defined(__MACH__)
+#if defined(__APPLE__)
 #define zig_darwin
 #elif defined(__DragonFly__)
 #define zig_dragonfly
-#define zig_bsd
 #elif defined(__EMSCRIPTEN__)
 #define zig_emscripten
 #elif defined(__FreeBSD__)
 #define zig_freebsd
-#define zig_bsd
 #elif defined(__Fuchsia__)
 #define zig_fuchsia
 #elif defined(__HAIKU__)
 #define zig_haiku
 #elif defined(__gnu_hurd__)
 #define zig_hurd
+#elif defined(__illumos__)
+#define zig_illumos
 #elif defined(__linux__)
 #define zig_linux
 #elif defined(__NetBSD__)
 #define zig_netbsd
-#define zig_bsd
 #elif defined(__OpenBSD__)
 #define zig_openbsd
-#define zig_bsd
-#elif defined(__SVR4)
-#define zig_solaris
+#elif defined(__serenity__)
+#define zig_serenity
 #elif defined(__wasi__)
 #define zig_wasi
 #elif defined(_WIN32)
@@ -404,14 +414,22 @@
 #define zig_trap() __asm__ volatile("udf #0xfe")
 #elif defined(zig_arm) || defined(zig_aarch64)
 #define zig_trap() __asm__ volatile("udf #0xfdee")
+#elif defined(zig_arc)
+#define zig_trap() __asm__ volatile("unimp_s")
+#elif defined(zig_csky)
+#define zig_trap() __asm__ volatile(".word 0x3fff")
 #elif defined(zig_hexagon)
 #define zig_trap() __asm__ volatile("r27:26 = memd(#0xbadc0fee)")
+#elif defined(zig_hppa)
+#define zig_trap() __asm__ volatile("iitlbp %r0, (%sr0, %r0)")
 #elif defined(zig_kvx) || defined(zig_loongarch) || defined(zig_powerpc)
 #define zig_trap() __asm__ volatile(".word 0x0")
 #elif defined(zig_m68k)
 #define zig_trap() __asm__ volatile("illegal")
 #elif defined(zig_m88k)
 #define zig_trap() __asm__ volatile("tb0 0, %%r0, 511")
+#elif defined(zig_microblaze)
+#define zig_trap() __asm__ volatile("getd r0, r0")
 #elif defined(zig_mips)
 #define zig_trap() __asm__ volatile(".word 0x3d")
 #elif defined(zig_or1k)
@@ -420,6 +438,8 @@
 #define zig_trap() __asm__ volatile("unimp")
 #elif defined(zig_s390x)
 #define zig_trap() __asm__ volatile("j 0x2")
+#elif defined(zig_sh)
+#define zig_trap() __asm__ volatile(".word 0x0001")
 #elif defined(zig_sparc)
 #define zig_trap() __asm__ volatile("illtrap")
 #elif defined(zig_x86_16)
@@ -446,16 +466,22 @@
 
 #if defined(zig_alpha)
 #define zig_breakpoint() __asm__ volatile("call_pal 0x000080")
-#elif defined(zig_arm)
+#elif defined(zig_arm) || defined(zig_csky)
 #define zig_breakpoint() __asm__ volatile("bkpt #0x0")
 #elif defined(zig_aarch64)
 #define zig_breakpoint() __asm__ volatile("brk #0xf000")
+#elif defined(zig_arc)
+#define zig_breakpoint() __asm__ volatile("brk_s")
 #elif defined(zig_hexagon)
 #define zig_breakpoint() __asm__ volatile("brkpt")
+#elif defined(zig_hppa)
+#define zig_breakpoint() __asm__ volatile("break 0x04, 0x0008")
 #elif defined(zig_kvx) || defined(zig_loongarch)
 #define zig_breakpoint() __asm__ volatile("break 0x0")
 #elif defined(zig_m88k)
 #define zig_breakpoint() __asm__ volatile("illop1")
+#elif defined(zig_microblaze)
+#define zig_breakpoint() __asm__ volatile("brki r16, 0x0018")
 #elif defined(zig_mips)
 #define zig_breakpoint() __asm__ volatile("break")
 #elif defined(zig_or1k)
@@ -466,6 +492,8 @@
 #define zig_breakpoint() __asm__ volatile("ebreak")
 #elif defined(zig_s390x)
 #define zig_breakpoint() __asm__ volatile("j 0x6")
+#elif defined(zig_sh)
+#define zig_breakpoint() __asm__ volatile("trapa #0xc3")
 #elif defined(zig_sparc)
 #define zig_breakpoint() __asm__ volatile("ta 0x1")
 #elif defined(zig_x86)

package/libc/musl/src/math/i386/log1p.s

@@ -1,25 +0,0 @@
-.global log1p
-.type log1p,@function
-log1p:
-	mov 8(%esp),%eax
-	fldln2
-	and $0x7fffffff,%eax
-	fldl 4(%esp)
-	cmp $0x3fd28f00,%eax
-	ja 1f
-	cmp $0x00100000,%eax
-	jb 2f
-	fyl2xp1
-	fstpl 4(%esp)
-	fldl 4(%esp)
-	ret
-1:	fld1
-	faddp
-	fyl2x
-	fstpl 4(%esp)
-	fldl 4(%esp)
-	ret
-		# subnormal x, return x with underflow
-2:	fsts 4(%esp)
-	fstp %st(1)
-	ret

package/libc/musl/src/math/i386/log1pf.s

@@ -1,26 +0,0 @@
-.global log1pf
-.type log1pf,@function
-log1pf:
-	mov 4(%esp),%eax
-	fldln2
-	and $0x7fffffff,%eax
-	flds 4(%esp)
-	cmp $0x3e940000,%eax
-	ja 1f
-	cmp $0x00800000,%eax
-	jb 2f
-	fyl2xp1
-	fstps 4(%esp)
-	flds 4(%esp)
-	ret
-1:	fld1
-	faddp
-	fyl2x
-	fstps 4(%esp)
-	flds 4(%esp)
-	ret
-		# subnormal x, return x with underflow
-2:	fxch
-	fmul %st(1)
-	fstps 4(%esp)
-	ret