@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/runtime/asm_ppc64x.h

@@ -37,19 +37,3 @@
 	GLOBL	funcname(SB), NOPTR, $24
 #endif
 #endif
-
-// linux/ppc64 uses ELFv1 which uses function descriptors.
-// These must also look like ABI0 functions on linux/ppc64
-// to work with abi.FuncPCABI0(sigtramp) in os_linux.go.
-// Only static codegen is supported on linux/ppc64, so TOC
-// is not needed.
-#ifdef GOOS_linux
-#ifdef GOARCH_ppc64
-#define GO_PPC64X_HAS_FUNCDESC
-#define DEFINE_PPC64X_FUNCDESC(funcname, localfuncname)	\
-	TEXT	funcname(SB),NOSPLIT|NOFRAME,$0		\
-		DWORD	$localfuncname(SB)		\
-		DWORD	$0				\
-		DWORD	$0
-#endif
-#endif

package/bin/go/src/runtime/asm_ppc64x.s

@@ -31,53 +31,26 @@ TEXT _rt0_ppc64x_lib(SB),NOSPLIT|NOFRAME,$0
 	MOVD	R12, CTR
 	BL	(CTR)
 
+	// Initialize g as nil in case of using g later e.g. sigaction in cgo_sigaction.go
+	MOVD	R0, g
+
 #ifdef GOOS_aix
 	// See runtime/cgo/gcc_aix_ppc64.c
 	MOVBZ	runtime·isarchive(SB), R3	// Check buildmode = c-archive
 	CMP		$0, R3
-	BEQ		done
+	BEQ		skipInit
 #endif
 
-	MOVD	$runtime·libpreinit(SB), R12
+	MOVD	$runtime·libInit(SB), R12
 	MOVD	R12, CTR
 	BL	(CTR)
 
-	// Create a new thread to do the runtime initialization and return.
-	// _cgo_sys_thread_create is a C function.
-	MOVD	_cgo_sys_thread_create(SB), R12
-	CMP	$0, R12
-	BEQ	nocgo
-	MOVD	$_rt0_ppc64x_lib_go(SB), R3
-	MOVD	$0, R4
-#ifdef GO_PPC64X_HAS_FUNCDESC
-	// Load the real entry address from the first slot of the function descriptor.
-	MOVD	8(R12), R2
-	MOVD	(R12), R12
-#endif
-	MOVD	R12, CTR
-	BL	(CTR)
-	MOVD	24(R1), R2 // Restore the old frame, and R2.
-	BR	done
-
-nocgo:
-	MOVD	$0x800000, R12                     // stacksize = 8192KB
-	MOVD	R12, 8+FIXED_FRAME(R1)
-	MOVD	$_rt0_ppc64x_lib_go(SB), R12
-	MOVD	R12, 16+FIXED_FRAME(R1)
-	MOVD	$runtime·newosproc0(SB),R12
-	MOVD	R12, CTR
-	BL	(CTR)
-
-done:
+skipInit:
+	// Restore and return to ELFv2 caller.
 	UNSTACK_AND_RESTORE_GO_TO_HOST_ABI(32)
 	RET
 
-#ifdef GO_PPC64X_HAS_FUNCDESC
-DEFINE_PPC64X_FUNCDESC(_rt0_ppc64x_lib_go, __rt0_ppc64x_lib_go)
-TEXT __rt0_ppc64x_lib_go(SB),NOSPLIT,$0
-#else
-TEXT _rt0_ppc64x_lib_go(SB),NOSPLIT,$0
-#endif
+TEXT runtime·rt0_lib_go<ABIInternal>(SB),NOSPLIT,$0
 	MOVD	_rt0_ppc64x_lib_argc<>(SB), R3
 	MOVD	_rt0_ppc64x_lib_argv<>(SB), R4
 	MOVD	$runtime·rt0_go(SB), R12
@@ -180,7 +153,7 @@ nocgo:
 	BL	runtime·mstart(SB)
 	// Prevent dead-code elimination of debugCallV2 and debugPinnerV1, which are
 	// intended to be called by debuggers.
-#ifdef GOARCH_ppc64le
+#ifdef GOOS_linux
 	MOVD	$runtime·debugPinnerV1<ABIInternal>(SB), R31
 	MOVD	$runtime·debugCallV2<ABIInternal>(SB), R31
 #endif
