type syscallFunc uintptr

var libc_getsystemcfg syscallFunc

type errno = syscall.Errno

// Implemented in runtime/syscall_aix.go.
func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err errno)
func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err errno)

func callgetsystemcfg(label int) (r1 uintptr, e1 errno) {

//go:nosplit
//go:cgo_unsafe_args
func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
	entersyscall()
	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6)), unsafe.Pointer(&fn))
	exitsyscall()
	return
}
func syscall6()

//go:linkname syscall_syscall6X syscall.syscall6X
//go:nosplit
//go:cgo_unsafe_args
func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
	entersyscall()

>>> Flow 2 (server to client)
00000000  16 03 03 00 5d 02 00 00  59 03 03 21 15 e1 02 00  |....]...Y..!....|
00000010  c6 0c e5 3f c9 6f a5 59  38 7e 13 81 1b 26 50 46  |...?.o.Y8~...&PF|
00000020  bf 2b 95 0c eb a8 bc 72  97 bc 26 20 ad 6b 84 ac  |.+.....r..& .k..|
00000030  8f 62 26 0b 4b d8 bf 1b  7d a5 27 3b 3e 45 a5 8f  |.b&.K...}.';>E..|
00000040  37 fb b2 25 2c d3 82 69  ed d7 c9 f0 cc a8 00 00  |7..%,..i........|

// Implemented in assembly to avoid allocation.
func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno)

func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)

// license that can be found in the LICENSE file.

#include "textflag.h"

// func Syscall6(num, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr)
TEXT ·Syscall6(SB),NOSPLIT,$0-80
	MOVD	num+0(FP), R8	// syscall entry
	MOVD	a1+8(FP), R0
	MOVD	a2+16(FP), R1
	MOVD	a3+24(FP), R2
	MOVD	a4+32(FP), R3
	MOVD	a5+40(FP), R4
	MOVD	a6+48(FP), R5
	SVC
	CMN	$4095, R0
	BCC	ok
	MOVD	$-1, R4
	MOVD	R4, r1+56(FP)

00000350  41 79 49 00 71 80 e9 0d  12 c3 17 03 03 00 99 ec  |AyI.q...........|
00000360  f5 a1 45 64 61 fc 61 35  d5 2f bf 20 02 68 0b 10  |..Eda.a5./. .h..|
00000370  df c4 4b e7 2c 43 bc f5  3d 0b 7e 9f a4 71 09 2c  |..K.,C..=.~..q.,|
00000380  a6 cf f4 f4 b4 2c 08 0c  03 50 ac 47 74 ad 24 f1  |.....,...P.Gt.$.|
00000390  04 f3 d4 83 42 3f 35 a5  57 ff ab 59 0c 9a a2 ca  |....B?5.W..Y....|
000003a0  6c 30 b7 87 73 af 53 f9  1d 6b e7 44 ec d1 bd 14  |l0..s.S..k.D....|

package unix

import "syscall"

// Implemented as sysvicall6 in runtime/syscall_solaris.go.
func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)

// Implemented as rawsysvicall6 in runtime/syscall_solaris.go.
func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)

//go:cgo_import_dynamic libc_fstatat fstatat "libc.so"

	return newoffset, err
}

func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) {
	fd, _, err := Syscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0)
	return int(fd), err
}

func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) {
	fd, _, err := RawSyscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0)

// license that can be found in the LICENSE file.

#include "textflag.h"

// func Syscall6(num, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr)
TEXT ·Syscall6(SB),NOSPLIT,$0-80
	MOVD	num+0(FP), R1	// syscall entry
	MOVD	a1+8(FP), R2
	MOVD	a2+16(FP), R3
	MOVD	a3+24(FP), R4
	MOVD	a4+32(FP), R5
	MOVD	a5+40(FP), R6
	MOVD	a6+48(FP), R7
	SYSCALL
	MOVD	$0xfffffffffffff001, R8
	CMPUBLT	R2, R8, ok
	MOVD	$-1, r1+56(FP)

//go:build linux && (mips64 || mips64le)

#include "textflag.h"

// func Syscall6(num, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr)
TEXT ·Syscall6(SB),NOSPLIT,$0-80
	MOVV	num+0(FP), R2	// syscall entry
	MOVV	a1+8(FP), R4
	MOVV	a2+16(FP), R5
	MOVV	a3+24(FP), R6
	MOVV	a4+32(FP), R7
	MOVV	a5+40(FP), R8
	MOVV	a6+48(FP), R9
	MOVV	R0, R3	// reset R3 to 0 as 1-ret SYSCALL keeps it
	SYSCALL
	BEQ	R7, ok