1// Copyright 2022 The Go Authors. All rights reserved.2// Use of this source code is governed by a BSD-style3// license that can be found in the LICENSE file.45//6// System calls and other sys.stuff for loong64, Linux7//89#include "go_asm.h"10#include "go_tls.h"11#include "textflag.h"12#include "cgo/abi_loong64.h"1314#define AT_FDCWD	-10015#define CLOCK_REALTIME	016#define CLOCK_MONOTONIC	11718#define SYS_exit		9319#define SYS_read		6320#define SYS_write		6421#define SYS_close		5722#define SYS_getpid		17223#define SYS_kill		12924#define SYS_mmap		22225#define SYS_munmap		21526#define SYS_setitimer		10327#define SYS_clone		22028#define SYS_nanosleep		10129#define SYS_sched_yield		12430#define SYS_rt_sigreturn	13931#define SYS_rt_sigaction	13432#define SYS_rt_sigprocmask	13533#define SYS_sigaltstack		13234#define SYS_madvise		23335#define SYS_mincore		23236#define SYS_gettid		17837#define SYS_futex		9838#define SYS_sched_getaffinity	12339#define SYS_exit_group		9440#define SYS_tgkill		13141#define SYS_openat		5642#define SYS_clock_gettime	11343#define SYS_brk			21444#define SYS_pipe2		5945#define SYS_timer_create	10746#define SYS_timer_settime	11047#define SYS_timer_delete	1114849// func exit(code int32)50TEXT runtime·exit<ABIInternal>(SB),NOSPLIT,$051	MOVV	$SYS_exit_group, R1152	SYSCALL53	RET5455// func exitThread(wait *atomic.Uint32)56TEXT runtime·exitThread<ABIInternal>(SB),NOSPLIT|NOFRAME,$057	// We're done using the stack.58	DBAR	$0x12	// StoreRelease barrier59	MOVW	R0, (R4)60	MOVW	$0, R4	// exit code61	MOVV	$SYS_exit, R1162	SYSCALL63	JMP	0(PC)6465// func open(name *byte, mode, perm int32) int3266TEXT runtime·open<ABIInternal>(SB),NOSPLIT,$067	// before:68	//    R4:  name, R5: mode, R6: perm69	// after:70	//    R4: AT_FDCWD, R5: name, R6: mode, R7: perm71	MOVW	R6, R772	MOVW	R5, R673	MOVV	R4, R574	MOVW	$AT_FDCWD, R4 // AT_FDCWD, so this acts like open7576	MOVV	$SYS_openat, R1177	SYSCALL78	MOVW	$-4096, R579	BGEU	R5, R4, 2(PC)80	MOVW	$-1, R481	RET8283// func closefd(fd int32) int3284TEXT runtime·closefd<ABIInternal>(SB),NOSPLIT,$085	MOVV	$SYS_close, R1186	SYSCALL87	MOVW	$-4096, R588	BGEU	R5, R4, 2(PC)89	MOVW	$-1, R490	RET9192// func write1(fd uintptr, p unsafe.Pointer, n int32) int3293TEXT runtime·write1<ABIInternal>(SB),NOSPLIT,$094	MOVV	$SYS_write, R1195	SYSCALL96	RET9798// func read(fd int32, p unsafe.Pointer, n int32) int3299TEXT runtime·read<ABIInternal>(SB),NOSPLIT,$0100	MOVV	$SYS_read, R11101	SYSCALL102	RET103104// func pipe2(flags int32) (r, w int32, errno int32)105TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20106	MOVV	$r+8(FP), R4107	MOVW	flags+0(FP), R5108	MOVV	$SYS_pipe2, R11109	SYSCALL110	MOVW	R4, errno+16(FP)111	RET112113// func usleep(usec uint32)114TEXT runtime·usleep<ABIInternal>(SB),NOSPLIT,$16115	MOVV	$1000, R6116	MULVU	R6, R4, R4117	MOVV	$1000000000, R6118119	DIVVU	R6, R4, R5	// ts->tv_sec120	REMVU	R6, R4, R8	// ts->tv_nsec121	MOVV	R5, 8(R3)122	MOVV	R8, 16(R3)123124	// nanosleep(&ts, 0)125	ADDV	$8, R3, R4126	MOVV	R0, R5127	MOVV	$SYS_nanosleep, R11128	SYSCALL129	RET130131// func gettid() uint32132TEXT runtime·gettid<ABIInternal>(SB),NOSPLIT,$0133	MOVV	$SYS_gettid, R11134	SYSCALL135	RET136137// func raise(sig uint32)138TEXT runtime·raise<ABIInternal>(SB),NOSPLIT,$0139	MOVW	R4, R24 // backup sig140	MOVV	$SYS_getpid, R11141	SYSCALL142	MOVW	R4, R23143	MOVV	$SYS_gettid, R11144	SYSCALL145	MOVW	R4, R5	// arg 2 tid146	MOVW	R23, R4	// arg 1 pid147	MOVW	R24, R6	// arg 3148	MOVV	$SYS_tgkill, R11149	SYSCALL150	RET151152// func raiseproc(sig uint32)153TEXT runtime·raiseproc<ABIInternal>(SB),NOSPLIT,$0154	MOVW	R4, R24 // backup sig155	MOVV	$SYS_getpid, R11156	SYSCALL157	//MOVW	R4, R4	// arg 1 pid158	MOVW	R24, R5	// arg 2159	MOVV	$SYS_kill, R11160	SYSCALL161	RET162163// func getpid() int164TEXT ·getpid<ABIInternal>(SB),NOSPLIT,$0165	MOVV	$SYS_getpid, R11166	SYSCALL167	RET168169// func tgkill(tgid, tid, sig int)170TEXT ·tgkill<ABIInternal>(SB),NOSPLIT,$0171	MOVV	$SYS_tgkill, R11172	SYSCALL173	RET174175// func setitimer(mode int32, new, old *itimerval)176TEXT runtime·setitimer<ABIInternal>(SB),NOSPLIT,$0177	MOVV	$SYS_setitimer, R11178	SYSCALL179	RET180181// func timer_create(clockid int32, sevp *sigevent, timerid *int32) int32182TEXT runtime·timer_create<ABIInternal>(SB),NOSPLIT,$0183	MOVV	$SYS_timer_create, R11184	SYSCALL185	RET186187// func timer_settime(timerid int32, flags int32, new, old *itimerspec) int32188TEXT runtime·timer_settime<ABIInternal>(SB),NOSPLIT,$0189	MOVV	$SYS_timer_settime, R11190	SYSCALL191	RET192193// func timer_delete(timerid int32) int32194TEXT runtime·timer_delete<ABIInternal>(SB),NOSPLIT,$0195	MOVV	$SYS_timer_delete, R11196	SYSCALL197	RET198199// func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32200TEXT runtime·mincore<ABIInternal>(SB),NOSPLIT,$0201	MOVV	$SYS_mincore, R11202	SYSCALL203	RET204205// func walltime() (sec int64, nsec int32)206TEXT runtime·walltime<ABIInternal>(SB),NOSPLIT,$24207	MOVV	R3, R23	// R23 is unchanged by C code208209	MOVV	g_m(g), R24	// R24 = m210211	// Set vdsoPC and vdsoSP for SIGPROF traceback.212	// Save the old values on stack and restore them on exit,213	// so this function is reentrant.214	MOVV	m_vdsoPC(R24), R11215	MOVV	m_vdsoSP(R24), R7216	MOVV	R11, 8(R3)217	MOVV	R7, 16(R3)218219	MOVV    $ret-8(FP), R11 // caller's SP220	MOVV	R1, m_vdsoPC(R24)221	MOVV	R11, m_vdsoSP(R24)222223	MOVV	m_curg(R24), R4224	BNE	R4, g, noswitch225226	MOVV	m_g0(R24), R4227	MOVV	(g_sched+gobuf_sp)(R4), R3	// Set SP to g0 stack228229noswitch:230	SUBV	$16, R3231	AND	$~15, R3	// Align for C code232233	MOVW	$CLOCK_REALTIME, R4234	MOVV	$0(R3), R5235236	MOVV	runtime·vdsoClockgettimeSym(SB), R20237	BEQ	R20, fallback238239	// Store g on gsignal's stack, see sys_linux_arm64.s for detail240	MOVBU	runtime·iscgo(SB), R25241	BNE	R25, nosaveg242243	MOVV	m_gsignal(R24), R25	// g.m.gsignal244	BEQ	R25, nosaveg245	BEQ	g, R25, nosaveg246247	MOVV	(g_stack+stack_lo)(R25), R25	// g.m.gsignal.stack.lo248	MOVV	g, (R25)249250	JAL	(R20)251252	MOVV	R0, (R25)253	JMP	finish254255nosaveg:256	JAL	(R20)257258finish:259	MOVV	0(R3), R4	// sec260	MOVV	8(R3), R5	// nsec261262	MOVV	R23, R3	// restore SP263	// Restore vdsoPC, vdsoSP264	// We don't worry about being signaled between the two stores.265	// If we are not in a signal handler, we'll restore vdsoSP to 0,266	// and no one will care about vdsoPC. If we are in a signal handler,267	// we cannot receive another signal.268	MOVV	16(R3), R25269	MOVV	R25, m_vdsoSP(R24)270	MOVV	8(R3), R25271	MOVV	R25, m_vdsoPC(R24)272273	RET274275fallback:276	MOVV	$SYS_clock_gettime, R11277	SYSCALL278	JMP finish279280// func nanotime1() int64281TEXT runtime·nanotime1<ABIInternal>(SB),NOSPLIT,$24282	MOVV	R3, R23	// R23 is unchanged by C code283284	MOVV	g_m(g), R24	// R24 = m285286	// Set vdsoPC and vdsoSP for SIGPROF traceback.287	// Save the old values on stack and restore them on exit,288	// so this function is reentrant.289	MOVV	m_vdsoPC(R24), R11290	MOVV	m_vdsoSP(R24), R7291	MOVV	R11, 8(R3)292	MOVV	R7, 16(R3)293294	MOVV    $ret-8(FP), R11 // caller's SP295	MOVV	R1, m_vdsoPC(R24)296	MOVV	R11, m_vdsoSP(R24)297298	MOVV	m_curg(R24), R4299	BNE	R4, g, noswitch300301	MOVV	m_g0(R24), R4302	MOVV	(g_sched+gobuf_sp)(R4), R3	// Set SP to g0 stack303304noswitch:305	SUBV	$16, R3306	AND	$~15, R3	// Align for C code307308	MOVW	$CLOCK_MONOTONIC, R4309	MOVV	$0(R3), R5310311	MOVV	runtime·vdsoClockgettimeSym(SB), R20312	BEQ	R20, fallback313314	// Store g on gsignal's stack, see sys_linux_arm64.s for detail315	MOVBU	runtime·iscgo(SB), R25316	BNE	R25, nosaveg317318	MOVV	m_gsignal(R24), R25	// g.m.gsignal319	BEQ	R25, nosaveg320	BEQ	g, R25, nosaveg321322	MOVV	(g_stack+stack_lo)(R25), R25	// g.m.gsignal.stack.lo323	MOVV	g, (R25)324325	JAL	(R20)326327	MOVV	R0, (R25)328	JMP	finish329330nosaveg:331	JAL	(R20)332333finish:334	MOVV	0(R3), R7	// sec335	MOVV	8(R3), R5	// nsec336337	MOVV	R23, R3	// restore SP338	// Restore vdsoPC, vdsoSP339	// We don't worry about being signaled between the two stores.340	// If we are not in a signal handler, we'll restore vdsoSP to 0,341	// and no one will care about vdsoPC. If we are in a signal handler,342	// we cannot receive another signal.343	MOVV	16(R3), R25344	MOVV	R25, m_vdsoSP(R24)345	MOVV	8(R3), R25346	MOVV	R25, m_vdsoPC(R24)347348	// sec is in R7, nsec in R5349	// return nsec in R7350	MOVV	$1000000000, R4351	MULVU	R4, R7, R7352	ADDVU	R5, R7, R4353	RET354355fallback:356	MOVV	$SYS_clock_gettime, R11357	SYSCALL358	JMP	finish359360// func rtsigprocmask(how int32, new, old *sigset, size int32)361TEXT runtime·rtsigprocmask<ABIInternal>(SB),NOSPLIT,$0362	MOVV	$SYS_rt_sigprocmask, R11363	SYSCALL364	MOVW	$-4096, R5365	BGEU	R5, R4, 2(PC)366	MOVV	R0, 0xf1(R0)	// crash367	RET368369// func rt_sigaction(sig uintptr, new, old *sigactiont, size uintptr) int32370TEXT runtime·rt_sigaction<ABIInternal>(SB),NOSPLIT,$0371	MOVV	$SYS_rt_sigaction, R11372	SYSCALL373	RET374375// Call the function stored in _cgo_sigaction using the GCC calling convention.376TEXT runtime·callCgoSigaction<ABIInternal>(SB),NOSPLIT,$0377	// R4: sig, R5: new, R6: old378	MOVV    _cgo_sigaction(SB), R7379	SUBV    $16, R3 // reserve 16 bytes for sp-8 where fp may be saved.380	JAL     (R7)381	ADDV    $16, R3382	MOVW    R4, R4383	RET384385// func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)386TEXT runtime·sigfwd<ABIInternal>(SB),NOSPLIT,$0387	// before:388	//    R4:  fn, R5: sig, R6: info, R7: ctx389	// after:390	//    R20: fn, R4: sig, R5: info, R6: ctx391	MOVV	R4, R20392	MOVV	R5, R4393	MOVV	R6, R5394	MOVV	R7, R6395	JAL	(R20)396	RET397398// Called from c-abi, R4: sig, R5: info, R6: cxt399// func sigtramp(signo, ureg, ctxt unsafe.Pointer)400TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$168401	// Save callee-save registers in the case of signal forwarding.402	// Please refer to https://golang.org/issue/31827 .403	SAVE_R22_TO_R31((4*8))404	SAVE_F24_TO_F31((14*8))405406	// this might be called in external code context,407	// where g is not set.408	MOVB	runtime·iscgo(SB), R7409	BEQ	R7, 2(PC)410	JAL	runtime·load_g(SB)411412	// R5 and R6 already contain info and ctx, respectively.413	MOVV	$runtime·sigtrampgo<ABIInternal>(SB), R7414	JAL	(R7)415416	// Restore callee-save registers.417	RESTORE_R22_TO_R31((4*8))418	RESTORE_F24_TO_F31((14*8))419420	RET421422// Called from c-abi, R4: sig, R5: info, R6: cxt423TEXT runtime·sigprofNonGoWrapper<>(SB),NOSPLIT,$168424	// Save callee-save registers because it's a callback from c code.425	SAVE_R22_TO_R31((4*8))426	SAVE_F24_TO_F31((14*8))427428	// R4, R5 and R6 already contain sig, info and ctx, respectively.429	CALL	runtime·sigprofNonGo<ABIInternal>(SB)430431	// Restore callee-save registers.432	RESTORE_R22_TO_R31((4*8))433	RESTORE_F24_TO_F31((14*8))434	RET435436// Called from c-abi, R4: sig, R5: info, R6: cxt437TEXT runtime·cgoSigtramp(SB),NOSPLIT|NOFRAME,$0438	// The stack unwinder, presumably written in C, may not be able to439	// handle Go frame correctly. So, this function is NOFRAME, and we440	// save/restore LR manually.441	MOVV	R1, R12442	// Save R30, g because they will be clobbered,443	// we need to restore them before jump to sigtramp.444	MOVV	R30, R13445	MOVV	g, R14446447	// If no traceback function, do usual sigtramp.448	MOVV	runtime·cgoTraceback(SB), R15449	BEQ	R15, sigtramp450451	// If no traceback support function, which means that452	// runtime/cgo was not linked in, do usual sigtramp.453	MOVV	_cgo_callers(SB), R15454	BEQ	R15, sigtramp455456	// Figure out if we are currently in a cgo call.457	// If not, just do usual sigtramp.458	CALL	runtime·load_g(SB)459	BEQ	g, sigtrampnog // g == nil460461	MOVV	g_m(g), R15462	BEQ	R15, sigtramp    // g.m == nil463	MOVW	m_ncgo(R15), R16464	BEQ	R16, sigtramp    // g.m.ncgo = 0465	MOVV	m_curg(R15), R16466	BEQ	R16, sigtramp    // g.m.curg == nil467	MOVV	g_syscallsp(R16), R17468	BEQ     R17, sigtramp    // g.m.curg.syscallsp == 0469	MOVV	m_cgoCallers(R15), R8 // R8 is the fifth arg in C calling convention.470	BEQ	R8, sigtramp    // g.m.cgoCallers == nil471	MOVW	m_cgoCallersUse(R15), R16472	BNE	R16, sigtramp    // g.m.cgoCallersUse != 0473474	// Jump to a function in runtime/cgo.475	// That function, written in C, will call the user's traceback476	// function with proper unwind info, and will then call back here.477	// The first three arguments, and the fifth, are already in registers.478	// Set the two remaining arguments now.479	MOVV	runtime·cgoTraceback(SB), R7480	MOVV	$runtime·sigtramp(SB), R9481	MOVV	_cgo_callers(SB), R15482	MOVV	R12, R1 // restore483	MOVV	R13, R30484	MOVV	R14, g485	JMP	(R15)486487sigtramp:488	MOVV	R12, R1 // restore489	MOVV	R13, R30490	MOVV	R14, g491	JMP	runtime·sigtramp(SB)492493sigtrampnog:494	// Signal arrived on a non-Go thread. If this is SIGPROF, get a495	// stack trace.496	MOVW    $27, R15 // 27 == SIGPROF497	BNE     R4, R15, sigtramp498499	MOVV    $runtime·sigprofCallersUse(SB), R16500	DBAR	$0x14501cas_again:502	MOVV    $1, R15503	LL	(R16), R17504	BNE	R17, fail505	SC	R15, (R16)506	BEQ	R15, cas_again507	DBAR    $0x14508509	// Jump to the traceback function in runtime/cgo.510	// It will call back to sigprofNonGo, which will ignore the511	// arguments passed in registers.512	// First three arguments to traceback function are in registers already.513	MOVV	runtime·cgoTraceback(SB), R7514	MOVV	$runtime·sigprofCallers(SB), R8515	MOVV	$runtime·sigprofNonGoWrapper<>(SB), R9516	MOVV	_cgo_callers(SB), R15517	MOVV	R12, R1 // restore518	MOVV	R13, R30519	MOVV	R14, g520	JMP	(R15)521522fail:523	DBAR    $0x14524	JMP     sigtramp525526// func sysMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)527TEXT runtime·sysMmap<ABIInternal>(SB),NOSPLIT,$0528	MOVV	$SYS_mmap, R11529	SYSCALL530	MOVW	$-4096, R5531	BGEU	R5, R4, ok532	SUBVU	R4, R0, R5533	MOVV	$0, R4534	RET535ok:536	MOVV	$0, R5537	RET538539// Call the function stored in _cgo_mmap using the GCC calling convention.540// This must be called on the system stack.541// func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uintptr542TEXT runtime·callCgoMmap<ABIInternal>(SB),NOSPLIT,$0543	MOVV	_cgo_mmap(SB), R13544	SUBV	$16, R3		// reserve 16 bytes for sp-8 where fp may be saved.545	JAL	(R13)546	ADDV	$16, R3547	MOVV	R4, R4548	RET549550// func sysMunmap(addr unsafe.Pointer, n uintptr)551TEXT runtime·sysMunmap<ABIInternal>(SB),NOSPLIT,$0552	MOVV	$SYS_munmap, R11553	SYSCALL554	MOVW	$-4096, R5555	BGEU	R5, R4, 2(PC)556	MOVV	R0, 0xf3(R0)	// crash557	RET558559// Call the function stored in _cgo_munmap using the GCC calling convention.560// This must be called on the system stack.561// func callCgoMunmap(addr unsafe.Pointer, n uintptr)562TEXT runtime·callCgoMunmap<ABIInternal>(SB),NOSPLIT,$0563	MOVV	_cgo_munmap(SB), R13564	SUBV	$16, R3		// reserve 16 bytes for sp-8 where fp may be saved.565	JAL	(R13)566	ADDV	$16, R3567	RET568569// func madvise(addr unsafe.Pointer, n uintptr, flags int32)570TEXT runtime·madvise<ABIInternal>(SB),NOSPLIT,$0571	MOVV	$SYS_madvise, R11572	SYSCALL573	RET574575// func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32576TEXT runtime·futex<ABIInternal>(SB),NOSPLIT,$0577	MOVV	$SYS_futex, R11578	SYSCALL579	RET580581// int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));582TEXT runtime·clone<ABIInternal>(SB),NOSPLIT,$0583	// Copy mp, gp, fn off parent stack for use by child.584	// Careful: Linux system call clobbers ???.585	MOVV	R6, R23586	MOVV	R7, R24587	MOVV	R8, R25588589	MOVV	R23, -8(R5)590	MOVV	R24, -16(R5)591	MOVV	R25, -24(R5)592	MOVV	$1234, R23593	MOVV	R23, -32(R5)594595	MOVV	$SYS_clone, R11596	SYSCALL597598	// In parent, return.599	BEQ	R4, 2(PC)600	RET601602	// In child, on new stack.603	MOVV	-32(R3), R23604	MOVV	$1234, R19605	BEQ	R23, R19, 2(PC)606	MOVV	R0, 0(R0)607608	// Initialize m->procid to Linux tid609	MOVV	$SYS_gettid, R11610	SYSCALL611612	MOVV	-24(R3), R25		// fn613	MOVV	-16(R3), R24		// g614	MOVV	-8(R3), R23		// m615616	BEQ	R23, nog617	BEQ	R24, nog618619	MOVV	R4, m_procid(R23)620621	// TODO: setup TLS.622623	// In child, set up new stack624	MOVV	R23, g_m(R24)625	MOVV	R24, g626	//CALL	runtime·stackcheck(SB)627628nog:629	// Call fn630	JAL	(R25)631632	// It shouldn't return.	 If it does, exit that thread.633	MOVW	$111, R4634	MOVV	$SYS_exit, R11635	SYSCALL636	JMP	-3(PC)	// keep exiting637638// func sigaltstack(new, old *stackt)639TEXT runtime·sigaltstack<ABIInternal>(SB),NOSPLIT,$0640	MOVV	$SYS_sigaltstack, R11641	SYSCALL642	MOVW	$-4096, R5643	BGEU	R5, R4, 2(PC)644	MOVV	R0, 0xf1(R0)	// crash645	RET646647// func osyield()648TEXT runtime·osyield<ABIInternal>(SB),NOSPLIT,$0649	MOVV	$SYS_sched_yield, R11650	SYSCALL651	RET652653// func sched_getaffinity(pid, len uintptr, buf *uintptr) int32654TEXT runtime·sched_getaffinity<ABIInternal>(SB),NOSPLIT,$0655	MOVV	$SYS_sched_getaffinity, R11656	SYSCALL657	RET658659// func sbrk0() uintptr660TEXT runtime·sbrk0<ABIInternal>(SB),NOSPLIT,$0661	// Implemented as brk(NULL).662	MOVV	$0, R4663	MOVV	$SYS_brk, R11664	SYSCALL665	RET666667// unimplemented, only needed for android; declared in stubs_linux.go668TEXT runtime·access(SB),$0-20669	MOVV	R0, 2(R0)670	MOVW	R0, ret+16(FP) // for vet671	RET672673// unimplemented, only needed for android; declared in stubs_linux.go674TEXT runtime·connect(SB),$0-28675	MOVV	R0, 2(R0)676	MOVW	R0, ret+24(FP) // for vet677	RET678679// unimplemented, only needed for android; declared in stubs_linux.go680TEXT runtime·socket(SB),$0-20681	MOVV	R0, 2(R0)682	MOVW	R0, ret+16(FP) // for vet683	RET684685// func vgetrandom1(buf *byte, length uintptr, flags uint32, state uintptr, stateSize uintptr) int686TEXT runtime·vgetrandom1<ABIInternal>(SB),NOSPLIT,$16687	MOVV	R3, R23688689	MOVV	runtime·vdsoGetrandomSym(SB), R12690691	MOVV	g_m(g), R24692693	MOVV	m_vdsoPC(R24), R13694	MOVV	R13, 8(R3)695	MOVV	m_vdsoSP(R24), R13696	MOVV	R13, 16(R3)697	MOVV	R1, m_vdsoPC(R24)698	MOVV    $buf-8(FP), R13699	MOVV	R13, m_vdsoSP(R24)700701	AND	$~15, R3702703	MOVBU	runtime·iscgo(SB), R13704	BNE	R13, nosaveg705	MOVV	m_gsignal(R24), R13706	BEQ	R13, nosaveg707	BEQ	g, R13, nosaveg708	MOVV	(g_stack+stack_lo)(R13), R25709	MOVV	g, (R25)710711	JAL	(R12)712713	MOVV	R0, (R25)714	JMP	restore715716nosaveg:717	JAL	(R12)718719restore:720	MOVV	R23, R3721	MOVV	16(R3), R25722	MOVV	R25, m_vdsoSP(R24)723	MOVV	8(R3), R25724	MOVV	R25, m_vdsoPC(R24)725	NOP	R4 // Satisfy go vet, since the return value comes from the vDSO function.726	RET