@@ -197,9 +170,9 @@ TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 	RET
 
-// Any changes must be reflected to runtime/cgo/gcc_aix_ppc64.S:.crosscall_ppc64
+// Any changes must be reflected to runtime/cgo/gcc_aix_ppc64.S:.crosscall1
 TEXT _cgo_reginit(SB),NOSPLIT|NOFRAME,$0-0
-	// crosscall_ppc64 and crosscall2 need to reginit, but can't
+	// crosscall1 and crosscall2 need to reginit, but can't
 	// get at the 'runtime.reginit' symbol.
 	BR	runtime·reginit(SB)
 
@@ -782,10 +755,6 @@ nosave:
 	// This code is like the above sequence but without saving/restoring g
 	// and without worrying about the stack moving out from under us
 	// (because we're on a system stack, not a goroutine stack).
-	// The above code could be used directly if already on a system stack,
-	// but then the only path through this code would be a rare case.
-	// Using this code for all "already on system stack" calls exercises it more,
-	// which should help keep it correct.
 
 	SUB	$(asmcgocallSaveOffset+8), R1, R10
 	RLDCR	$0, R10, $~15, R1		// 16-byte alignment for gcc ABI
@@ -1050,16 +1019,6 @@ TEXT runtime·unspillArgs(SB),NOSPLIT,$0-0
 	FMOVD	184(R20), F12
 	RET
 
-// AES hashing not implemented for ppc64
-TEXT runtime·memhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-32
-	JMP	runtime·memhashFallback<ABIInternal>(SB)
-TEXT runtime·strhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·strhashFallback<ABIInternal>(SB)
-TEXT runtime·memhash32<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash32Fallback<ABIInternal>(SB)
-TEXT runtime·memhash64<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash64Fallback<ABIInternal>(SB)
-
 // Called from cgo wrappers, this function returns g->m->curg.stack.hi.
 // Must obey the gcc calling convention.
 #ifdef GOOS_aix
@@ -1119,11 +1078,6 @@ TEXT runtime·addmoduledata(SB),NOSPLIT|NOFRAME,$0-0
 	ADD	$8, R1
 	RET
 
-TEXT ·checkASM(SB),NOSPLIT,$0-1
-	MOVW	$1, R3
-	MOVB	R3, ret+0(FP)
-	RET
-
 // gcWriteBarrier informs the GC about heap pointer writes.
 //
 // gcWriteBarrier does NOT follow the Go ABI. It accepts the
@@ -1260,7 +1214,7 @@ GLOBL	debugCallFrameTooLarge<>(SB), RODATA, $20	// Size duplicated below
 //
 // This is ABIInternal because Go code injects its PC directly into new
 // goroutine stacks.
-#ifdef GOARCH_ppc64le
+#ifdef GOOS_linux
 TEXT runtime·debugCallV2<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0
 	// save scratch register R31 first
 	MOVD	R31, -184(R1)
@@ -1420,7 +1374,7 @@ DEBUG_CALL_FN(debugCall16384<>, 16384)
 DEBUG_CALL_FN(debugCall32768<>, 32768)
 DEBUG_CALL_FN(debugCall65536<>, 65536)
 
-#ifdef GOARCH_ppc64le
+#ifdef GOOS_linux
 // func debugCallPanicked(val interface{})
 TEXT runtime·debugCallPanicked(SB),NOSPLIT,$32-16
 	// Copy the panic value to the top of stack at SP+32.

package/bin/go/src/runtime/asm_riscv64.s

@@ -5,6 +5,7 @@
 #include "go_asm.h"
 #include "funcdata.h"
 #include "textflag.h"
+#include "cgo/abi_riscv64.h"
 
 
 // When building with -buildmode=c-shared, this symbol is called when the shared
@@ -12,30 +13,8 @@
 TEXT _rt0_riscv64_lib(SB),NOSPLIT,$224
 	// Preserve callee-save registers, along with X1 (LR).
 	MOV	X1, (8*3)(X2)
