reg := fmt.Sprintf("R%d", i)
		l.add("MOVD", reg, 8)
	}
	l.addSpecial(
		"MOVW CR, R31\nMOVW R31, %d(R1)",
		"MOVW %d(R1), R31\nMOVFL R31, $0xff", // this is MOVW R31, CR
		8)                                    // CR is 4-byte wide, but just keep the alignment
	l.addSpecial(
		"MOVD XER, R31\nMOVD R31, %d(R1)",
		"MOVD %d(R1), R31\nMOVD R31, XER",
		8)
	// Add floating point registers F0-F31.
	for i := 0; i <= 31; i++ {

	// save scratch register R31 first
	MOVD	R31, -184(R1)
	MOVD	0(R1), R31
	// save caller LR
	MOVD	R31, -304(R1)
	MOVD	-32(R1), R31
	// save argument frame size
	MOVD	R31, -192(R1)
	MOVD	LR, R31
	MOVD	R31, -320(R1)
	ADD	$-320, R1
	// save all registers that can contain pointers
	// and the CR register
	MOVW	CR, R31
	MOVD	R31, 8(R1)
	MOVD	R2, 24(R1)
	MOVD	R3, 56(R1)

			faultOnNilArg0: true,
			unsafePoint:    true,
		},

		// R31 is temp register
		// Loop code:
		//	MOVD len/32,R31		set up loop ctr
		//	MOVD R31,CTR
		//	MOVD $16,R31		index register
		// loop:
		//	LXVD2X (R0)(R4),VS32
		//	LXVD2X (R31)(R4),VS33
		//	ADD  R4,$32          increment src
		//	STXVD2X VS32,(R0)(R3)
		//	STXVD2X VS33,(R31)(R3)
		//	ADD  R3,$32          increment dst

	{"R20", "R20"},
	{"R21", "R21"},
	{"R22", "R22"},
	{"R23", "R23"},
	{"R24", "R24"},
	{"R25", "R25"},
	{"R26", "R26"},
	{"R27", "R27"},
	{"R28", "R28"},
	{"R29", "R29"},
	{"R3", "R3"},
	{"R31", "R31"},
	{"R4", "R4"},
	{"R5", "R5"},
	{"R6", "R6"},
	{"R7", "R7"},
	{"R8", "R8"},
	{"R9", "R9"},
	{"SPR(269)", "SPR(269)"},
	{"a(FP)", "a(FP)"},
	{"g", "g"},
	{"ret+8(FP)", "ret+8(FP)"},

	MOVV	0(R4), R0	// make sure g != nil
	JMP	gogo<>(SB)

TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
	MOVV	R4, g
	JAL	runtime·save_g(SB)

	MOVV	0(g), R2
	MOVV	gobuf_sp(R3), R29
	MOVV	gobuf_lr(R3), R31
	MOVV	gobuf_ret(R3), R1
	MOVV	gobuf_ctxt(R3), REGCTXT
	MOVV	R0, gobuf_sp(R3)
	MOVV	R0, gobuf_ret(R3)
	MOVV	R0, gobuf_lr(R3)
	MOVV	R0, gobuf_ctxt(R3)
	MOVV	gobuf_pc(R3), R4
	JMP	(R4)

	// are callee-save in the gcc calling convention, so save them.
	MOVW	R23, R8
	MOVW	g, R9
	MOVW	R31, R10 // this call frame does not save LR

	JAL	runtime·load_g(SB)
	MOVW	g_m(g), R1
	MOVW	m_curg(R1), R1
	MOVW	(g_stack+stack_hi)(R1), R2 // return value in R2

	MOVW	R8, R23
	MOVW	R9, g
	MOVW	R10, R31

	RET

// The top-most function running on a goroutine
// returns to goexit+PCQuantum.

	// We are already on m's g0 stack.

	// Go relies on R0 being $0.
	XOR	R0, R0

	// TODO(jsing): Save callee-save registers (R14-R31, F14-F31, V20-V31).

	MOVD    m_g0(R3), g
	BL	runtime·save_g(SB)

	BL	runtime·mstart(SB)

	// TODO(jsing): Restore callee-save registers (R14-R31, F14-F31, V20-V31).

	// Go is all done with this OS thread.
	// Tell pthread everything is ok (we never join with this thread, so

	// should never return
	JAL	runtime·abort(SB)
	UNDEF

/*
 * support for morestack
 */

// Called during function prolog when more stack is needed.
// Caller has already loaded:
// loong64: R31: LR
//
// The traceback routines see morestack on a g0 as being
// the top of a stack (for example, morestack calling newstack
// calling the scheduler calling newm calling gc), so we must

	VMOVH	-70(R12), W3   // 7bdd60e1
	VMOVW	(R3), W31      // 78001fe2
	VMOVW	64(R20), W16   // 7810a422
	VMOVW	-104(R17), W24 // 7be68e22
	VMOVD	(R3), W2       // 780018a3
	VMOVD	128(R23), W19  // 7810bce3
	VMOVD	-256(R31), W0  // 7be0f823

	VMOVB	W8, (R0)       // 78000224
	VMOVB	W0, 511(R3)    // 79ff1824
	VMOVB	W21, -512(R12) // 7a006564
	VMOVH	W12, (R24)     // 7800c325
	VMOVH	W8, 110(R19)   // 78379a25

	// If no traceback support function, which means that
	// runtime/cgo was not linked in, do usual sigtramp.
	MOVD	_cgo_callers(SB), R6
	CMP	$0, R6
	BEQ	sigtramp

	// Inspect the g in TLS without clobbering R30/R31 via runtime.load_g.
	MOVD	runtime·tls_g(SB), R9
	MOVD	0(R9), R9

	// Figure out if we are currently in a cgo call.
	// If not, just do usual sigtramp.
	// compared to ARM64 and others.
	CMP	$0, R9