MOVW $3, R0 // CLOCK_MONOTONIC
	MOVW $8(R13), R1
	SWI $SYS___clock_gettime50

	MOVW 8(R13), R0 // sec.low
	MOVW 12(R13), R4 // sec.high
	MOVW 16(R13), R2 // nsec

	MOVW $1000000000, R3
	MULLU R0, R3, (R1, R0)
	MUL R3, R4
	ADD.S R2, R0
	ADC R4, R1

	MOVW R0, ret_lo+0(FP)
	MOVW R1, ret_hi+4(FP)
	RET

TEXT runtime·getcontext(SB),NOSPLIT|NOFRAME,$0

	MOVW $4, R0 // CLOCK_MONOTONIC
	MOVW $8(R13), R1
	MOVW $SYS_clock_gettime, R7
	SWI $0

	MOVW 8(R13), R0 // sec.low
	MOVW 12(R13), R4 // sec.high
	MOVW 16(R13), R2 // nsec

	MOVW $1000000000, R3
	MULLU R0, R3, (R1, R0)
	MUL R3, R4
	ADD.S R2, R0
	ADC R4, R1

	MOVW R0, ret_lo+0(FP)
	MOVW R1, ret_hi+4(FP)
	RET

TEXT runtime·asmSigaction(SB),NOSPLIT|NOFRAME,$0

			div: 2,
			ret: 4,
			rem: 0,
		},
		{
			num: 9,
			div: 2,
			ret: 4,
			rem: 1,
		},
		{
			// Used by runtime.check.
			num: 12345*1000000000 + 54321,
			div: 1000000000,
			ret: 12345,
			rem: 54321,
		},
		{
			num: 1<<32 - 1,
			div: 2,
			ret: 1<<31 - 1, // no overflow.
			rem: 1,
		},
		{
			num: 1 << 32,
			div: 2,

	MOVW	$1, R4	// CLOCK_MONOTONIC
	MOVW	$4(R29), R5
	MOVW	$SYS_clock_gettime, R2
	SYSCALL
	MOVW	4(R29), R3	// sec
	MOVW	8(R29), R5	// nsec
	// sec is in R3, nsec in R5
	// return nsec in R3
	MOVW	$1000000000, R4
	MULU	R4, R3
	MOVW	LO, R3
	ADDU	R5, R3
	SGTU	R5, R3, R4
	MOVW	$ret+0(FP), R6
#ifdef GOARCH_mips
	MOVW	R3, 4(R6)
#else
	MOVW	R3, 0(R6)
#endif
	MOVW	HI, R3
	ADDU	R4, R3

	// we cannot receive another signal.
	MOVV	16(R29), R1
	MOVV	R1, m_vdsoSP(R17)
	MOVV	8(R29), R1
	MOVV	R1, m_vdsoPC(R17)

	// sec is in R3, nsec in R5
	// return nsec in R3
	MOVV	$1000000000, R4
	MULVU	R4, R3
	MOVV	LO, R3
	ADDVU	R5, R3
	MOVV	R3, ret+0(FP)
	RET

fallback:
	MOVV	$SYS_clock_gettime, R2
	SYSCALL
	JMP	finish

	// we cannot receive another signal.

	MOVD	24(R15), R12
	MOVD	R12, m_vdsoSP(R6)
	MOVD	16(R15), R12
	MOVD	R12, m_vdsoPC(R6)

return:
	// sec is in R3, nsec in R5
	// return nsec in R3
	MULLD	$1000000000, R3
	ADD		R5, R3
	MOVD	R3, ret+0(FP)
	RET

	// Syscall fallback
fallback:
	MOVD	$tp-16(SP), R3
	MOVD	$SYS_clock_gettime, R1
	SYSCALL
	LMG		tp-16(SP), R2, R3
	MOVD	R3, R5
	MOVD	R2, R3

	MOVL	$SYS_clock_gettime, AX
	MOVQ	$CLOCK_MONOTONIC, DI
	LEAQ	8(SP), SI
	SYSCALL
	MOVQ	8(SP), AX	// sec
	MOVQ	16(SP), DX	// nsec

	// sec is in AX, nsec in DX
	// return nsec in AX
	IMULQ	$1000000000, AX
	ADDQ	DX, AX
	MOVQ	AX, ret+0(FP)
	RET

TEXT runtime·asmSigaction(SB),NOSPLIT,$0
	MOVQ	sig+0(FP), DI		// arg 1 sig
	MOVQ	new+8(FP), SI		// arg 2 act
	MOVQ	old+16(FP), DX		// arg 3 oact

	BL	runtime·vdsoCall(SB)

	JMP	finish

fallback:
	MOVW	$SYS_clock_gettime, R7
	SWI	$0

finish:
	MOVW	sec-12(SP), R0  // sec
	MOVW	nsec-8(SP), R2  // nsec

	MOVW	$1000000000, R3
	MULLU	R0, R3, (R1, R0)
	ADD.S	R2, R0
	ADC	$0, R1	// Add carry bit to upper half.

	MOVW	R0, ret_lo+0(FP)
	MOVW	R1, ret_hi+4(FP)

	RET

// int32 futex(int32 *uaddr, int32 op, int32 val,

	done := false
	for ; !done && n > 0; n-- {
		u := get(U)
		if end(u) != 0 {
			done = true
		} else {
			u.pr()
		}
	}
	print(("\n"))
}

func Print(U PS) {
	Printn(U, 1000000000)
}

// Evaluate n terms of power series U at x=c
func eval(c *rat, U PS, n int) *rat {
	if n == 0 {
		return zero
	}
	y := get(U)
	if end(y) != 0 {
		return zero
	}

	// we cannot receive another signal.
	MOVD	40(R1), R6
	MOVD	R6, m_vdsoSP(R21)
	MOVD	32(R1), R6
	MOVD	R6, m_vdsoPC(R21)

return:
	// sec is in R3, nsec in R5
	// return nsec in R3
	MOVD	$1000000000, R4
	MULLD	R4, R3
	ADD	R5, R3
	MOVD	R3, ret+0(FP)
	RET

	// Syscall fallback
fallback:
	ADD	$32, R1, R4
	SYSCALL $SYS_clock_gettime
	MOVD	32(R1), R3
	MOVD	40(R1), R5
	JMP	return