Get `mips64(el)-linux` working and start testing it by alexrp · Pull Request #21095 · ziglang/zig

alexrp · 2024-08-16T09:27:32Z

No description provided.

alexrp · 2024-08-17T10:04:13Z

This should be ready for review.

The kernel sets r7 to 0 (success) or -1 (error), and stores the result in r2. When r7 is -1 and the result is positive, it needs to be negated to get the errno value that higher-level code, such as errnoFromSyscall(), expects to see. The old code was missing the check that r2 is positive, but was also doing the r7 check incorrectly; since it can only be set to 0 or -1, the blez instruction would always branch. In practice, this fix is necessary for e.g. the ENOSYS error to be interpreted correctly. This manifested as hitting an unreachable branch when calling process_vm_readv() in std.debug.MemoryAccessor.

It is usually generic, so no point having it in arch bits.

#21090

#21091

These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

andrewrk

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

If it's too much, perhaps one category of testing can be performed on master branch only, and then any breakage can be reverted.

andrewrk · 2024-08-23T02:59:18Z

 \\ syscall
- \\ blez $7, 1f
+ \\ beq $7, $zero, 1f
+ \\ blez $2, 1f
 \\ dsubu $2, $0, $2
 \\ 1:


The equivalent musl code for all these syscall functions has only one daddu instruction followed by syscall. Any reason we can't do that?

The reason we don't have that is because musl mixes inline assembly and C logic: https://git.musl-libc.org/cgit/musl/tree/arch/mips64/syscall_arch.h#n38
We could of course do the same, but I thought I'd just keep things simple.

it's not really related to C logic, it's just using C syntax to get values in and out of registers. Zig's constraint strings are powerful enough to do the same. You're already doing it with ={$2} to get the value out. You can do the same thing with the input values.
register long r4 __asm__("$4") = a;
is just
: "[a] {$4}" (a),
in zig.

alexrp · 2024-08-23T03:15:33Z

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

@andrewrk that's because the CI results here were from before #21125 was merged. The extreme slowdown observed for MIPS is specific to O32; N64 runs in a normal amount of time.

andrewrk · 2024-08-23T03:51:31Z

I see, thank you for pointing that out.

alexrp · 2024-08-16T09:27:32Z

No description provided.

alexrp · 2024-08-17T10:04:13Z

This should be ready for review.

The kernel sets r7 to 0 (success) or -1 (error), and stores the result in r2. When r7 is -1 and the result is positive, it needs to be negated to get the errno value that higher-level code, such as errnoFromSyscall(), expects to see. The old code was missing the check that r2 is positive, but was also doing the r7 check incorrectly; since it can only be set to 0 or -1, the blez instruction would always branch. In practice, this fix is necessary for e.g. the ENOSYS error to be interpreted correctly. This manifested as hitting an unreachable branch when calling process_vm_readv() in std.debug.MemoryAccessor.

It is usually generic, so no point having it in arch bits.

#21090

#21091

These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

andrewrk

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

If it's too much, perhaps one category of testing can be performed on master branch only, and then any breakage can be reverted.

andrewrk · 2024-08-23T02:59:18Z

 \\ syscall
- \\ blez $7, 1f
+ \\ beq $7, $zero, 1f
+ \\ blez $2, 1f
 \\ dsubu $2, $0, $2
 \\ 1:


The equivalent musl code for all these syscall functions has only one daddu instruction followed by syscall. Any reason we can't do that?

The reason we don't have that is because musl mixes inline assembly and C logic: https://git.musl-libc.org/cgit/musl/tree/arch/mips64/syscall_arch.h#n38
We could of course do the same, but I thought I'd just keep things simple.

it's not really related to C logic, it's just using C syntax to get values in and out of registers. Zig's constraint strings are powerful enough to do the same. You're already doing it with ={$2} to get the value out. You can do the same thing with the input values.
register long r4 __asm__("$4") = a;
is just
: "[a] {$4}" (a),
in zig.

alexrp · 2024-08-23T03:15:33Z

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