-	MOV	X8, (8*4)(X2)
-	MOV	X9, (8*5)(X2)
-	MOV	X18, (8*6)(X2)
-	MOV	X19, (8*7)(X2)
-	MOV	X20, (8*8)(X2)
-	MOV	X21, (8*9)(X2)
-	MOV	X22, (8*10)(X2)
-	MOV	X23, (8*11)(X2)
-	MOV	X24, (8*12)(X2)
-	MOV	X25, (8*13)(X2)
-	MOV	X26, (8*14)(X2)
-	MOV	g, (8*15)(X2)
-	MOVD	F8, (8*16)(X2)
-	MOVD	F9, (8*17)(X2)
-	MOVD	F18, (8*18)(X2)
-	MOVD	F19, (8*19)(X2)
-	MOVD	F20, (8*20)(X2)
-	MOVD	F21, (8*21)(X2)
-	MOVD	F22, (8*22)(X2)
-	MOVD	F23, (8*23)(X2)
-	MOVD	F24, (8*24)(X2)
-	MOVD	F25, (8*25)(X2)
-	MOVD	F26, (8*26)(X2)
-	MOVD	F27, (8*27)(X2)
+	SAVE_GPR((8*4))
+	SAVE_FPR((8*16))
 
 	// Initialize g as nil in case of using g later e.g. sigaction in cgo_sigaction.go
 	MOV	X0, g
@@ -43,57 +22,17 @@ TEXT _rt0_riscv64_lib(SB),NOSPLIT,$224
 	MOV	A0, _rt0_riscv64_lib_argc<>(SB)
 	MOV	A1, _rt0_riscv64_lib_argv<>(SB)
 
-	// Synchronous initialization.
-	MOV	$runtime·libpreinit(SB), T0
-	JALR	RA, T0
-
-	// Create a new thread to do the runtime initialization and return.
-	MOV	_cgo_sys_thread_create(SB), T0
-	BEQZ	T0, nocgo
-	MOV	$_rt0_riscv64_lib_go(SB), A0
-	MOV	$0, A1
-	JALR	RA, T0
-	JMP	restore
-
-nocgo:
-	MOV	$0x800000, A0                     // stacksize = 8192KB
-	MOV	$_rt0_riscv64_lib_go(SB), A1
-	MOV	A0, 8(X2)
-	MOV	A1, 16(X2)
-	MOV	$runtime·newosproc0(SB), T0
-	JALR	RA, T0
+	MOV	$runtime·libInit(SB), T1
+	JALR	RA, T1
 
-restore:
 	// Restore callee-save registers, along with X1 (LR).
 	MOV	(8*3)(X2), X1
-	MOV	(8*4)(X2), X8
-	MOV	(8*5)(X2), X9
-	MOV	(8*6)(X2), X18
-	MOV	(8*7)(X2), X19
-	MOV	(8*8)(X2), X20
-	MOV	(8*9)(X2), X21
-	MOV	(8*10)(X2), X22
-	MOV	(8*11)(X2), X23
-	MOV	(8*12)(X2), X24
-	MOV	(8*13)(X2), X25
-	MOV	(8*14)(X2), X26
-	MOV	(8*15)(X2), g
-	MOVD	(8*16)(X2), F8
-	MOVD	(8*17)(X2), F9
-	MOVD	(8*18)(X2), F18
-	MOVD	(8*19)(X2), F19
-	MOVD	(8*20)(X2), F20
-	MOVD	(8*21)(X2), F21
-	MOVD	(8*22)(X2), F22
-	MOVD	(8*23)(X2), F23
-	MOVD	(8*24)(X2), F24
-	MOVD	(8*25)(X2), F25
-	MOVD	(8*26)(X2), F26
-	MOVD	(8*27)(X2), F27
+	RESTORE_GPR((8*4))
+	RESTORE_FPR((8*16))
 
 	RET
 
-TEXT _rt0_riscv64_lib_go(SB),NOSPLIT,$0
+TEXT runtime·rt0_lib_go<ABIInternal>(SB),NOSPLIT,$0
 	MOV	_rt0_riscv64_lib_argc<>(SB), A0
 	MOV	_rt0_riscv64_lib_argv<>(SB), A1
 	MOV	$runtime·rt0_go(SB), T0
@@ -122,14 +61,14 @@ TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	MOV	X2, (g_stack+stack_hi)(g)
 
 	// if there is a _cgo_init, call it using the gcc ABI.
