MOVW	R16, (4*4)(R29)
	MOVW	R17, (4*5)(R29)
	MOVW	R18, (4*6)(R29)
	MOVW	R19, (4*7)(R29)
	MOVW	R20, (4*8)(R29)
	MOVW	R21, (4*9)(R29)
	MOVW	R22, (4*10)(R29)
	MOVW	R23, (4*11)(R29)
	MOVW	g, (4*12)(R29)
	MOVW	R31, (4*13)(R29)
#ifndef GOMIPS_softfloat
	MOVD	F20, (4*14)(R29)
	MOVD	F22, (4*14+8*1)(R29)
	MOVD	F24, (4*14+8*2)(R29)
	MOVD	F26, (4*14+8*3)(R29)
	MOVD	F28, (4*14+8*4)(R29)
	MOVD	F30, (4*14+8*5)(R29)
#endif

	JAL	runtime·cgocallback(SB)

	MOVV	(8*4)(R29), R16
	MOVV	(8*5)(R29), R17
	MOVV	(8*6)(R29), R18
	MOVV	(8*7)(R29), R19
	MOVV	(8*8)(R29), R20
	MOVV	(8*9)(R29), R21
	MOVV	(8*10)(R29), R22
	MOVV	(8*11)(R29), R23
	MOVV	(8*12)(R29), RSB
	MOVV	(8*13)(R29), g
	MOVV	(8*14)(R29), R31
#ifndef GOMIPS64_softfloat
	MOVD	(8*15)(R29), F24
	MOVD	(8*16)(R29), F25
	MOVD	(8*17)(R29), F26
	MOVD	(8*18)(R29), F27
	MOVD	(8*19)(R29), F28

	MOVW	a1+4(FP), R4
	MOVW	a2+8(FP), R5
	MOVW	a3+12(FP), R6
	MOVW	a4+16(FP), R7
	MOVW	a5+20(FP), R8
	MOVW	a6+24(FP), R9
	MOVW	a7+28(FP), R10
	MOVW	a8+32(FP), R11
	MOVW	R8, 16(R29)
	MOVW	R9, 20(R29)
	MOVW	R10, 24(R29)
	MOVW	R11, 28(R29)
	MOVW	trap+0(FP), R2	// syscall entry
	MOVW	R0, R3	// reset R3 to zero as 1-ret SYSCALL keeps it
	SYSCALL
	BEQ	R7, ok9
	MOVW	$-1, R1
	MOVW	R1, r1+40(FP)	// r1
	MOVW	R0, r2+44(FP)	// r2

package main

/*
#cgo CFLAGS: -Os

int foo_fpr() {
        asm volatile("":::"fr31","fr30","fr29","fr28");
}
int foo_gpr0() {
        asm volatile("":::"r30","r29","r28");
}
int foo_gpr1() {
        asm volatile("":::"fr31", "fr30","fr29","fr28","r30","r29","r28");
}
int foo_vr() {
        asm volatile("":::"v31","v30","v29","v28");
}
*/
import "C"

import "fmt"

func main() {
	C.foo_fpr()

TEXT ·Syscall6(SB),NOSPLIT,$20-40
	MOVW	num+0(FP), R2	// syscall entry
	MOVW	a1+4(FP), R4
	MOVW	a2+8(FP), R5
	MOVW	a3+12(FP), R6
	MOVW	a4+16(FP), R7
	MOVW	a5+20(FP), R8
	MOVW	a6+24(FP), R9
	MOVW	R8, 16(R29)
	MOVW	R9, 20(R29)
	MOVW	R0, R3	// reset R3 to 0 as 1-ret SYSCALL keeps it
	SYSCALL
	BEQ	R7, ok
	MOVW	$-1, R1
	MOVW	R1, r1+28(FP)
	MOVW	R0, r2+32(FP)
	MOVW	R2, errno+36(FP)
	RET
ok:
	MOVW	R2, r1+28(FP)

	// will clobber the test pattern created by the caller
	ADDV	$(1024*8), R29

	// Ask signaller to setgid
	MOVW	$1, R1
	SYNC
	MOVW	R1, ·Baton(SB)
	SYNC

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R1
	OR	R2, R2, R2	// hint that we're in a spin loop
	BNE	R1, loop
	SYNC

	// Restore stack
	ADDV	$(-1024*8), R29

	SUB	$(8*24), RSP
	STP	(R0, R1), (8*1)(RSP)
	MOVD	R3, (8*3)(RSP)

	SAVE_R19_TO_R28(8*4)
	SAVE_F8_TO_F15(8*14)
	STP	(R29, R30), (8*22)(RSP)


	// Initialize Go ABI environment
	BL	runtime·load_g(SB)
	BL	runtime·cgocallback(SB)

	RESTORE_R19_TO_R28(8*4)
	RESTORE_F8_TO_F15(8*14)
	LDP	(8*22)(RSP), (R29, R30)

	ADD	$(8*24), RSP

// 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.

#include "go_asm.h"
#include "textflag.h"

#define	REGCTXT	R29

// memequal(a, b unsafe.Pointer, size uintptr) bool
TEXT runtime·memequal<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-25
	BEQ	R4, R5, eq
	ADDV	R4, R6, R7
	PCALIGN	$16
loop:
	BNE	R4, R7, test
	MOVV	$1, R4
	RET
test:

	print("r24  ", hex(c.r24()), "\t")
	print("r25  ", hex(c.r25()), "\n")
	print("r26  ", hex(c.r26()), "\t")
	print("r27  ", hex(c.r27()), "\n")
	print("r28  ", hex(c.r28()), "\t")
	print("r29  ", hex(c.r29()), "\n")
	print("r30  ", hex(c.r30()), "\t")
	print("r31  ", hex(c.r31()), "\n")
	print("pc   ", hex(c.pc()), "\t")
	print("ctr  ", hex(c.ctr()), "\n")
	print("link ", hex(c.link()), "\t")

TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0
	/*
	 * We still need to save all callee save register as before, and then
	 * push 3 args for fn (R4, R5, R7), skipping R6.
	 * Also note that at procedure entry in gc world, 8(R29) will be the
	 *  first arg.
	 */

	ADDV	$(-23*8), R3
	MOVV	R4, (1*8)(R3) // fn unsafe.Pointer
	MOVV	R5, (2*8)(R3) // a unsafe.Pointer
	MOVV	R7, (3*8)(R3) // ctxt uintptr

	SAVE_R22_TO_R31((4*8))