@andrewrk that's because the CI results here were from before #21125 was merged. The extreme slowdown observed for MIPS is specific to O32; N64 runs in a normal amount of time.

andrewrk · 2024-08-23T03:51:31Z

I see, thank you for pointing that out.

alexrp · 2024-08-16T09:27:32Z

No description provided.

alexrp · 2024-08-17T10:04:13Z

This should be ready for review.

The kernel sets r7 to 0 (success) or -1 (error), and stores the result in r2. When r7 is -1 and the result is positive, it needs to be negated to get the errno value that higher-level code, such as errnoFromSyscall(), expects to see. The old code was missing the check that r2 is positive, but was also doing the r7 check incorrectly; since it can only be set to 0 or -1, the blez instruction would always branch. In practice, this fix is necessary for e.g. the ENOSYS error to be interpreted correctly. This manifested as hitting an unreachable branch when calling process_vm_readv() in std.debug.MemoryAccessor.

It is usually generic, so no point having it in arch bits.

#21090

#21091

These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

andrewrk

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

If it's too much, perhaps one category of testing can be performed on master branch only, and then any breakage can be reverted.

andrewrk · 2024-08-23T02:59:18Z

 \\ syscall
- \\ blez $7, 1f
+ \\ beq $7, $zero, 1f
+ \\ blez $2, 1f
 \\ dsubu $2, $0, $2
 \\ 1:


The equivalent musl code for all these syscall functions has only one daddu instruction followed by syscall. Any reason we can't do that?

The reason we don't have that is because musl mixes inline assembly and C logic: https://git.musl-libc.org/cgit/musl/tree/arch/mips64/syscall_arch.h#n38
We could of course do the same, but I thought I'd just keep things simple.

it's not really related to C logic, it's just using C syntax to get values in and out of registers. Zig's constraint strings are powerful enough to do the same. You're already doing it with ={$2} to get the value out. You can do the same thing with the input values.
register long r4 __asm__("$4") = a;
is just
: "[a] {$4}" (a),
in zig.

alexrp · 2024-08-23T03:15:33Z

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

@andrewrk that's because the CI results here were from before #21125 was merged. The extreme slowdown observed for MIPS is specific to O32; N64 runs in a normal amount of time.

andrewrk · 2024-08-23T03:51:31Z

I see, thank you for pointing that out.

alexrp · 2024-08-16T09:27:32Z

No description provided.

alexrp · 2024-08-17T10:04:13Z

This should be ready for review.

The kernel sets r7 to 0 (success) or -1 (error), and stores the result in r2. When r7 is -1 and the result is positive, it needs to be negated to get the errno value that higher-level code, such as errnoFromSyscall(), expects to see. The old code was missing the check that r2 is positive, but was also doing the r7 check incorrectly; since it can only be set to 0 or -1, the blez instruction would always branch. In practice, this fix is necessary for e.g. the ENOSYS error to be interpreted correctly. This manifested as hitting an unreachable branch when calling process_vm_readv() in std.debug.MemoryAccessor.

It is usually generic, so no point having it in arch bits.

#21090

#21091

These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

andrewrk

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

If it's too much, perhaps one category of testing can be performed on master branch only, and then any breakage can be reverted.

andrewrk · 2024-08-23T02:59:18Z

 \\ syscall
- \\ blez $7, 1f
+ \\ beq $7, $zero, 1f
+ \\ blez $2, 1f
 \\ dsubu $2, $0, $2
 \\ 1:


The equivalent musl code for all these syscall functions has only one daddu instruction followed by syscall. Any reason we can't do that?

The reason we don't have that is because musl mixes inline assembly and C logic: https://git.musl-libc.org/cgit/musl/tree/arch/mips64/syscall_arch.h#n38
We could of course do the same, but I thought I'd just keep things simple.

it's not really related to C logic, it's just using C syntax to get values in and out of registers. Zig's constraint strings are powerful enough to do the same. You're already doing it with ={$2} to get the value out. You can do the same thing with the input values.
register long r4 __asm__("$4") = a;
is just
: "[a] {$4}" (a),
in zig.

