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

package/std/os/linux/sh.zig

@@ -0,0 +1,239 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub const syscall_arg_t = u32;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
+    return asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r3}" (@intFromEnum(number)),
+        : .{ .memory = true });
+}
+
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r3}" (@intFromEnum(number)),
+          [arg1] "{r4}" (arg1),
+        : .{ .memory = true });
+}
+
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r3}" (@intFromEnum(number)),
+          [arg1] "{r4}" (arg1),
+          [arg2] "{r5}" (arg2),
+        : .{ .memory = true });
+}
+
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r3}" (@intFromEnum(number)),
+          [arg1] "{r4}" (arg1),
+          [arg2] "{r5}" (arg2),
+          [arg3] "{r6}" (arg3),
+        : .{ .memory = true });
+}
+
+pub fn syscall4(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r3}" (@intFromEnum(number)),
+          [arg1] "{r4}" (arg1),
+          [arg2] "{r5}" (arg2),
+          [arg3] "{r6}" (arg3),
+          [arg4] "{r7}" (arg4),
+        : .{ .memory = true });
+}
+
+pub fn syscall5(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r3}" (@intFromEnum(number)),
+          [arg1] "{r4}" (arg1),
+          [arg2] "{r5}" (arg2),
+          [arg3] "{r6}" (arg3),
+          [arg4] "{r7}" (arg4),
+          [arg5] "{r0}" (arg5),
+        : .{ .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+    arg6: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r3}" (@intFromEnum(number)),
+          [arg1] "{r4}" (arg1),
+          [arg2] "{r5}" (arg2),
+          [arg3] "{r6}" (arg3),
+          [arg4] "{r7}" (arg4),
+          [arg5] "{r0}" (arg5),
+          [arg6] "{r1}" (arg6),
+        : .{ .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         r4,   r5,    r6,    r7,  +0,   +4,  +8
+    //
+    // syscall(SYS_clone, flags, stack, ptid, ctid, tls)
+    //         r3         r4,    r5,    r6,   r7,   r0
+    asm volatile (
+        \\ mov #-4, r0
+        \\ and r0, r5
+        \\
+        \\ mov r4, r1
+        \\ mov r7, r2
+        \\
+        \\ mov #120, r3 ! SYS_clone
+        \\ mov r6, r4
+        \\ mov.l @r15, r6
+        \\ mov.l @(r15, 8), r7
+        \\ mov.l @(r15, 4), r0
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\
+        \\ cmp/eq #0, r0
+        \\ bt 1f
+        \\
+        \\ // parent
+        \\ rts
+        \\  nop
+        \\
+        \\ // child
+        \\1:
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+        \\ .cfi_undefined pr
+    );
+    asm volatile (
+        \\ mov #0, r0
+        \\ lds r0, pr
+        \\ mov r0, r14
+        \\
+        \\ mov r2, r4
+        \\ jsr @r1
+        \\  nop
+        \\
+        \\ mov #1, r3 ! SYS_exit
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+    );
+}
+
+pub fn restore() callconv(.naked) noreturn {
+    asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        :
+        : [number] "{r3}" (@intFromEnum(SYS.sigreturn)),
+    );
+}
+
+pub fn restore_rt() callconv(.naked) noreturn {
+    asm volatile (
+        \\ trapa #31
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        \\ or r0, r0
+        :
+        : [number] "{r3}" (@intFromEnum(SYS.rt_sigreturn)),
+    );
+}
+
+pub const time_t = i32;
+
+pub const VDSO = void;

package/std/os/linux/sparc.zig

