Adding upstream version 1.21.8.upstream/1.21.8

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 448 insertions, 0 deletions

diff --git a/src/runtime/sys_freebsd_riscv64.s b/src/runtime/sys_freebsd_riscv64.s
new file mode 100644
index 0000000..cbf920c
--- /dev/null
+++ b/src/runtime/sys_freebsd_riscv64.s
@@ -0,0 +1,448 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//
+// System calls and other sys.stuff for riscv64, FreeBSD
+// /usr/src/sys/kern/syscalls.master for syscall numbers.
+//
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+#define CLOCK_REALTIME		0
+#define CLOCK_MONOTONIC		4
+
+#define SYS_exit		1
+#define SYS_read		3
+#define SYS_write		4
+#define SYS_open		5
+#define SYS_close		6
+#define SYS_getpid		20
+#define SYS_kill		37
+#define SYS_sigaltstack		53
+#define SYS_munmap		73
+#define SYS_madvise		75
+#define SYS_setitimer		83
+#define SYS_fcntl		92
+#define SYS___sysctl		202
+#define SYS_nanosleep		240
+#define SYS_issetugid		253
+#define SYS_clock_gettime	232
+#define SYS_sched_yield		331
+#define SYS_sigprocmask		340
+#define SYS_kqueue		362
+#define SYS_sigaction		416
+#define SYS_thr_exit		431
+#define SYS_thr_self		432
+#define SYS_thr_kill		433
+#define SYS__umtx_op		454
+#define SYS_thr_new		455
+#define SYS_mmap		477
+#define SYS_cpuset_getaffinity	487
+#define SYS_pipe2 		542
+#define SYS_kevent		560
+
+TEXT emptyfunc<>(SB),0,$0-0
+	RET
+
+// func sys_umtx_op(addr *uint32, mode int32, val uint32, uaddr1 uintptr, ut *umtx_time) int32
+TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
+	MOV	addr+0(FP), A0
+	MOVW	mode+8(FP), A1
+	MOVW	val+12(FP), A2
+	MOV	uaddr1+16(FP), A3
+	MOV	ut+24(FP), A4
+	MOV	$SYS__umtx_op, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	NEG	A0, A0
+ok:
+	MOVW	A0, ret+32(FP)
+	RET
+
+// func thr_new(param *thrparam, size int32) int32
+TEXT runtime·thr_new(SB),NOSPLIT,$0
+	MOV	param+0(FP), A0
+	MOVW	size+8(FP), A1
+	MOV	$SYS_thr_new, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	NEG	A0, A0
+ok:
+	MOVW	A0, ret+16(FP)
+	RET
+
+// func thr_start()
+TEXT runtime·thr_start(SB),NOSPLIT,$0
+	// set up g
+	MOV	m_g0(A0), g
+	MOV	A0, g_m(g)
+	CALL	emptyfunc<>(SB)	 // fault if stack check is wrong
+	CALL	runtime·mstart(SB)
+
+	WORD	$0	// crash
+	RET
+
+// func exit(code int32)
+TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
+	MOVW	code+0(FP), A0
+	MOV	$SYS_exit, T0
+	ECALL
+	WORD	$0	// crash
+
+// func exitThread(wait *atomic.Uint32)
+TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
+	MOV	wait+0(FP), A0
+	// We're done using the stack.
+	FENCE
+	MOVW	ZERO, (A0)
+	FENCE
+	MOV	$0, A0	// exit code
+	MOV	$SYS_thr_exit, T0
+	ECALL
+	JMP	0(PC)
+
+// func open(name *byte, mode, perm int32) int32
+TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
+	MOV	name+0(FP), A0
+	MOVW	mode+8(FP), A1
+	MOVW	perm+12(FP), A2
+	MOV	$SYS_open, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	MOV	$-1, A0
+ok:
+	MOVW	A0, ret+16(FP)
+	RET
+
+// func closefd(fd int32) int32
+TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
+	MOVW	fd+0(FP), A0
+	MOV	$SYS_close, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	MOV	$-1, A0
+ok:
+	MOVW	A0, ret+8(FP)
+	RET
+
+// func pipe2(flags int32) (r, w int32, errno int32)
+TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20
+	MOV	$r+8(FP), A0
+	MOVW	flags+0(FP), A1
+	MOV	$SYS_pipe2, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	NEG	A0, A0
+ok:
+	MOVW	A0, errno+16(FP)
+	RET
+
+// func write1(fd uintptr, p unsafe.Pointer, n int32) int32
+TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28
+	MOV	fd+0(FP), A0
+	MOV	p+8(FP), A1
+	MOVW	n+16(FP), A2
+	MOV	$SYS_write, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	NEG	A0, A0
+ok:
+	MOVW	A0, ret+24(FP)
+	RET
+
+// func read(fd int32, p unsafe.Pointer, n int32) int32
+TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
+	MOVW	fd+0(FP), A0
+	MOV	p+8(FP), A1
+	MOVW	n+16(FP), A2
+	MOV	$SYS_read, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	NEG	A0, A0
+ok:
+	MOVW	A0, ret+24(FP)
+	RET
+
+// func usleep(usec uint32)
+TEXT runtime·usleep(SB),NOSPLIT,$24-4
+	MOVWU	usec+0(FP), A0
+	MOV	$1000, A1
+	MUL	A1, A0, A0
+	MOV	$1000000000, A1
+	DIV	A1, A0, A2
+	MOV	A2, 8(X2)
+	REM	A1, A0, A3
+	MOV	A3, 16(X2)
+	ADD	$8, X2, A0
+	MOV	ZERO, A1
+	MOV	$SYS_nanosleep, T0
+	ECALL
+	RET
+
+// func thr_self() thread
+TEXT runtime·thr_self(SB),NOSPLIT,$8-8
+	MOV	$ptr-8(SP), A0	// arg 1 &8(SP)
+	MOV	$SYS_thr_self, T0
+	ECALL
+	MOV	ptr-8(SP), A0
+	MOV	A0, ret+0(FP)
+	RET
+
+// func thr_kill(t thread, sig int)
+TEXT runtime·thr_kill(SB),NOSPLIT,$0-16
+	MOV	tid+0(FP), A0	// arg 1 pid
+	MOV	sig+8(FP), A1	// arg 2 sig
+	MOV	$SYS_thr_kill, T0
+	ECALL
+	RET
+
+// func raiseproc(sig uint32)
+TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
+	MOV	$SYS_getpid, T0
+	ECALL
+	// arg 1 pid - already in A0
+	MOVW	sig+0(FP), A1	// arg 2
+	MOV	$SYS_kill, T0
+	ECALL
+	RET
+
+// func setitimer(mode int32, new, old *itimerval)
+TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
+	MOVW	mode+0(FP), A0
+	MOV	new+8(FP), A1
+	MOV	old+16(FP), A2
+	MOV	$SYS_setitimer, T0
+	ECALL
+	RET
+
+// func fallback_walltime() (sec int64, nsec int32)
+TEXT runtime·fallback_walltime(SB),NOSPLIT,$24-12
+	MOV	$CLOCK_REALTIME, A0
+	MOV	$8(X2), A1
+	MOV	$SYS_clock_gettime, T0
+	ECALL
+	MOV	8(X2), T0	// sec
+	MOVW	16(X2), T1	// nsec
+	MOV	T0, sec+0(FP)
+	MOVW	T1, nsec+8(FP)
+	RET
+
+// func fallback_nanotime() int64
+TEXT runtime·fallback_nanotime(SB),NOSPLIT,$24-8
+	MOV	$CLOCK_MONOTONIC, A0
+	MOV	$8(X2), A1
+	MOV	$SYS_clock_gettime, T0
+	ECALL
+	MOV	8(X2), T0	// sec
+	MOV	16(X2), T1	// nsec
+
+	// sec is in T0, nsec in T1
+	// return nsec in T0
+	MOV	$1000000000, T2
+	MUL	T2, T0
+	ADD	T1, T0
+
+	MOV	T0, ret+0(FP)
+	RET
+
+// func asmSigaction(sig uintptr, new, old *sigactiont) int32
+TEXT runtime·asmSigaction(SB),NOSPLIT|NOFRAME,$0
+	MOV	sig+0(FP), A0		// arg 1 sig
+	MOV	new+8(FP), A1		// arg 2 act
+	MOV	old+16(FP), A2		// arg 3 oact
+	MOV	$SYS_sigaction, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	MOV	$-1, A0
+ok:
+	MOVW	A0, ret+24(FP)
+	RET
+
+// func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
+TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
+	MOVW	sig+8(FP), A0
+	MOV	info+16(FP), A1
+	MOV	ctx+24(FP), A2
+	MOV	fn+0(FP), T1
+	JALR	RA, T1
+	RET
+
+// func sigtramp(signo, ureg, ctxt unsafe.Pointer)
+TEXT runtime·sigtramp(SB),NOSPLIT,$64
+	MOVW	A0, 8(X2)
+	MOV	A1, 16(X2)
+	MOV	A2, 24(X2)
+
+	// this might be called in external code context,
+	// where g is not set.
+	MOVBU	runtime·iscgo(SB), A0
+	BEQ	A0, ZERO, ok
+	CALL	runtime·load_g(SB)
+ok:
+	MOV	$runtime·sigtrampgo(SB), A0
+	JALR	RA, A0
+	RET
+
+// func mmap(addr uintptr, n uintptr, prot int, flags int, fd int, off int64) (ret uintptr, err error)
+TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0
+	MOV	addr+0(FP), A0
+	MOV	n+8(FP), A1
+	MOVW	prot+16(FP), A2
+	MOVW	flags+20(FP), A3
+	MOVW	fd+24(FP), A4
+	MOVW	off+28(FP), A5
+	MOV	$SYS_mmap, T0
+	ECALL
+	BNE	T0, ZERO, fail
+	MOV	A0, p+32(FP)
+	MOV	ZERO, err+40(FP)
+	RET
+fail:
+	MOV	ZERO, p+32(FP)
+	MOV	A0, err+40(FP)
+	RET
+
+// func munmap(addr uintptr, n uintptr) (err error)
+TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0
+	MOV	addr+0(FP), A0
+	MOV	n+8(FP), A1
+	MOV	$SYS_munmap, T0
+	ECALL
+	BNE	T0, ZERO, fail
+	RET
+fail:
+	WORD	$0	// crash
+
+// func madvise(addr unsafe.Pointer, n uintptr, flags int32) int32
+TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
+	MOV	addr+0(FP), A0
+	MOV	n+8(FP), A1
+	MOVW	flags+16(FP), A2
+	MOV	$SYS_madvise, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	MOV	$-1, A0
+ok:
+	MOVW	A0, ret+24(FP)
+	RET
+
+// func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
+TEXT runtime·sysctl(SB),NOSPLIT,$0
+	MOV	mib+0(FP), A0
+	MOV	miblen+8(FP), A1
+	MOV	out+16(FP), A2
+	MOV	size+24(FP), A3
+	MOV	dst+32(FP), A4
+	MOV	ndst+40(FP), A5
+	MOV	$SYS___sysctl, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	NEG	A0, A0
+ok:
+	MOVW	A0, ret+48(FP)
+	RET
+
+// func sigaltstack(new, old *stackt)
+TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
+	MOV	new+0(FP), A0
+	MOV	old+8(FP), A1
+	MOV	$SYS_sigaltstack, T0
+	ECALL
+	BNE	T0, ZERO, fail
+	RET
+fail:
+	WORD	$0	// crash
+
+// func osyield()
+TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
+	MOV	$SYS_sched_yield, T0
+	ECALL
+	RET
+
+// func sigprocmask(how int32, new, old *sigset)
+TEXT runtime·sigprocmask(SB),NOSPLIT|NOFRAME,$0-24
+	MOVW	how+0(FP), A0
+	MOV	new+8(FP), A1
+	MOV	old+16(FP), A2
+	MOV	$SYS_sigprocmask, T0
+	ECALL
+	BNE	T0, ZERO, fail
+	RET
+fail:
+	WORD	$0	// crash
+
+
+// func cpuset_getaffinity(level int, which int, id int64, size int, mask *byte) int32
+TEXT runtime·cpuset_getaffinity(SB),NOSPLIT|NOFRAME,$0-44
+	MOV	level+0(FP), A0
+	MOV	which+8(FP), A1
+	MOV	id+16(FP), A2
+	MOV	size+24(FP), A3
+	MOV	mask+32(FP), A4
+	MOV	$SYS_cpuset_getaffinity, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	MOV	$-1, A0
+ok:
+	MOVW	A0, ret+40(FP)
+	RET
+
+// func kqueue() int32
+TEXT runtime·kqueue(SB),NOSPLIT|NOFRAME,$0
+	MOV $SYS_kqueue, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	MOV	$-1, A0
+ok:
+	MOVW	A0, ret+0(FP)
+	RET
+
+// func kevent(kq int, ch unsafe.Pointer, nch int, ev unsafe.Pointer, nev int, ts *Timespec) (n int, err error)
+TEXT runtime·kevent(SB),NOSPLIT,$0
+	MOVW	kq+0(FP), A0
+	MOV	ch+8(FP), A1
+	MOVW	nch+16(FP), A2
+	MOV	ev+24(FP), A3
+	MOVW	nev+32(FP), A4
+	MOV	ts+40(FP), A5
+	MOV	$SYS_kevent, T0
+	ECALL
+	BEQ	T0, ZERO, ok
+	NEG	A0, A0
+ok:
+	MOVW	A0, ret+48(FP)
+	RET
+
+// func fcntl(fd, cmd, arg int32) (int32, int32)
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), A0
+	MOVW	cmd+4(FP), A1
+	MOVW	arg+8(FP), A2
+	MOV	$SYS_fcntl, T0
+	ECALL
+	BEQ	T0, ZERO, noerr
+	MOV	$-1, A1
+	MOVW	A1, ret+16(FP)
+	MOVW	A0, errno+20(FP)
+	RET
+noerr:
+	MOVW	A0, ret+16(FP)
+	MOVW	ZERO, errno+20(FP)
+	RET
+
+// func getCntxct() uint32
+TEXT runtime·getCntxct(SB),NOSPLIT|NOFRAME,$0
+	RDTIME	A0
+	MOVW	A0, ret+0(FP)
+	RET
+
+// func issetugid() int32
+TEXT runtime·issetugid(SB),NOSPLIT|NOFRAME,$0
+	MOV $SYS_issetugid, T0
+	ECALL
+	MOVW	A0, ret+0(FP)
+	RET
+