alexrp · 2024-08-23T03:15:33Z

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

@andrewrk that's because the CI results here were from before #21125 was merged. The extreme slowdown observed for MIPS is specific to O32; N64 runs in a normal amount of time.

andrewrk · 2024-08-23T03:51:31Z

I see, thank you for pointing that out.

alexrp · 2024-08-16T09:27:32Z

No description provided.

alexrp · 2024-08-17T10:04:13Z

This should be ready for review.

The kernel sets r7 to 0 (success) or -1 (error), and stores the result in r2. When r7 is -1 and the result is positive, it needs to be negated to get the errno value that higher-level code, such as errnoFromSyscall(), expects to see. The old code was missing the check that r2 is positive, but was also doing the r7 check incorrectly; since it can only be set to 0 or -1, the blez instruction would always branch. In practice, this fix is necessary for e.g. the ENOSYS error to be interpreted correctly. This manifested as hitting an unreachable branch when calling process_vm_readv() in std.debug.MemoryAccessor.

It is usually generic, so no point having it in arch bits.

#21090

#21091

These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

andrewrk

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

If it's too much, perhaps one category of testing can be performed on master branch only, and then any breakage can be reverted.

andrewrk · 2024-08-23T02:59:18Z

 \\ syscall
- \\ blez $7, 1f
+ \\ beq $7, $zero, 1f
+ \\ blez $2, 1f
 \\ dsubu $2, $0, $2
 \\ 1:


The equivalent musl code for all these syscall functions has only one daddu instruction followed by syscall. Any reason we can't do that?

The reason we don't have that is because musl mixes inline assembly and C logic: https://git.musl-libc.org/cgit/musl/tree/arch/mips64/syscall_arch.h#n38
We could of course do the same, but I thought I'd just keep things simple.

it's not really related to C logic, it's just using C syntax to get values in and out of registers. Zig's constraint strings are powerful enough to do the same. You're already doing it with ={$2} to get the value out. You can do the same thing with the input values.
register long r4 __asm__("$4") = a;
is just
: "[a] {$4}" (a),
in zig.

alexrp · 2024-08-23T03:15:33Z

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

@andrewrk that's because the CI results here were from before #21125 was merged. The extreme slowdown observed for MIPS is specific to O32; N64 runs in a normal amount of time.

andrewrk · 2024-08-23T03:51:31Z

I see, thank you for pointing that out.

alexrp · 2024-08-16T09:27:32Z

No description provided.

alexrp · 2024-08-17T10:04:13Z

This should be ready for review.

The kernel sets r7 to 0 (success) or -1 (error), and stores the result in r2. When r7 is -1 and the result is positive, it needs to be negated to get the errno value that higher-level code, such as errnoFromSyscall(), expects to see. The old code was missing the check that r2 is positive, but was also doing the r7 check incorrectly; since it can only be set to 0 or -1, the blez instruction would always branch. In practice, this fix is necessary for e.g. the ENOSYS error to be interpreted correctly. This manifested as hitting an unreachable branch when calling process_vm_readv() in std.debug.MemoryAccessor.

It is usually generic, so no point having it in arch bits.

#21090

#21091

These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

andrewrk

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

If it's too much, perhaps one category of testing can be performed on master branch only, and then any breakage can be reverted.

andrewrk · 2024-08-23T02:59:18Z

 \\ syscall
- \\ blez $7, 1f
+ \\ beq $7, $zero, 1f
+ \\ blez $2, 1f
 \\ dsubu $2, $0, $2
 \\ 1:


The equivalent musl code for all these syscall functions has only one daddu instruction followed by syscall. Any reason we can't do that?

The reason we don't have that is because musl mixes inline assembly and C logic: https://git.musl-libc.org/cgit/musl/tree/arch/mips64/syscall_arch.h#n38
We could of course do the same, but I thought I'd just keep things simple.

