runtime: add async preemption support on riscv64

This CL adds support of call injection and async preemption on
riscv64. We also clobbered REG_TMP for the injected call. Unsafe
points related to REG_TMP access have been marked in previous commits.

Fixes #36711.

Author: NonerKao

src/runtime/mkpreempt.go

@@ -502,8 +502,35 @@ func genPPC64() {
 }
 
 func genRISCV64() {
-	p("// No async preemption on riscv64 - see issue 36711")
-	p("UNDEF")
+	// X0 (zero), X1 (LR), X2 (SP), X4 (g), X31 (TMP) are special.
+	var l = layout{sp: "X2", stack: 8}
+
+	// Integers
+	for i := 3; i < 31; i++ {
+		if i == 4 {
+			continue
+		}
+		reg := fmt.Sprintf("X%d", i)
+		l.add("MOV", reg, 8)
+	}
+
+	// Floating points
+	// TODO: support fscr.
+	for i := 0; i <= 31; i++ {
+		reg := fmt.Sprintf("F%d", i)
+		l.add("MOVF", reg, 8)
+	}
+
+	p("MOV X1, -%d(X2)", l.stack)
+	p("ADD $-%d, X2", l.stack)
+	l.save()
+	p("CALL ·asyncPreempt2(SB)")
+	l.restore()
+	p("MOV %d(X2), X31", l.stack)
+	p("ADD $%d, X2", l.stack+8)
+	p("MOV 0(X2), X1")
+
+	p("JMP 0(X31)")
 }
 
 func genS390X() {

src/runtime/preempt_riscv64.s

@@ -4,5 +4,128 @@
 #include "textflag.h"
 
 TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0
-	// No async preemption on riscv64 - see issue 36711
-	UNDEF
+	MOV X1, -480(X2)
+	ADD $-480, X2
+	MOV X3, 8(X2)
+	MOV X5, 16(X2)
+	MOV X6, 24(X2)
+	MOV X7, 32(X2)
+	MOV X8, 40(X2)
+	MOV X9, 48(X2)
+	MOV X10, 56(X2)
+	MOV X11, 64(X2)
+	MOV X12, 72(X2)
+	MOV X13, 80(X2)
+	MOV X14, 88(X2)
+	MOV X15, 96(X2)
+	MOV X16, 104(X2)
+	MOV X17, 112(X2)
+	MOV X18, 120(X2)
+	MOV X19, 128(X2)
+	MOV X20, 136(X2)
+	MOV X21, 144(X2)
+	MOV X22, 152(X2)
+	MOV X23, 160(X2)
+	MOV X24, 168(X2)
+	MOV X25, 176(X2)
+	MOV X26, 184(X2)
+	MOV X27, 192(X2)
+	MOV X28, 200(X2)
+	MOV X29, 208(X2)
+	MOV X30, 216(X2)
+	MOVF F0, 224(X2)
+	MOVF F1, 232(X2)
+	MOVF F2, 240(X2)
+	MOVF F3, 248(X2)
+	MOVF F4, 256(X2)
+	MOVF F5, 264(X2)
+	MOVF F6, 272(X2)
+	MOVF F7, 280(X2)
+	MOVF F8, 288(X2)
+	MOVF F9, 296(X2)
+	MOVF F10, 304(X2)
+	MOVF F11, 312(X2)
+	MOVF F12, 320(X2)
+	MOVF F13, 328(X2)
+	MOVF F14, 336(X2)
+	MOVF F15, 344(X2)
+	MOVF F16, 352(X2)
+	MOVF F17, 360(X2)
+	MOVF F18, 368(X2)
+	MOVF F19, 376(X2)
+	MOVF F20, 384(X2)
+	MOVF F21, 392(X2)
+	MOVF F22, 400(X2)
+	MOVF F23, 408(X2)
+	MOVF F24, 416(X2)
+	MOVF F25, 424(X2)
+	MOVF F26, 432(X2)
+	MOVF F27, 440(X2)
+	MOVF F28, 448(X2)
+	MOVF F29, 456(X2)
+	MOVF F30, 464(X2)
+	MOVF F31, 472(X2)
+	CALL ·asyncPreempt2(SB)
+	MOVF 472(X2), F31
+	MOVF 464(X2), F30
+	MOVF 456(X2), F29
+	MOVF 448(X2), F28
+	MOVF 440(X2), F27
+	MOVF 432(X2), F26
+	MOVF 424(X2), F25
+	MOVF 416(X2), F24
+	MOVF 408(X2), F23
+	MOVF 400(X2), F22
+	MOVF 392(X2), F21
+	MOVF 384(X2), F20
+	MOVF 376(X2), F19
+	MOVF 368(X2), F18
+	MOVF 360(X2), F17
+	MOVF 352(X2), F16
+	MOVF 344(X2), F15
+	MOVF 336(X2), F14
+	MOVF 328(X2), F13
+	MOVF 320(X2), F12
+	MOVF 312(X2), F11
+	MOVF 304(X2), F10
+	MOVF 296(X2), F9
+	MOVF 288(X2), F8
+	MOVF 280(X2), F7
+	MOVF 272(X2), F6
+	MOVF 264(X2), F5
+	MOVF 256(X2), F4
+	MOVF 248(X2), F3
+	MOVF 240(X2), F2
+	MOVF 232(X2), F1
+	MOVF 224(X2), F0
+	MOV 216(X2), X30
+	MOV 208(X2), X29
+	MOV 200(X2), X28
+	MOV 192(X2), X27
+	MOV 184(X2), X26
+	MOV 176(X2), X25
+	MOV 168(X2), X24
+	MOV 160(X2), X23
+	MOV 152(X2), X22
+	MOV 144(X2), X21
+	MOV 136(X2), X20
+	MOV 128(X2), X19
+	MOV 120(X2), X18
+	MOV 112(X2), X17
+	MOV 104(X2), X16
+	MOV 96(X2), X15
+	MOV 88(X2), X14
+	MOV 80(X2), X13
+	MOV 72(X2), X12
+	MOV 64(X2), X11
+	MOV 56(X2), X10
+	MOV 48(X2), X9
+	MOV 40(X2), X8
+	MOV 32(X2), X7
+	MOV 24(X2), X6
+	MOV 16(X2), X5
+	MOV 8(X2), X3
+	MOV 480(X2), X31
+	ADD $488, X2
+	MOV 0(X2), X1
+	JMP 0(X31)

src/runtime/signal_riscv64.go

@@ -78,8 +78,14 @@ func (c *sigctxt) preparePanic(sig uint32, gp *g) {
 	c.set_pc(uint64(funcPC(sigpanic)))
 }
 
-const pushCallSupported = false
+const pushCallSupported = true
 
 func (c *sigctxt) pushCall(targetPC uintptr) {
-	throw("unimplemented")
+	sp := c.sp() - sys.PtrSize
+	c.set_sp(sp)
+	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.ra()
+	// Set up PC and LR to pretend the function being signaled
+	// calls targetPC at the faulting PC.
+	c.set_ra(c.pc())
+	c.set_pc(uint64(targetPC))
 }