@zigc/lib 0.17.0-dev.356 → 0.17.0-dev.389

package/std/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/lang.zig

@@ -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,

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/ioctl.zig

@@ -11,6 +11,7 @@ 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 },
 };