-	MOV	_cgo_init(SB), T0
-	BEQ	T0, ZERO, nocgo
+	MOV	_cgo_init(SB), T2
+	BEQ	T2, ZERO, nocgo
 
 	MOV	ZERO, A3		// arg 3: not used
 	MOV	ZERO, A2		// arg 2: not used
 	MOV	$setg_gcc<>(SB), A1	// arg 1: setg
 	MOV	g, A0			// arg 0: G
-	JALR	RA, T0
+	JALR	RA, T2
 
 nocgo:
 	// update stackguard after _cgo_init
@@ -335,16 +274,6 @@ TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
 	MOV	ZERO, CTXT
 	JMP	runtime·morestack(SB)
 
-// AES hashing not implemented for riscv64
-TEXT runtime·memhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-32
-	JMP	runtime·memhashFallback<ABIInternal>(SB)
-TEXT runtime·strhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·strhashFallback<ABIInternal>(SB)
-TEXT runtime·memhash32<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash32Fallback<ABIInternal>(SB)
-TEXT runtime·memhash64<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash64Fallback<ABIInternal>(SB)
-
 // restore state from Gobuf; longjmp
 
 // func gogo(buf *gobuf)
@@ -421,9 +350,9 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
 // Call fn(arg) aligned appropriately for the gcc ABI.
 // Called on a system stack, and there may be no g yet (during needm).
 TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
-	MOV	fn+0(FP), X5
+	MOV	fn+0(FP), X11
 	MOV	arg+8(FP), X10
-	JALR	RA, (X5)
+	JALR	RA, (X11)
 	RET
 
 // func asmcgocall(fn, arg unsafe.Pointer) int32
@@ -431,7 +360,7 @@ TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
 // aligned appropriately for the gcc ABI.
 // See cgocall.go for more details.
 TEXT ·asmcgocall(SB),NOSPLIT,$0-20
-	MOV	fn+0(FP), X5
+	MOV	fn+0(FP), X11
 	MOV	arg+8(FP), X10
 
 	MOV	X2, X8	// save original stack pointer
@@ -441,6 +370,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	// We get called to create new OS threads too, and those
 	// come in on the m->g0 stack already. Or we might already
 	// be on the m->gsignal stack.
+	BEQZ	g, nosave
 	MOV	g_m(g), X6
 	MOV	m_gsignal(X6), X7
 	BEQ	X7, g, g0
@@ -461,7 +391,7 @@ g0:
 	SUB	X8, X9, X8
 	MOV	X8, 8(X2)	// save depth in old g stack (can't just save SP, as stack might be copied during a callback)
 
-	JALR	RA, (X5)
+	JALR	RA, (X11)
 
 	// Restore g, stack pointer. X10 is return value.
 	MOV	0(X2), g
@@ -474,6 +404,20 @@ g0:
 	MOVW	X10, ret+16(FP)
 	RET
 
+nosave:
+	// Running on a system stack, perhaps even without a g.
+	// Having no g can happen during thread creation or thread teardown.
+	MOV	fn+0(FP), X11
+	MOV	arg+8(FP), X10
+	MOV	X2, X8
+	SUB	$16, X2
+	MOV	ZERO, 0(X2)	// Where above code stores g, in case someone looks during debugging.
+	MOV	X8, 8(X2)	// Save original stack pointer.
+	JALR	RA, (X11)
+	MOV	8(X2), X2	// Restore stack pointer.
+	MOVW	X10, ret+16(FP)
+	RET
+
 // func asminit()
 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
 	RET
@@ -785,11 +729,6 @@ TEXT runtime·setg(SB), NOSPLIT, $0-8
 	CALL	runtime·save_g(SB)
 	RET
 
-TEXT ·checkASM(SB),NOSPLIT,$0-1
-	MOV	$1, T0
-	MOV	T0, ret+0(FP)
-	RET
-
 // spillArgs stores return values from registers to a *internal/abi.RegArgs in X25.
 TEXT ·spillArgs(SB),NOSPLIT,$0-0
 	MOV	X10, (0*8)(X25)

package/bin/go/src/runtime/asm_s390x.s

@@ -34,28 +34,12 @@ TEXT _rt0_s390x_lib(SB), NOSPLIT|NOFRAME, $0
 	FMOVD	F14, 64(R15)
 	FMOVD	F15, 72(R15)
 
