MOVUPS X6, 124(SP)
	MOVUPS X7, 140(SP)
	#endif
	CALL ·asyncPreempt2(SB)
	#ifndef GO386_softfloat
	MOVUPS 140(SP), X7
	MOVUPS 124(SP), X6
	MOVUPS 108(SP), X5
	MOVUPS 92(SP), X4
	MOVUPS 76(SP), X3
	MOVUPS 60(SP), X2
	MOVUPS 44(SP), X1
	MOVUPS 28(SP), X0
	#endif
	MOVL 24(SP), DI
	MOVL 20(SP), SI
	MOVL 16(SP), BP
	MOVL 12(SP), BX
	MOVL 8(SP), DX
	MOVL 4(SP), CX
	MOVL 0(SP), AX
	ADJSP $-156
	POPFL

	MOVUPS X7, 224(SP)
	MOVUPS X8, 240(SP)
	MOVUPS X9, 256(SP)
	MOVUPS X10, 272(SP)
	MOVUPS X11, 288(SP)
	MOVUPS X12, 304(SP)
	MOVUPS X13, 320(SP)
	MOVUPS X14, 336(SP)
	MOVUPS X15, 352(SP)
	CALL ·asyncPreempt2(SB)
	MOVUPS 352(SP), X15
	MOVUPS 336(SP), X14
	MOVUPS 320(SP), X13
	MOVUPS 304(SP), X12
	MOVUPS 288(SP), X11
	MOVUPS 272(SP), X10
	MOVUPS 256(SP), X9
	MOVUPS 240(SP), X8
	MOVUPS 224(SP), X7

	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

	FSTPD (F18, F19), 376(RSP)
	FSTPD (F20, F21), 392(RSP)
	FSTPD (F22, F23), 408(RSP)
	FSTPD (F24, F25), 424(RSP)
	FSTPD (F26, F27), 440(RSP)
	FSTPD (F28, F29), 456(RSP)
	FSTPD (F30, F31), 472(RSP)
	CALL ·asyncPreempt2(SB)
	FLDPD 472(RSP), (F30, F31)
	FLDPD 456(RSP), (F28, F29)
	FLDPD 440(RSP), (F26, F27)
	FLDPD 424(RSP), (F24, F25)
	FLDPD 408(RSP), (F22, F23)
	FLDPD 392(RSP), (F20, F21)
	FLDPD 376(RSP), (F18, F19)

	MOVD F24, 408(R3)
	MOVD F25, 416(R3)
	MOVD F26, 424(R3)
	MOVD F27, 432(R3)
	MOVD F28, 440(R3)
	MOVD F29, 448(R3)
	MOVD F30, 456(R3)
	MOVD F31, 464(R3)
	MOVV FCC0, R4
	MOVV R4, 472(R3)
	CALL ·asyncPreempt2(SB)
	MOVV 472(R3), R4
	MOVV R4, FCC0
	MOVD 464(R3), F31
	MOVD 456(R3), F30
	MOVD 448(R3), F29
	MOVD 440(R3), F28
	MOVD 432(R3), F27
	MOVD 424(R3), F26
	MOVD 416(R3), F25
	MOVD 408(R3), F24

	FMOVD F24, 448(R1)
	FMOVD F25, 456(R1)
	FMOVD F26, 464(R1)
	FMOVD F27, 472(R1)
	FMOVD F28, 480(R1)
	FMOVD F29, 488(R1)
	FMOVD F30, 496(R1)
	FMOVD F31, 504(R1)
	MOVFL FPSCR, F0
	FMOVD F0, 512(R1)
	CALL ·asyncPreempt2(SB)
	FMOVD 512(R1), F0
	MOVFL F0, FPSCR
	FMOVD 504(R1), F31
	FMOVD 496(R1), F30
	FMOVD 488(R1), F29
	FMOVD 480(R1), F28
	FMOVD 472(R1), F27
	FMOVD 464(R1), F26
	FMOVD 456(R1), F25
	FMOVD 448(R1), F24

	MOVD F23, 416(R29)
	MOVD F24, 424(R29)
	MOVD F25, 432(R29)
	MOVD F26, 440(R29)
	MOVD F27, 448(R29)
	MOVD F28, 456(R29)
	MOVD F29, 464(R29)
	MOVD F30, 472(R29)
	MOVD F31, 480(R29)
	#endif
	CALL ·asyncPreempt2(SB)
	#ifndef GOMIPS64_softfloat
	MOVD 480(R29), F31
	MOVD 472(R29), F30
	MOVD 464(R29), F29
	MOVD 456(R29), F28
	MOVD 448(R29), F27
	MOVD 440(R29), F26
	MOVD 432(R29), F25
	MOVD 424(R29), F24

	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.