it's not really related to C logic, it's just using C syntax to get values in and out of registers. Zig's constraint strings are powerful enough to do the same. You're already doing it with ={$2} to get the value out. You can do the same thing with the input values.
register long r4 __asm__("$4") = a;
is just
: "[a] {$4}" (a),
in zig.

alexrp · 2024-08-23T03:15:33Z

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

@andrewrk that's because the CI results here were from before #21125 was merged. The extreme slowdown observed for MIPS is specific to O32; N64 runs in a normal amount of time.

andrewrk · 2024-08-23T03:51:31Z

I see, thank you for pointing that out.

alexrp · 2024-08-16T09:27:32Z

No description provided.

alexrp · 2024-08-17T10:04:13Z

This should be ready for review.

The kernel sets r7 to 0 (success) or -1 (error), and stores the result in r2. When r7 is -1 and the result is positive, it needs to be negated to get the errno value that higher-level code, such as errnoFromSyscall(), expects to see. The old code was missing the check that r2 is positive, but was also doing the r7 check incorrectly; since it can only be set to 0 or -1, the blez instruction would always branch. In practice, this fix is necessary for e.g. the ENOSYS error to be interpreted correctly. This manifested as hitting an unreachable branch when calling process_vm_readv() in std.debug.MemoryAccessor.

It is usually generic, so no point having it in arch bits.

#21090

#21091

These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

andrewrk

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

If it's too much, perhaps one category of testing can be performed on master branch only, and then any breakage can be reverted.

andrewrk · 2024-08-23T02:59:18Z

 \\ syscall
- \\ blez $7, 1f
+ \\ beq $7, $zero, 1f
+ \\ blez $2, 1f
 \\ dsubu $2, $0, $2
 \\ 1:


The equivalent musl code for all these syscall functions has only one daddu instruction followed by syscall. Any reason we can't do that?

The reason we don't have that is because musl mixes inline assembly and C logic: https://git.musl-libc.org/cgit/musl/tree/arch/mips64/syscall_arch.h#n38
We could of course do the same, but I thought I'd just keep things simple.

it's not really related to C logic, it's just using C syntax to get values in and out of registers. Zig's constraint strings are powerful enough to do the same. You're already doing it with ={$2} to get the value out. You can do the same thing with the input values.
register long r4 __asm__("$4") = a;
is just
: "[a] {$4}" (a),
in zig.

alexrp · 2024-08-23T03:15:33Z

This doubles the amount of time CI runs take. Let's proceed and see if it is manageable.

@andrewrk that's because the CI results here were from before #21125 was merged. The extreme slowdown observed for MIPS is specific to O32; N64 runs in a normal amount of time.

andrewrk · 2024-08-23T03:51:31Z

I see, thank you for pointing that out.

alexrp marked this pull request as draft August 16, 2024 10:12

alexrp marked this pull request as ready for review August 17, 2024 10:04

alexrp added 10 commits August 18, 2024 07:27

std.os.linux: Fix E definition for mips64.
bcf41c8

std.os.linux: Fix rlimit_resource for mips64; move out of arch bits.
ed9a502
It is usually generic, so no point having it in arch bits.

std.os.linux: Fix Stat struct for mips/mips64.
ea38009

std.c: Fix Stat struct for mips/mips64 on linux.
e2a4d7a

std.c: Fix Sigaction struct for glibc on mips/mips64.
812a444

std.debug: Also disable stack traces on mips64.
4320611

test: Disable @min/max for floats on mips64.
d4d6b23
#21090

test: Disable vector reduce operation on mips64.
ecbc701
#21091

test: Add mips64(el)-linux-(none,musl,gnuabi64) targets.
3e8ac8e
These take 3-4 minutes to run on my machine, i.e. they're not affected by the LLVM compilation speed bug that affects mips32.

alexrp mentioned this pull request Aug 22, 2024
Update target triple list and support status in README.md. ziglang/zig-bootstrap#184
Merged

andrewrk approved these changes Aug 23, 2024
View reviewed changes

andrewrk merged commit ee84ded into ziglang:masterAug 23, 2024

alexrp deleted the mips64-tests branch August 23, 2024 07:27