-	// Synchronous initialization.
-	MOVD	$runtime·libpreinit(SB), R1
-	BL	R1
-
-	// Create a new thread to finish Go runtime initialization.
-	MOVD	_cgo_sys_thread_create(SB), R1
-	CMP	R1, $0
-	BEQ	nocgo
-	MOVD	$_rt0_s390x_lib_go(SB), R2
-	MOVD	$0, R3
-	BL	R1
-	BR	restore
+	// Initialize g as nil in case of using g later e.g. sigaction in cgo_sigaction.go
+	XOR	g, g
 
-nocgo:
-	MOVD	$0x800000, R1              // stacksize
-	MOVD	R1, 0(R15)
-	MOVD	$_rt0_s390x_lib_go(SB), R1
-	MOVD	R1, 8(R15)                 // fn
-	MOVD	$runtime·newosproc(SB), R1
+	MOVD	$runtime·libInit(SB), R1
 	BL	R1
 
-restore:
 	// Restore F8-F15 from our stack frame.
 	FMOVD	16(R15), F8
 	FMOVD	24(R15), F9
@@ -71,9 +55,9 @@ restore:
 	LMG	48(R15), R6, R15
 	RET
 
-// _rt0_s390x_lib_go initializes the Go runtime.
+// rt0_lib_go initializes the Go runtime.
 // This is started in a separate thread by _rt0_s390x_lib.
-TEXT _rt0_s390x_lib_go(SB), NOSPLIT|NOFRAME, $0
+TEXT runtime·rt0_lib_go<ABIInternal>(SB), NOSPLIT|NOFRAME, $0
 	MOVD	_rt0_s390x_lib_argc<>(SB), R2
 	MOVD	_rt0_s390x_lib_argv<>(SB), R3
 	MOVD	$runtime·rt0_go(SB), R1
@@ -81,7 +65,7 @@ TEXT _rt0_s390x_lib_go(SB), NOSPLIT|NOFRAME, $0
 
 DATA _rt0_s390x_lib_argc<>(SB)/8, $0
 GLOBL _rt0_s390x_lib_argc<>(SB), NOPTR, $8
-DATA _rt0_s90x_lib_argv<>(SB)/8, $0
+DATA _rt0_s390x_lib_argv<>(SB)/8, $0
 GLOBL _rt0_s390x_lib_argv<>(SB), NOPTR, $8
 
 TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
@@ -206,11 +190,7 @@ TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
 TEXT runtime·mcall<ABIInternal>(SB), NOSPLIT, $-8-8
-#ifdef GOEXPERIMENT_regabiargs
 	MOVD	R2, R12				// context
-#else
-	MOVD	fn+0(FP), R12			// context
-#endif
 	// Save caller state in g->sched
 	MOVD	R15, (g_sched+gobuf_sp)(g)
 	MOVD	LR, (g_sched+gobuf_pc)(g)
@@ -552,6 +532,7 @@ TEXT ·asmcgocall(SB),NOSPLIT,$0-20
 	// We get called to create new OS threads too, and those
 	// come in on the m->g0 stack already. Or we might already
 	// be on the m->gsignal stack.
+	CMPBEQ	g, $0, nosave
 	MOVD	g_m(g), R6
 	MOVD	m_gsignal(R6), R7
 	CMPBEQ	R7, g, g0
@@ -589,6 +570,48 @@ g0:
 	MOVW	R2, ret+16(FP)
 	RET
 
