for i := 0; i < 8; i++ {
		lSSE.add("MOVUPS", fmt.Sprintf("X%d", i), 16)
	}

	p("ADJSP $%d", lSSE.stack)
	p("NOP SP")
	l.save()
	p("#ifndef %s", softfloat)
	lSSE.save()
	p("#endif")
	p("CALL ·asyncPreempt2(SB)")
	p("#ifndef %s", softfloat)
	lSSE.restore()
	p("#endif")
	l.restore()
	p("ADJSP $%d", -lSSE.stack)

	p("POPFL")
	p("RET")
}

func genAMD64() {
	// Assign stack offsets.

	MOVD F7, 116(R13)
	MOVD F8, 124(R13)
	MOVD F9, 132(R13)
	MOVD F10, 140(R13)
	MOVD F11, 148(R13)
	MOVD F12, 156(R13)
	MOVD F13, 164(R13)
	MOVD F14, 172(R13)
	MOVD F15, 180(R13)
nofp:
	CALL ·asyncPreempt2(SB)
	MOVB ·goarmsoftfp(SB), R0
	CMP $0, R0
	BNE nofp2
	MOVD 180(R13), F15
	MOVD 172(R13), F14
	MOVD 164(R13), F13
	MOVD 156(R13), F12
	MOVD 148(R13), F11
	MOVD 140(R13), F10
	MOVD 132(R13), F9

}

//go:generate go run mkpreempt.go

// asyncPreempt saves all user registers and calls asyncPreempt2.
//
// When stack scanning encounters an asyncPreempt frame, it scans that
// frame and its parent frame conservatively.
//
// asyncPreempt is implemented in assembly.
func asyncPreempt()

//go:nosplit
func asyncPreempt2() {
	gp := getg()
	gp.asyncSafePoint = true
	if gp.preemptStop {

	MOVD F22, 384(X2)
	MOVD F23, 392(X2)
	MOVD F24, 400(X2)
	MOVD F25, 408(X2)
	MOVD F26, 416(X2)
	MOVD F27, 424(X2)
	MOVD F28, 432(X2)
	MOVD F29, 440(X2)
	MOVD F30, 448(X2)
	MOVD F31, 456(X2)
	CALL ·asyncPreempt2(SB)
	MOVD 456(X2), F31
	MOVD 448(X2), F30
	MOVD 440(X2), F29
	MOVD 432(X2), F28
	MOVD 424(X2), F27
	MOVD 416(X2), F26
	MOVD 408(X2), F25
	MOVD 400(X2), F24
	MOVD 392(X2), F23
	MOVD 384(X2), F22

package objabi

import (
	"internal/abi"
	"strings"
)

var funcIDs = map[string]abi.FuncID{
	"abort":              abi.FuncID_abort,
	"asmcgocall":         abi.FuncID_asmcgocall,
	"asyncPreempt":       abi.FuncID_asyncPreempt,
	"cgocallback":        abi.FuncID_cgocallback,
	"corostart":          abi.FuncID_corostart,
	"debugCallV2":        abi.FuncID_debugCallV2,
	"gcBgMarkWorker":     abi.FuncID_gcBgMarkWorker,

	// won't get to see who faulted.)
	// Also don't push a sigpanic frame if the faulting PC
	// is the entry of asyncPreempt. In this case, we suspended
	// the thread right between the fault and the exception handler
	// starting to run, and we have pushed an asyncPreempt call.
	// The exception is not from asyncPreempt, so not to push a
	// sigpanic call to make it look like that. Instead, just
	// overwrite the PC. (See issue #35773)

	gp := gFromSP(mp, c.sp())
	if gp != nil && wantAsyncPreempt(gp) {
		if ok, newpc := isAsyncSafePoint(gp, c.ip(), c.sp(), c.lr()); ok {
			// Inject call to asyncPreempt
			targetPC := abi.FuncPCABI0(asyncPreempt)
			switch GOARCH {
			default:
				throw("unsupported architecture")
			case "386", "amd64":
				// Make it look like the thread called targetPC.
				sp := c.sp()

	// preempt.
	if wantAsyncPreempt(gp) {
		if ok, newpc := isAsyncSafePoint(gp, ctxt.sigpc(), ctxt.sigsp(), ctxt.siglr()); ok {
			// Adjust the PC and inject a call to asyncPreempt.
			ctxt.pushCall(abi.FuncPCABI0(asyncPreempt), newpc)
		}
	}

	// Acknowledge the preemption.
	gp.m.preemptGen.Add(1)
	gp.m.signalPending.Store(0)

	if GOOS == "darwin" || GOOS == "ios" {

	"F15",
	"F16",
	"F17",
	"F18",
	"F19",
	"F20",
	"F21",
	"F22",
	"F23",
	"F24",
	"F25",
	"F26",
	"F27",
	"F28",
	"F29",
	"F30",
	"F31",

	// If you add registers, update asyncPreempt in runtime.

	// pseudo-registers
	"SB",
}

func init() {
	// Make map from reg names to reg integers.
	if len(regNamesLOONG64) > 64 {
		panic("too many registers")
	}

	"F23",
	"F24",
	"F25",
	"F26",
	"F27",
	"F28",
	"F29",
	"F30",
	// "F31", the allocator is limited to 64 entries. We sacrifice this FPR to support XER.

	"XER",

	// If you add registers, update asyncPreempt in runtime.

	// "CR0",
	// "CR1",
	// "CR2",
	// "CR3",
	// "CR4",
	// "CR5",
	// "CR6",
	// "CR7",

	// "CR",
	// "LR",
	// "CTR",
}

func init() {