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

package/std/os/emscripten.zig

@@ -17,7 +17,7 @@ pub const CLOCK = linux.CLOCK;
 
 pub const CPU_SETSIZE = 128;
 pub const cpu_set_t = [CPU_SETSIZE / @sizeOf(usize)]usize;
-pub const cpu_count_t = std.meta.Int(.unsigned, std.math.log2(CPU_SETSIZE * 8));
+pub const cpu_count_t = @Int(.unsigned, std.math.log2(CPU_SETSIZE * 8));
 
 pub fn CPU_COUNT(set: cpu_set_t) cpu_count_t {
     var sum: cpu_count_t = 0;
@@ -373,7 +373,7 @@ pub const rusage = extern struct {
     nsignals: isize,
     nvcsw: isize,
     nivcsw: isize,
-    __reserved: [16]isize = [1]isize{0} ** 16,
+    __reserved: [16]isize = @splat(0),
 
     pub const SELF = 0;
     pub const CHILDREN = -1;
@@ -467,8 +467,8 @@ pub const SHUT = struct {
 pub const SIG = linux.SIG;
 
 pub const Sigaction = extern struct {
-    pub const handler_fn = *align(1) const fn (i32) callconv(.c) void;
-    pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.c) void;
+    pub const handler_fn = *align(1) const fn (SIG) callconv(.c) void;
+    pub const sigaction_fn = *const fn (SIG, *const siginfo_t, ?*anyopaque) callconv(.c) void;
 
     handler: extern union {
         handler: ?handler_fn,
@@ -481,10 +481,10 @@ pub const Sigaction = extern struct {
 
 pub const sigset_t = [1024 / 32]u32;
 pub fn sigemptyset() sigset_t {
-    return [_]u32{0} ** @typeInfo(sigset_t).array.len;
+    return @splat(0);
 }
 pub const siginfo_t = extern struct {
-    signo: i32,
+    signo: SIG,
     errno: i32,
     code: i32,
     fields: siginfo_fields_union,
@@ -882,6 +882,7 @@ pub extern "c" fn emscripten_hide_mouse() void;
 pub extern "c" fn emscripten_set_canvas_size(width: c_int, height: c_int) void;
 pub extern "c" fn emscripten_get_canvas_size(width: *c_int, height: *c_int, isFullscreen: *c_int) void;
 pub extern "c" fn emscripten_get_now() f64;
+pub extern "c" fn emscripten_num_logical_cores() c_int;
 pub extern "c" fn emscripten_random() f32;
 pub const em_idb_onload_func = ?*const fn (?*anyopaque, ?*anyopaque, c_int) callconv(.c) void;
 pub extern "c" fn emscripten_idb_async_load(db_name: [*:0]const u8, file_id: [*:0]const u8, arg: ?*anyopaque, onload: em_idb_onload_func, onerror: em_arg_callback_func) void;

package/std/os/linux/IoUring.zig

@@ -1856,6 +1856,7 @@ pub fn buf_ring_advance(br: *linux.io_uring_buf_ring, count: u16) void {
 }
 
 test BufferGroup {
+    if (builtin.target.cpu.arch.isPowerPC()) return; // https://codeberg.org/ziglang/zig/issues/31562
     if (!is_linux) return error.SkipZigTest;
 
     const io = testing.io;
@@ -1924,5 +1925,6 @@ test BufferGroup {
 }
 
 test {
+    if (builtin.target.cpu.arch.isPowerPC()) return; // https://codeberg.org/ziglang/zig/issues/31562
     if (is_linux) _ = @import("IoUring/test.zig");
 }

package/std/os/linux/alpha.zig

@@ -0,0 +1,358 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u64 {
+    return asm volatile (
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\1:
+        : [ret] "={$0}" (-> u64),
+        : [number] "{$0}" (number),
+        : .{
+          .r1 = true,
+          .r2 = true,
+          .r3 = true,
+          .r4 = true,
+          .r5 = true,
+          .r6 = true,
+          .r7 = true,
+          .r8 = true,
+          .r22 = true,
+          .r23 = true,
+          .r24 = true,
+          .r25 = true,
+          .r27 = true,
+          .r28 = true,
+          .memory = true,
+          .r16 = true,
+          .r17 = true,
+          .r18 = true,
+          .r20 = true,
+          .r21 = true,
+        });
+}
+
+pub fn syscall1(number: SYS, arg1: u64) u64 {
+    // These registers are both inputs and clobbers.
+    var r16_out: u64 = undefined;
+    return asm volatile (
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\1:
+        : [ret] "={$0}" (-> u64),
+          [r16_out] "={$16}" (r16_out),
+        : [number] "{$0}" (number),
+          [arg1] "{$16}" (arg1),
+        : .{
+          .r1 = true,
+          .r2 = true,
+          .r3 = true,
+          .r4 = true,
+          .r5 = true,
+          .r6 = true,
+          .r7 = true,
+          .r8 = true,
+          .r22 = true,
+          .r23 = true,
+          .r24 = true,
+          .r25 = true,
+          .r27 = true,
+          .r28 = true,
+          .memory = true,
+          .r17 = true,
+          .r18 = true,
+          .r20 = true,
+          .r21 = true,
+        });
+}
+
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
+    // These registers are both inputs and clobbers.
+    var r16_out: u64 = undefined;
+    var r17_out: u64 = undefined;
+    return asm volatile (
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\1:
+        : [ret] "={$0}" (-> u64),
+          [r16_out] "={$16}" (r16_out),
+          [r17_out] "={$17}" (r17_out),
+        : [number] "{$0}" (number),
+          [arg1] "{$16}" (arg1),
+          [arg2] "{$17}" (arg2),
+        : .{
+          .r1 = true,
+          .r2 = true,
+          .r3 = true,
+          .r4 = true,
+          .r5 = true,
+          .r6 = true,
+          .r7 = true,
+          .r8 = true,
+          .r22 = true,
+          .r23 = true,
+          .r24 = true,
+          .r25 = true,
+          .r27 = true,
+          .r28 = true,
+          .memory = true,
+          .r18 = true,
+          .r20 = true,
+          .r21 = true,
+        });
+}
+
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
+    // These registers are both inputs and clobbers.
+    var r16_out: u64 = undefined;
+    var r17_out: u64 = undefined;
+    var r18_out: u64 = undefined;
+    return asm volatile (
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\1:
+        : [ret] "={$0}" (-> u64),
+          [r16_out] "={$16}" (r16_out),
+          [r17_out] "={$17}" (r17_out),
+          [r18_out] "={$18}" (r18_out),
+        : [number] "{$0}" (number),
+          [arg1] "{$16}" (arg1),
+          [arg2] "{$17}" (arg2),
+          [arg3] "{$18}" (arg3),
+        : .{
+          .r1 = true,
+          .r2 = true,
+          .r3 = true,
+          .r4 = true,
+          .r5 = true,
+          .r6 = true,
+          .r7 = true,
+          .r8 = true,
+          .r22 = true,
+          .r23 = true,
+          .r24 = true,
+          .r25 = true,
+          .r27 = true,
+          .r28 = true,
+          .memory = true,
+          .r20 = true,
+          .r21 = true,
+        });
+}
+
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
+    // These registers are both inputs and clobbers.
+    var r16_out: u64 = undefined;
+    var r17_out: u64 = undefined;
+    var r18_out: u64 = undefined;
+    var r19_out: u64 = undefined;
+    return asm volatile (
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\1:
+        : [ret] "={$0}" (-> u64),
+          [r16_out] "={$16}" (r16_out),
+          [r17_out] "={$17}" (r17_out),
+          [r18_out] "={$18}" (r18_out),
+          [r19_out] "={$19}" (r19_out),
+        : [number] "{$0}" (number),
+          [arg1] "{$16}" (arg1),
+          [arg2] "{$17}" (arg2),
+          [arg3] "{$18}" (arg3),
+          [arg4] "{$19}" (arg4),
+        : .{
+          .r1 = true,
+          .r2 = true,
+          .r3 = true,
+          .r4 = true,
+          .r5 = true,
+          .r6 = true,
+          .r7 = true,
+          .r8 = true,
+          .r22 = true,
+          .r23 = true,
+          .r24 = true,
+          .r25 = true,
+          .r27 = true,
+          .r28 = true,
+          .memory = true,
+          .r20 = true,
+          .r21 = true,
+        });
+}
+
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
+    // These registers are both inputs and clobbers.
+    var r16_out: u64 = undefined;
+    var r17_out: u64 = undefined;
+    var r18_out: u64 = undefined;
+    var r19_out: u64 = undefined;
+    var r20_out: u64 = undefined;
+    return asm volatile (
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\1:
+        : [ret] "={$0}" (-> u64),
+          [r16_out] "={$16}" (r16_out),
+          [r17_out] "={$17}" (r17_out),
+          [r18_out] "={$18}" (r18_out),
+          [r19_out] "={$19}" (r19_out),
+          [r20_out] "={$20}" (r20_out),
+        : [number] "{$0}" (number),
+          [arg1] "{$16}" (arg1),
+          [arg2] "{$17}" (arg2),
+          [arg3] "{$18}" (arg3),
+          [arg4] "{$19}" (arg4),
+          [arg5] "{$20}" (arg5),
+        : .{
+          .r1 = true,
+          .r2 = true,
+          .r3 = true,
+          .r4 = true,
+          .r5 = true,
+          .r6 = true,
+          .r7 = true,
+          .r8 = true,
+          .r22 = true,
+          .r23 = true,
+          .r24 = true,
+          .r25 = true,
+          .r27 = true,
+          .r28 = true,
+          .memory = true,
+          .r21 = true,
+        });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
+    // These registers are both inputs and clobbers.
+    var r16_out: u64 = undefined;
+    var r17_out: u64 = undefined;
+    var r18_out: u64 = undefined;
+    var r19_out: u64 = undefined;
+    var r20_out: u64 = undefined;
+    var r21_out: u64 = undefined;
+    return asm volatile (
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\1:
+        : [ret] "={$0}" (-> u64),
+          [r16_out] "={$16}" (r16_out),
+          [r17_out] "={$17}" (r17_out),
+          [r18_out] "={$18}" (r18_out),
+          [r19_out] "={$19}" (r19_out),
+          [r20_out] "={$20}" (r20_out),
+          [r21_out] "={$21}" (r21_out),
+        : [number] "{$0}" (number),
+          [arg1] "{$16}" (arg1),
+          [arg2] "{$17}" (arg2),
+          [arg3] "{$18}" (arg3),
+          [arg4] "{$19}" (arg4),
+          [arg5] "{$20}" (arg5),
+          [arg6] "{$21}" (arg6),
+        : .{
+          .r1 = true,
+          .r2 = true,
+          .r3 = true,
+          .r4 = true,
+          .r5 = true,
+          .r6 = true,
+          .r7 = true,
+          .r8 = true,
+          .r22 = true,
+          .r23 = true,
+          .r24 = true,
+          .r25 = true,
+          .r27 = true,
+          .r28 = true,
+          .memory = true,
+        });
+}
+
+pub fn clone() callconv(.naked) u64 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         a0,   a1,    a2,    a3,  a4,   a5,  +0
+    //
+    // syscall(SYS_clone, flags, stack, ptid, ctid, tls)
+    //         v0         a0,    a1,    a2,   a3,   a4
+    asm volatile (
+    // a0 = $16, a1 = $17, a2 = $18, a3 = $19,
+    // a4 = $20, a5 = $21, sp = $30, v0 = $0
+        \\ # Save function pointer and argument pointer on new thread stack
+        \\ ldi $1, -8
+        \\ and $17, $17, $1
+        \\ lda $17, -16($17)
+        \\ stq $16, 0($17)
+        \\ stq $19, 8($17)
+        \\
+        \\ # Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,ctid,tls)
+        \\ mov $18, $16
+        \\ mov $20, $18
+        \\ ldq $19, 0($30)
+        \\ mov $21, $20
+        \\
+        \\ # Actual syscall
+        \\ ldi $0, 312 # SYS_clone
+        \\ callsys
+        \\ beq $19, 1f
+        \\ negq $0, $0
+        \\ ret
+        \\1:
+        \\ beq $0, 2f
+        \\ ret
+        \\2:
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+    // ra = $26
+        \\ .cfi_undefined $26
+    );
+    asm volatile (
+    // v0 = $0, t9 = $23, a0 = $16, ra = $26, sp = $30, fp = $15
+        \\ mov 0, $15
+        \\
+        \\ ldq $23, 0($30)
+        \\ ldq $16, 8($30)
+        \\ lda $30, 16($30)
+        \\ jsr $26, ($23)
+        \\
+        \\ mov $0, $16
+        \\ ldi $0, 1 # SYS_EXIT
+        \\ callsys
+    );
+}
+
+pub fn restore() noreturn {
+    asm volatile (
+    // v0 = $0, a0 = $16, sp = $30
+        \\ mov $30, $16
+        \\ ldi $0, 103 # SIGRETURN
+        \\ callsys
+    );
+}
+
+pub fn restore_rt() noreturn {
+    asm volatile (
+    // v0 = $0, a0 = $16, sp = $30
+        \\ mov $30, $16
+        \\ ldi $0, 351 # RT_SIGRETURN
+        \\ callsys
+    );
+}
+
+pub const VDSO = void;

package/std/os/linux/arm.zig

@@ -182,30 +182,4 @@ pub const VDSO = struct {
     pub const CGT_VER = "LINUX_2.6";
 };
 
-pub const HWCAP = struct {
-    pub const SWP = 1 << 0;
-    pub const HALF = 1 << 1;
-    pub const THUMB = 1 << 2;
-    pub const @"26BIT" = 1 << 3;
-    pub const FAST_MULT = 1 << 4;
-    pub const FPA = 1 << 5;
-    pub const VFP = 1 << 6;
-    pub const EDSP = 1 << 7;
-    pub const JAVA = 1 << 8;
-    pub const IWMMXT = 1 << 9;
-    pub const CRUNCH = 1 << 10;
-    pub const THUMBEE = 1 << 11;
-    pub const NEON = 1 << 12;
-    pub const VFPv3 = 1 << 13;
-    pub const VFPv3D16 = 1 << 14;
-    pub const TLS = 1 << 15;
-    pub const VFPv4 = 1 << 16;
-    pub const IDIVA = 1 << 17;
-    pub const IDIVT = 1 << 18;
-    pub const VFPD32 = 1 << 19;
-    pub const IDIV = IDIVA | IDIVT;
-    pub const LPAE = 1 << 20;
-    pub const EVTSTRM = 1 << 21;
-};
-
 pub const time_t = i32;

package/std/os/linux/bpf.zig

@@ -58,6 +58,12 @@ pub const JGT = 0x20;
 pub const JGE = 0x30;
 pub const JSET = 0x40;
 
+// misc fields
+/// copy A into X
+pub const TAX = 0x00;
+/// copy X into A
+pub const TXA = 0x80;
+
 //#define BPF_SRC(code)   ((code) & 0x08)
 pub const K = 0x00;
 pub const X = 0x08;

package/std/os/linux/ioctl.zig

@@ -11,16 +11,17 @@ const bits = switch (@import("builtin").cpu.arch) {
     .powerpc64le,
     .sparc,
     .sparc64,
+    .alpha,
     => .{ .size = 13, .dir = 3, .none = 1, .read = 2, .write = 4 },
     else => .{ .size = 14, .dir = 2, .none = 0, .read = 2, .write = 1 },
 };
 
-const Direction = std.meta.Int(.unsigned, bits.dir);
+const Direction = @Int(.unsigned, bits.dir);
 
 pub const Request = packed struct {
     nr: u8,
     io_type: u8,
-    size: std.meta.Int(.unsigned, bits.size),
+    size: @Int(.unsigned, bits.size),
     dir: Direction,
 };