+nosave:
+	// Running on a system stack, perhaps even without a g.
+	// Having no g can happen during thread creation or thread teardown.
+	MOVD	fn+0(FP), R3
+	MOVD	arg+8(FP), R4
+	MOVD	R15, R2
+	SUB	$176, R15
+	MOVD	$~7, R6
+	AND	R6, R15
+	MOVD	$0, 168(R15)	// Where above code stores g, in case someone looks during debugging.
+	MOVD	R2, 160(R15)	// Save original stack pointer.
+	MOVD	$0, 0(R15)	// clear back chain pointer
+	MOVD	R4, R2		// arg in R2
+	BL	R3
+	XOR	R0, R0
+	MOVD	160(R15), R15	// Restore stack pointer.
+	MOVW	R2, ret+16(FP)
+	RET
+
+// func asmcgocall_no_g(fn, arg unsafe.Pointer)
+// Call fn(arg) aligned appropriately for the gcc ABI.
+// Called on a system stack, and there may be no g yet.
+TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16
+	MOVD	fn+0(FP), R3
+	MOVD	arg+8(FP), R4
+
+	MOVD	R15, R2		// Save original stack pointer.
+
+	// Save room for the stack pointer, plus 160 bytes of callee
+	// save area that lives on the caller stack.
+	SUB	$168, R15
+	MOVD	$~7, R6
+	AND	R6, R15
+
+	MOVD	R2, 160(R15)	// Save original stack pointer.
+	MOVD	$0, 0(R15)	// clear back chain pointer
+	MOVD	R4, R2		// arg in R2
+	BL	R3
+	XOR	R0, R0
+	MOVD	160(R15), R15	// Restore stack pointer.
+	RET
+
 // cgocallback(fn, frame unsafe.Pointer, ctxt uintptr)
 // See cgocall.go for more details.
 TEXT ·cgocallback(SB),NOSPLIT,$24-24
@@ -763,7 +786,6 @@ TEXT runtime·cputicks(SB),NOSPLIT,$0-8
 	MOVD	R3, ret+0(FP)
 	RET
 
-#ifdef GOEXPERIMENT_regabiargs
 // spillArgs stores return values from registers to a *internal/abi.RegArgs in R10.
 TEXT runtime·spillArgs(SB),NOSPLIT,$0-0
 	MOVD	R2, 0(R10)
@@ -819,24 +841,6 @@ TEXT runtime·unspillArgs(SB),NOSPLIT,$0-0
 	FMOVD	176(R10), F14
 	FMOVD	184(R10), F15
 	RET
-#else
-
-TEXT runtime·spillArgs(SB),NOSPLIT,$0-0
-        RET
-
-TEXT runtime·unspillArgs(SB),NOSPLIT,$0-0
-        RET
-#endif
-
-// AES hashing not implemented for s390x
-TEXT runtime·memhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-32
-	JMP	runtime·memhashFallback<ABIInternal>(SB)
-TEXT runtime·strhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·strhashFallback<ABIInternal>(SB)
-TEXT runtime·memhash32<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash32Fallback<ABIInternal>(SB)
-TEXT runtime·memhash64<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash64Fallback<ABIInternal>(SB)
 
 // Called from cgo wrappers, this function returns g->m->curg.stack.hi.
 // Must obey the gcc calling convention.
@@ -890,10 +894,6 @@ TEXT runtime·addmoduledata(SB),NOSPLIT|NOFRAME,$0-0
 	LMG	48(R15), R6, R15
 	RET
 
-TEXT ·checkASM(SB),NOSPLIT,$0-1
-	MOVB	$1, ret+0(FP)
-	RET
-
 // gcWriteBarrier informs the GC about heap pointer writes.
 //
 // gcWriteBarrier does NOT follow the Go ABI. It accepts the

package/bin/go/src/runtime/asm_wasm.s

@@ -32,11 +32,6 @@ TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
 DATA  runtime·mainPC+0(SB)/8,$runtime·main(SB)
 GLOBL runtime·mainPC(SB),RODATA,$8
 
-// func checkASM() bool
-TEXT ·checkASM(SB), NOSPLIT, $0-1
-	MOVB $1, ret+0(FP)
-	RET
-
 TEXT runtime·gogo(SB), NOSPLIT, $0-8
 	MOVD buf+0(FP), R0
 	MOVD gobuf_g(R0), R1
@@ -183,16 +178,6 @@ TEXT runtime·systemstack_switch(SB), NOSPLIT, $0-0
 TEXT runtime·abort(SB),NOSPLIT|NOFRAME,$0-0
 	UNDEF
 
