add testing support for GOOS=tamago GOARCH=riscv64

Author: abarisani

.github/workflows/build.yml

@@ -14,6 +14,9 @@ jobs:
     - name: Compile Go with all.bash
       run: |
         cd src ; ./clean.bash ; ./all.bash
-    - name: Run Go distribution tests under GOOS=tamago
+    - name: Run Go distribution tests under tamago/arm
       run: |
         GO_BUILDER_NAME="tamago" GOOS=tamago GOARCH=arm ./bin/go tool dist test
+    - name: Run Go distribution tests under tamago/riscv64
+      run: |
+        GO_BUILDER_NAME="tamago" GOOS=tamago GOARCH=riscv64 ./bin/go tool dist test

src/runtime/asm_riscv64.s

@@ -79,17 +79,19 @@ TEXT setg_gcc<>(SB),NOSPLIT,$0-0
 	CALL	runtime·save_g(SB)
 	RET
 
-#ifndef GOOS_tamago
 
 // func cputicks() int64
 TEXT runtime·cputicks(SB),NOSPLIT,$0-8
+#ifndef GOOS_tamago
 	// RDTIME to emulate cpu ticks
 	// RDCYCLE reads counter that is per HART(core) based
 	// according to the riscv manual, see issue 46737
 	RDTIME	A0
 	MOV	A0, ret+0(FP)
 	RET
-
+#else
+	// nanotime() is a poor approximation of CPU ticks that is enough for the profiler.
+	JMP	runtime·nanotime(SB)
 #endif
 
 // systemstack_switch is a dummy routine that systemstack leaves at the bottom

src/runtime/os_tamago_riscv64.go

@@ -119,11 +119,7 @@ func signame(sig uint32) string {
 	return ""
 }
 
-//go:nosplit
-func cputicks() int64 {
-	// runtime·nanotime() is a poor approximation of CPU ticks that is enough for the profiler.
-	return nanotime()
-}
+func cputicks() int64
 
 //go:linkname os_sigpipe os.sigpipe
 func os_sigpipe() {

src/runtime/rt0_tamago_riscv64.s

@@ -17,8 +17,26 @@
 #define CSRS(RS,CSR) WORD $(0x2073 + RS<<15 + CSR<<20)
 #define CSRW(RS,CSR) WORD $(0x1073 + RS<<15 + CSR<<20)
 
+#define SYS_mmap 222
+
 // entry point for M privilege level instances
 TEXT _rt0_riscv64_tamago(SB),NOSPLIT|NOFRAME,$0
+	MOV	runtime·testBinary(SB), T0
+	BEQ	T0, ZERO, start
+
+	// when testing bare metal memory is mapped as OS virtual memory
+	MOV	runtime·ramStart(SB), A0
+	MOV	runtime·ramSize(SB), A1
+	MOV	$0x3, A2	// PROT_READ | PROT_WRITE
+	MOV	$0x22, A3	// MAP_PRIVATE | MAP_ANONYMOUS
+	MOV	$0xffffffff, A4
+	MOV	$0, A5
+	MOV	$SYS_mmap, A7
+	ECALL
+
+	JMP	_rt0_riscv64_tamago_start(SB)
+
+start:
 	// Disable interrupts
 	MOV	$0, T0
 	CSRW	(t0, sie)

src/runtime/sys_tamago_riscv64.s

@@ -10,7 +10,7 @@
 #include "go_tls.h"
 #include "textflag.h"
 
-TEXT runtime·rt0_riscv64_tamago(SB),NOSPLIT|TOPFRAME,$0
+TEXT runtime·rt0_riscv64_tamago(SB),NOSPLIT|NOFRAME,$0
 	// create istack out of the bootstack
 	MOV	$runtime·g0(SB), g
 	MOV	$(-64*1024), T0

src/testing/testing_tamago_riscv64.go

@@ -0,0 +1,55 @@
+// Copyright 2021 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.
+
+//go:build tamago && riscv64
+
+package testing
+
+import (
+	"runtime"
+	_ "unsafe"
+)
+
+//go:linkname ramStart runtime.ramStart
+var ramStart uint64 = 0x80000000
+
+//go:linkname ramSize runtime.ramSize
+var ramSize uint64 = 0x20000000 // 512MB
+
+//go:linkname ramStackOffset runtime.ramStackOffset
+var ramStackOffset uint64 = 0x100
+
+// defined in testing_tamago_riscv64.s
+func sys_exit(code int32)
+func sys_write(c *byte)
+func sys_clock_gettime() (ns int64)
+func sys_getrandom(b []byte, n int)
+
+//go:linkname nanotime1 runtime.nanotime1
+func nanotime1() int64 {
+	return sys_clock_gettime()
+}
+
+//go:linkname initRNG runtime.initRNG
+func initRNG() {}
+
+//go:linkname getRandomData runtime.getRandomData
+func getRandomData(b []byte) {
+	sys_getrandom(b, len(b))
+}
+
+// preallocated memory to avoid malloc during panic
+var a [1]byte
+
+//go:linkname printk runtime.printk
+func printk(c byte) {
+	a[0] = c
+	sys_write(&a[0])
+}
+
+//go:linkname hwinit runtime.hwinit
+func hwinit() {
+	runtime.Bloc = uintptr(ramStart)
+	runtime.Exit = sys_exit
+}

src/testing/testing_tamago_riscv64.s

@@ -0,0 +1,54 @@
+// Copyright 2009 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.
+
+//go:build tamago && riscv64
+
+#include "go_asm.h"
+#include "textflag.h"
+
+#define CLOCK_REALTIME 0
+
+#define SYS_write		64
+#define SYS_exit		93
+#define SYS_clock_gettime	113
+#define SYS_getrandom		278
+
+// func sys_clock_gettime() int64
+TEXT ·sys_clock_gettime(SB),NOSPLIT,$40-8
+	MOV	$CLOCK_REALTIME, A0
+	MOV	$8(X2), A1
+	MOV	$SYS_clock_gettime, A7
+	ECALL
+	MOV	8(X2), T0	// sec
+	MOV	16(X2), T1	// nsec
+	MOV	$1000000000, T2
+	MUL	T2, T0
+	ADD	T1, T0
+	MOV	T0, ns+0(FP)
+	RET
+
+// func sys_exit(code int32)
+TEXT ·sys_exit(SB), $0-4
+	MOVW	code+0(FP), A0
+	MOV	$SYS_exit, A7
+	ECALL
+	RET
+
+// func sys_write(c *byte)
+TEXT ·sys_write(SB),NOSPLIT,$0-8
+	MOV	$1, A0		// fd
+	MOV	c+0(FP), A1	// p
+	MOV	$1, A2		// n
+	MOV	$SYS_write, A7
+	ECALL
+	RET
+
+// func sys_getrandom(b []byte, n int)
+TEXT ·sys_getrandom(SB), $0-32
+	MOV	b+0(FP), A0
+	MOV	n+24(FP), A1
+	MOV	$0, A2
+	MOV	$SYS_getrandom, A7
+	ECALL
+	RET