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

	MOVF F23, 208(R29)
	MOVF F24, 212(R29)
	MOVF F25, 216(R29)
	MOVF F26, 220(R29)
	MOVF F27, 224(R29)
	MOVF F28, 228(R29)
	MOVF F29, 232(R29)
	MOVF F30, 236(R29)
	MOVF F31, 240(R29)
	#endif
	CALL ·asyncPreempt2(SB)
	#ifndef GOMIPS_softfloat
	MOVF 240(R29), F31
	MOVF 236(R29), F30
	MOVF 232(R29), F29
	MOVF 228(R29), F28
	MOVF 224(R29), F27
	MOVF 220(R29), F26
	MOVF 216(R29), F25
	MOVF 212(R29), F24

// license that can be found in the LICENSE file.

package main

import (
	"runtime"
	"runtime/debug"
	"sync/atomic"
)

func init() {
	register("AsyncPreempt", AsyncPreempt)
}

func AsyncPreempt() {
	// Run with just 1 GOMAXPROCS so the runtime is required to
	// use scheduler preemption.
	runtime.GOMAXPROCS(1)
	// Disable GC so we have complete control of what we're testing.

// Code generated by mkpreempt.go; DO NOT EDIT.

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

TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0
	// No async preemption on wasm

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",

	"HI", // high bits of multiplication
	"LO", // low bits of multiplication

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

	// pseudo-registers
	"SB",
}

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