authorgravatar for alex@alexrp.comAlex Rønne Petersen <alex@alexrp.com> 2025-10-17 01:12:07+02:00
committergravatar for alex@alexrp.comAlex Rønne Petersen <alex@alexrp.com> 2025-10-17 01:20:33+02:00
log502eca7b0908cc8f0fa334fde4c3f7e4fc067027
treea4880044c9817f6c730b59de4765109ac9351d34
parentaa8e53908a355f42551b7fb51cf78b197bfbd851
signaturebadge-check Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

std.os.linux: add incomplete mipsn32 arch bits file

This is very likely full of wrong stuff. It's effectively just a copy of the mips64 file - needed because the former stopped using usize/isize. To be clear, this is no more broken than the old situation was; this just makes the brokenness explicit.

2 files changed, 275 insertions(+), 1 deletions(-)

lib/std/os/linux.zig+4-1
...@@ -43,7 +43,10 @@ const arch_bits = switch (native_arch) {...@@ -43,7 +43,10 @@ const arch_bits = switch (native_arch) {
43 .loongarch64 => @import("linux/loongarch64.zig"),43 .loongarch64 => @import("linux/loongarch64.zig"),
44 .m68k => @import("linux/m68k.zig"),44 .m68k => @import("linux/m68k.zig"),
45 .mips, .mipsel => @import("linux/mips.zig"),45 .mips, .mipsel => @import("linux/mips.zig"),
46 .mips64, .mips64el => @import("linux/mips64.zig"),46 .mips64, .mips64el => switch (builtin.abi) {
47 .gnuabin32, .muslabin32 => @import("linux/mipsn32.zig"),
48 else => @import("linux/mips64.zig"),
49 },
47 .powerpc, .powerpcle => @import("linux/powerpc.zig"),50 .powerpc, .powerpcle => @import("linux/powerpc.zig"),
48 .powerpc64, .powerpc64le => @import("linux/powerpc64.zig"),51 .powerpc64, .powerpc64le => @import("linux/powerpc64.zig"),
49 .s390x => @import("linux/s390x.zig"),52 .s390x => @import("linux/s390x.zig"),
lib/std/os/linux/mipsn32.zig created+271
...@@ -0,0 +1,271 @@
1// TODO: A lot of this file is very likely wrong.
2
3const builtin = @import("builtin");
4const std = @import("../../std.zig");
5const SYS = std.os.linux.SYS;
6
7pub fn syscall0(number: SYS) u32 {
8 return asm volatile (
9 \\ syscall
10 \\ beq $7, $zero, 1f
11 \\ blez $2, 1f
12 \\ dsubu $2, $0, $2
13 \\ 1:
14 : [ret] "={$2}" (-> u32),
15 : [number] "{$2}" (@intFromEnum(number)),
16 : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
17}
18
19pub fn syscall_pipe(fd: *[2]i32) u32 {
20 return asm volatile (
21 \\ .set noat
22 \\ .set noreorder
23 \\ syscall
24 \\ beq $7, $zero, 1f
25 \\ nop
26 \\ b 2f
27 \\ subu $2, $0, $2
28 \\ 1:
29 \\ sw $2, 0($4)
30 \\ sw $3, 4($4)
31 \\ 2:
32 : [ret] "={$2}" (-> u32),
33 : [number] "{$2}" (@intFromEnum(SYS.pipe)),
34 [fd] "{$4}" (fd),
35 : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
36}
37
38pub fn syscall1(number: SYS, arg1: u32) u32 {
39 return asm volatile (
40 \\ syscall
41 \\ beq $7, $zero, 1f
42 \\ blez $2, 1f
43 \\ nop
44 \\ dsubu $2, $0, $2
45 \\ 1:
46 : [ret] "={$2}" (-> u32),
47 : [number] "{$2}" (@intFromEnum(number)),
48 [arg1] "{$4}" (arg1),
49 : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
50}
51
52pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
53 return asm volatile (
54 \\ syscall
55 \\ beq $7, $zero, 1f
56 \\ blez $2, 1f
57 \\ dsubu $2, $0, $2
58 \\ 1:
59 : [ret] "={$2}" (-> u32),
60 : [number] "{$2}" (@intFromEnum(number)),
61 [arg1] "{$4}" (arg1),
62 [arg2] "{$5}" (arg2),
63 : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
64}
65
66pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
67 return asm volatile (
68 \\ syscall
69 \\ beq $7, $zero, 1f
70 \\ blez $2, 1f
71 \\ dsubu $2, $0, $2
72 \\ 1:
73 : [ret] "={$2}" (-> u32),
74 : [number] "{$2}" (@intFromEnum(number)),
75 [arg1] "{$4}" (arg1),
76 [arg2] "{$5}" (arg2),
77 [arg3] "{$6}" (arg3),
78 : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
79}
80
81pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
82 return asm volatile (
83 \\ syscall
84 \\ beq $7, $zero, 1f
85 \\ blez $2, 1f
86 \\ dsubu $2, $0, $2
87 \\ 1:
88 : [ret] "={$2}" (-> u32),
89 : [number] "{$2}" (@intFromEnum(number)),
90 [arg1] "{$4}" (arg1),
91 [arg2] "{$5}" (arg2),
92 [arg3] "{$6}" (arg3),
93 [arg4] "{$7}" (arg4),
94 : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
95}
96
97pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
98 return asm volatile (
99 \\ syscall
100 \\ beq $7, $zero, 1f
101 \\ blez $2, 1f
102 \\ dsubu $2, $0, $2
103 \\ 1:
104 : [ret] "={$2}" (-> u32),
105 : [number] "{$2}" (@intFromEnum(number)),
106 [arg1] "{$4}" (arg1),
107 [arg2] "{$5}" (arg2),
108 [arg3] "{$6}" (arg3),
109 [arg4] "{$7}" (arg4),
110 [arg5] "{$8}" (arg5),
111 : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
112}
113
114pub fn syscall6(
115 number: SYS,
116 arg1: u32,
117 arg2: u32,
118 arg3: u32,
119 arg4: u32,
120 arg5: u32,
121 arg6: u32,
122) u32 {
123 return asm volatile (
124 \\ syscall
125 \\ beq $7, $zero, 1f
126 \\ blez $2, 1f
127 \\ dsubu $2, $0, $2
128 \\ 1:
129 : [ret] "={$2}" (-> u32),
130 : [number] "{$2}" (@intFromEnum(number)),
131 [arg1] "{$4}" (arg1),
132 [arg2] "{$5}" (arg2),
133 [arg3] "{$6}" (arg3),
134 [arg4] "{$7}" (arg4),
135 [arg5] "{$8}" (arg5),
136 [arg6] "{$9}" (arg6),
137 : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
138}
139
140pub fn syscall7(
141 number: SYS,
142 arg1: u32,
143 arg2: u32,
144 arg3: u32,
145 arg4: u32,
146 arg5: u32,
147 arg6: u32,
148 arg7: u32,
149) u32 {
150 return asm volatile (
151 \\ syscall
152 \\ beq $7, $zero, 1f
153 \\ blez $2, 1f
154 \\ dsubu $2, $0, $2
155 \\ 1:
156 : [ret] "={$2}" (-> u32),
157 : [number] "{$2}" (@intFromEnum(number)),
158 [arg1] "{$4}" (arg1),
159 [arg2] "{$5}" (arg2),
160 [arg3] "{$6}" (arg3),
161 [arg4] "{$7}" (arg4),
162 [arg5] "{$8}" (arg5),
163 [arg6] "{$9}" (arg6),
164 [arg7] "{$10}" (arg7),
165 : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
166}
167
168pub fn clone() callconv(.naked) u32 {
169 // __clone(func, stack, flags, arg, ptid, tls, ctid)
170 // 3, 4, 5, 6, 7, 8, 9
171 //
172 // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
173 // 2 4, 5, 6, 7, 8
174 asm volatile (
175 \\ # Save function pointer and argument pointer on new thread stack
176 \\ and $5, $5, -16
177 \\ dsubu $5, $5, 16
178 \\ sd $4, 0($5)
179 \\ sd $7, 8($5)
180 \\ # Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,tls,ctid)
181 \\ move $4, $6
182 \\ move $6, $8
183 \\ move $7, $9
184 \\ move $8, $10
185 \\ li $2, 5055 # SYS_clone
186 \\ syscall
187 \\ beq $7, $0, 1f
188 \\ nop
189 \\ jr $ra
190 \\ dsubu $2, $0, $2
191 \\1:
192 \\ beq $2, $0, 1f
193 \\ nop
194 \\ jr $ra
195 \\ nop
196 \\1:
197 );
198 if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
199 \\ .cfi_undefined $ra
200 );
201 asm volatile (
202 \\ move $fp, $zero
203 \\ move $ra, $zero
204 \\
205 \\ ld $25, 0($sp)
206 \\ ld $4, 8($sp)
207 \\ jalr $25
208 \\ nop
209 \\ move $4, $2
210 \\ li $2, 5058 # SYS_exit
211 \\ syscall
212 );
213}
214
215pub const VDSO = struct {
216 pub const CGT_SYM = "__vdso_clock_gettime";
217 pub const CGT_VER = "LINUX_2.6";
218};
219
220pub const blksize_t = u32;
221pub const nlink_t = u32;
222pub const time_t = i32;
223pub const mode_t = u32;
224pub const off_t = i64;
225pub const ino_t = u64;
226pub const dev_t = u64;
227pub const blkcnt_t = i64;
228
229// The `stat` definition used by the Linux kernel.
230pub const Stat = extern struct {
231 dev: dev_t,
232 __pad0: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
233 ino: ino_t,
234 mode: mode_t,
235 nlink: nlink_t,
236 uid: std.os.linux.uid_t,
237 gid: std.os.linux.gid_t,
238 rdev: dev_t,
239 __pad1: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
240 size: off_t,
241 atim: u32,
242 atim_nsec: u32,
243 mtim: u32,
244 mtim_nsec: u32,
245 ctim: u32,
246 ctim_nsec: u32,
247 blksize: blksize_t,
248 __pad3: u32,
249 blocks: blkcnt_t,
250
251 pub fn atime(self: @This()) std.os.linux.timespec {
252 return .{
253 .sec = self.atim,
254 .nsec = self.atim_nsec,
255 };
256 }
257
258 pub fn mtime(self: @This()) std.os.linux.timespec {
259 return .{
260 .sec = self.mtim,
261 .nsec = self.mtim_nsec,
262 };
263 }
264
265 pub fn ctime(self: @This()) std.os.linux.timespec {
266 return .{
267 .sec = self.ctim,
268 .nsec = self.ctim_nsec,
269 };
270 }
271};