-// AES hashing not implemented for wasm
-TEXT runtime·memhash(SB),NOSPLIT|NOFRAME,$0-32
-	JMP	runtime·memhashFallback(SB)
-TEXT runtime·strhash(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·strhashFallback(SB)
-TEXT runtime·memhash32(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash32Fallback(SB)
-TEXT runtime·memhash64(SB),NOSPLIT|NOFRAME,$0-24
-	JMP	runtime·memhash64Fallback(SB)
-
 TEXT runtime·asminit(SB), NOSPLIT, $0-0
 	// No per-thread init.
 	RET

package/bin/go/src/runtime/atomic_riscv64.s

@@ -6,5 +6,5 @@
 
 // func publicationBarrier()
 TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
-	FENCE
+	FENCE	W, W
 	RET

package/bin/go/src/runtime/cgo/abi_riscv64.h

@@ -0,0 +1,72 @@
+// Copyright 2026 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.
+
+// Macros for transitioning from the host ABI to Go ABI0.
+//
+// These macros save and restore the callee-saved registers
+// from the stack, but they don't adjust stack pointer, so
+// the user should prepare stack space in advance.
+// SAVE_GPR(offset) saves X8, X9, X18-X27 to the stack space
+// of ((offset)+0*8)(X2) ~ ((offset)+11*8)(X2).
+//
+// SAVE_FPR(offset) saves F8, F9, F18-F27 to the stack space
+// of ((offset)+0*8)(X2) ~ ((offset)+11*8)(X2).
+//
+// Note: g is X27
+
+#define SAVE_GPR(offset) \
+	MOV X8, ((offset)+0*8)(X2)   \
+	MOV X9, ((offset)+1*8)(X2)   \
+	MOV X18, ((offset)+2*8)(X2)  \
+	MOV X19, ((offset)+3*8)(X2)  \
+	MOV X20, ((offset)+4*8)(X2)  \
+	MOV X21, ((offset)+5*8)(X2)  \
+	MOV X22, ((offset)+6*8)(X2)  \
+	MOV X23, ((offset)+7*8)(X2)  \
+	MOV X24, ((offset)+8*8)(X2)  \
+	MOV X25, ((offset)+9*8)(X2)  \
+	MOV X26, ((offset)+10*8)(X2) \
+	MOV g, ((offset)+11*8)(X2)
+
+#define RESTORE_GPR(offset) \
+	MOV ((offset)+0*8)(X2), X8   \
+	MOV ((offset)+1*8)(X2), X9   \
+	MOV ((offset)+2*8)(X2), X18  \
+	MOV ((offset)+3*8)(X2), X19  \
+	MOV ((offset)+4*8)(X2), X20  \
+	MOV ((offset)+5*8)(X2), X21  \
+	MOV ((offset)+6*8)(X2), X22  \
+	MOV ((offset)+7*8)(X2), X23  \
+	MOV ((offset)+8*8)(X2), X24  \
+	MOV ((offset)+9*8)(X2), X25  \
+	MOV ((offset)+10*8)(X2), X26 \
+	MOV ((offset)+11*8)(X2), g
+
+#define SAVE_FPR(offset) \
+	MOVD F8, ((offset)+0*8)(X2)   \
+	MOVD F9, ((offset)+1*8)(X2)   \
+	MOVD F18, ((offset)+2*8)(X2)  \
+	MOVD F19, ((offset)+3*8)(X2)  \
+	MOVD F20, ((offset)+4*8)(X2)  \
+	MOVD F21, ((offset)+5*8)(X2)  \
+	MOVD F22, ((offset)+6*8)(X2)  \
+	MOVD F23, ((offset)+7*8)(X2)  \
+	MOVD F24, ((offset)+8*8)(X2)  \
+	MOVD F25, ((offset)+9*8)(X2)  \
+	MOVD F26, ((offset)+10*8)(X2) \
+	MOVD F27, ((offset)+11*8)(X2)
+
+#define RESTORE_FPR(offset) \
+	MOVD ((offset)+0*8)(X2), F8   \
+	MOVD ((offset)+1*8)(X2), F9   \
+	MOVD ((offset)+2*8)(X2), F18  \
+	MOVD ((offset)+3*8)(X2), F19  \
+	MOVD ((offset)+4*8)(X2), F20  \
+	MOVD ((offset)+5*8)(X2), F21  \
+	MOVD ((offset)+6*8)(X2), F22  \
+	MOVD ((offset)+7*8)(X2), F23  \
+	MOVD ((offset)+8*8)(X2), F24  \
+	MOVD ((offset)+9*8)(X2), F25  \
+	MOVD ((offset)+10*8)(X2), F26 \
+	MOVD ((offset)+11*8)(X2), F27