@@ -0,0 +1,277 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub const syscall_arg_t = u32;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ neg %%o0
+        \\1:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(number)),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ neg %%o0
+        \\1:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(number)),
+          [arg1] "{o0}" (arg1),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ neg %%o0
+        \\1:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(number)),
+          [arg1] "{o0}" (arg1),
+          [arg2] "{o1}" (arg2),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ neg %%o0
+        \\1:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(number)),
+          [arg1] "{o0}" (arg1),
+          [arg2] "{o1}" (arg2),
+          [arg3] "{o2}" (arg3),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn syscall4(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ neg %%o0
+        \\1:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(number)),
+          [arg1] "{o0}" (arg1),
+          [arg2] "{o1}" (arg2),
+          [arg3] "{o2}" (arg3),
+          [arg4] "{o3}" (arg4),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn syscall5(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ neg %%o0
+        \\1:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(number)),
+          [arg1] "{o0}" (arg1),
+          [arg2] "{o1}" (arg2),
+          [arg3] "{o2}" (arg3),
+          [arg4] "{o3}" (arg4),
+          [arg5] "{o4}" (arg5),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+    arg6: syscall_arg_t,
+) u32 {
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ neg %%o0
+        \\1:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(number)),
+          [arg1] "{o0}" (arg1),
+          [arg2] "{o1}" (arg2),
+          [arg3] "{o2}" (arg3),
+          [arg4] "{o3}" (arg4),
+          [arg5] "{o4}" (arg5),
+          [arg6] "{o5}" (arg6),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn syscall_pipe(
+    fd: *[2]std.os.linux.fd_t,
+) u32 {
+    return asm volatile (
+        \\ mov %[arg], %%g3
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ # Return the error code
+        \\ ba 2f
+        \\  neg %%o0
+        \\1:
+        \\ st %%o0, [%%g3+0]
+        \\ st %%o1, [%%g3+4]
+        \\ clr %%o0
+        \\2:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(SYS.pipe)),
+          [arg] "r" (fd),
+        : .{ .memory = true, .g3 = true });
+}
+
+pub fn syscall_fork() u32 {
+    // Linux/sparc fork() returns two values in %o0 and %o1:
+    // - On the parent's side, %o0 is the child's PID and %o1 is 0.
+    // - On the child's side, %o0 is the parent's PID and %o1 is 1.
+    // We need to clear the child's %o0 so that the return values
+    // conform to the libc convention.
+    return asm volatile (
+        \\ t 0x10
+        \\ bcc 1f
+        \\  nop
+        \\ ba 2f
+        \\  neg %%o0
+        \\1:
+        \\ # Clear the child's %%o0
+        \\ dec %%o1
+        \\ and %%o1, %%o0, %%o0
+        \\2:
+        : [ret] "={o0}" (-> u32),
+        : [number] "{g1}" (@intFromEnum(SYS.fork)),
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         i0,   i1,    i2,    i3,  i4,   i5,  sp
+    //
+    // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+    //         g1         o0,    o1,    o2,   o3,  o4
+    asm volatile (
+        \\ save %%sp, -96, %%sp
+        \\
+        \\ // clone() on SPARC can fail with EFAULT if %%sp points to uncommitted memory, so flush
+        \\ // all register windows up to this point to ensure that the kernel has enough committed
+        \\ // memory for its stack frame.
+        \\ save %%sp, -96, %%sp
+        \\ t 0x3
+        \\ restore
+        \\
+        \\ # Save the func pointer and the arg pointer
+        \\ mov %%i0, %%g2
+        \\ mov %%i3, %%g3
+        \\
+        \\ # Shuffle the arguments
+        \\ mov 217, %%g1 // SYS_clone
+        \\ mov %%i2, %%o0
+        \\
+        \\ # Align, and add some extra space for the initial frame
+        \\ and %%i1, -8, %%i1
+        \\ sub %%i1, 96 + 2047, %%o1
+        \\
+        \\ mov %%i4, %%o2
+        \\ mov %%i5, %%o3
+        \\ ld [%%fp + 92 + 2047], %%o4
+        \\ t 0x10
+        \\ bcs 1f
+        \\  nop
+        \\ # The child pid is returned in o0 while o1 tells if this
+        \\ # process is the child (=1) or the parent (=0).
+        \\ tst %%o1
+        \\ bne 2f
+        \\  nop
+        \\
+        \\ # Parent process, return the child pid
+        \\ mov %%o0, %%i0
+        \\ ret
+        \\  restore
+        \\
+        \\1:
+        \\ # The syscall failed
+        \\ sub %%g0, %%o0, %%i0
+        \\ ret
+        \\  restore
+        \\
+        \\2:
+        \\ # Child process
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+        \\ .cfi_undefined %%i7
+    );
+    asm volatile (
+        \\ mov %%g0, %%fp
+        \\ mov %%g0, %%i7
+        \\
+        \\ # call func(arg)
+        \\ call %%g2
+        \\  mov %%g3, %%o0
+        \\ # Exit
+        \\ mov 1, %%g1 // SYS_exit
+        \\ t 0x10
+    );
+}
+
+pub const restore = restore_rt;
+
+// Need to use C ABI here instead of naked
+// to prevent an infinite loop when calling rt_sigreturn.
+pub fn restore_rt() callconv(.c) void {
+    return asm volatile ("t 0x10"
+        :
+        : [number] "{g1}" (@intFromEnum(SYS.rt_sigreturn)),
+        : .{ .memory = true, .xcc = true, .o0 = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
+}
+
+pub const VDSO = struct {
+    pub const CGT_SYM = "__vdso_clock_gettime";
+    pub const CGT_VER = "LINUX_2.6";
+};
+
+pub const time_t = i32;

package/std/os/linux/sparc64.zig

@@ -10,9 +10,9 @@ pub fn syscall0(
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ neg %%o0
-        \\ 1:
+        \\1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
@@ -25,9 +25,9 @@ pub fn syscall1(
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ neg %%o0
-        \\ 1:
+        \\1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
@@ -42,9 +42,9 @@ pub fn syscall2(
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ neg %%o0
-        \\ 1:
+        \\1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
@@ -61,9 +61,9 @@ pub fn syscall3(
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ neg %%o0
-        \\ 1:
+        \\1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
@@ -82,9 +82,9 @@ pub fn syscall4(
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ neg %%o0
-        \\ 1:
+        \\1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
@@ -105,9 +105,9 @@ pub fn syscall5(
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ neg %%o0
-        \\ 1:
+        \\1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
@@ -130,9 +130,9 @@ pub fn syscall6(
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ neg %%o0
-        \\ 1:
+        \\1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
@@ -151,10 +151,10 @@ pub fn syscall_pipe(
         \\ mov %[arg], %%g3
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ # Return the error code
         \\ ba 2f
-        \\ neg %%o0
+        \\  neg %%o0
         \\1:
         \\ st %%o0, [%%g3+0]
         \\ st %%o1, [%%g3+4]
@@ -175,14 +175,14 @@ pub fn syscall_fork() u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ ba 2f
-        \\ neg %%o0
-        \\ 1:
+        \\  neg %%o0
+        \\1:
         \\ # Clear the child's %%o0
         \\ dec %%o1
         \\ and %%o1, %%o0, %%o0
-        \\ 2:
+        \\2:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(SYS.fork)),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
@@ -196,33 +196,48 @@ pub fn clone() callconv(.naked) u64 {
     //         g1         o0,    o1,    o2,   o3,  o4
     asm volatile (
         \\ save %%sp, -192, %%sp
+        \\
+        \\ // clone() on SPARC can fail with EFAULT if %%sp points to uncommitted memory, so flush
+        \\ // all register windows up to this point to ensure that the kernel has enough committed
+        \\ // memory for its stack frame.
+        \\ save %%sp, -192, %%sp
+        \\ flushw
+        \\ restore
+        \\
         \\ # Save the func pointer and the arg pointer
         \\ mov %%i0, %%g2
         \\ mov %%i3, %%g3
+        \\
         \\ # Shuffle the arguments
         \\ mov 217, %%g1 // SYS_clone
         \\ mov %%i2, %%o0
-        \\ # Add some extra space for the initial frame
-        \\ sub %%i1, 176 + 2047, %%o1
+        \\
+        \\ # Align, and add some extra space for the initial frame
+        \\ and %%i1, -16, %%i1
+        \\ sub %%i1, 192 + 2047, %%o1
+        \\
         \\ mov %%i4, %%o2
         \\ mov %%i5, %%o3
-        \\ ldx [%%fp + 0x8af], %%o4
+        \\ ldx [%%fp + 176 + 2047], %%o4
         \\ t 0x6d
         \\ bcs,pn %%xcc, 1f
-        \\ nop
+        \\  nop
         \\ # The child pid is returned in o0 while o1 tells if this
-        \\ # process is # the child (=1) or the parent (=0).
+        \\ # process is the child (=1) or the parent (=0).
         \\ brnz %%o1, 2f
-        \\ nop
+        \\  nop
+        \\
         \\ # Parent process, return the child pid
         \\ mov %%o0, %%i0
         \\ ret
-        \\ restore
+        \\  restore
+        \\
         \\1:
         \\ # The syscall failed
         \\ sub %%g0, %%o0, %%i0
         \\ ret
-        \\ restore
+        \\  restore
+        \\
         \\2:
         \\ # Child process
     );
@@ -234,9 +249,8 @@ pub fn clone() callconv(.naked) u64 {
         \\ mov %%g0, %%i7
         \\
         \\ # call func(arg)
-        \\ mov %%g0, %%fp
         \\ call %%g2
-        \\ mov %%g3, %%o0
+        \\  mov %%g3, %%o0
         \\ # Exit
         \\ mov 1, %%g1 // SYS_exit
         \\ t 0x6d