mathhardalib.s

VXWORKS源代码

	fmulp	%st, %st(1)
	call	powerOftwo
	jmp	powErrExit

powOne:
	fld1
	jmp	powErrExit

powNan:
	fldz
	jmp	powErrExit

powNegX:				/* x < 0 */
	fldl	DARG2(%ebp)
	frndint
	fcompl	DARG2(%ebp)
	fstsw	%ax
	sahf
	jne	powNan			/* if (y != int(y)), (x**y = 0) */

	fldl	DARG2(%ebp)		/* x**y = 2**(y * log2(|x|)) */
	fldl	DARG1(%ebp)
	fabs
	fyl2x
	call	powerOftwo

	fld1				/* if ((y % 2) != 0)              */
	fld1				/*   x**y = -(%st)                */
	faddp				/* else                           */
	fldl	DARG2(%ebp)             /*   x**y = %st	                  */
	fprem
	fldz
	fcompp
	fstsw	%ax
	sahf
	je	powExit0

	fcomp	%st			/* pop, fincstp + ffree might work */
	fchs				/* x**y = -(%st) */
	jmp	powExit

powExit0:
	fcomp	%st			/* pop, fincstp + ffree might work */
	jmp	powExit

powErrExit:
powExit:
	leave
	ret

/*******************************************************************************
*
* mathHardSin - ANSI-compatable hardware floating-point sine
*
* RETURNS: The floating-point sine of dblParam.
*
* SEE ALSO: 
*   floatLib (1), cos (2), tan (2), 
*   "The C Programming Language - Second Edition"
*
* double mathHardSin (dblParam)
*     double dblParam;	/* angle in radians *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardSin)
	pushl	%ebp
	movl	%esp,%ebp

	fldl	DARG1(%ebp)
	fsin

	leave
	ret

/*******************************************************************************
*
* mathHardSqrt - ANSI-compatable hardware floating-point square root
*
* RETURNS: The floating-point square root of dblParam.
*
* SEE ALSO: floatLib(1), pow (2)
*
* double mathHardSqrt (dblParam)
*     double dblParam;	/* argument *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardSqrt)
	pushl	%ebp
	movl	%esp,%ebp

	fldl	DARG1(%ebp)
	fsqrt

	leave
	ret

/*******************************************************************************
*
* mathHardTan - ANSI-compatable hardware floating-point tangent
*
* RETURNS: Floating-point tangent of dblParam.
*
* SEE ALSO: floatLib (1), cos (2), sin (2),
* "The C Programming Language - Second Edition"
*
* double mathHardTan (dblParam)
*     double dblParam;	/* angle in radians *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardTan)
	pushl	%ebp
	movl	%esp,%ebp

	fldl	DARG1(%ebp)
	fptan
	fstp	%st

	leave
	ret

/*******************************************************************************
*
* mathHardSincos - simultaneous hardware floating-point sine and cosine
*
* RETURNS:
* The simultaeous floating point results of sine and cosine of the 
* radian argument  The dblParam must be in range of -1.0 to +1.0.
*
* CAVEAT:
* Supported for the HD648132 only.
*
* SEE ALSO: floatLib (1), "HD648132 Floating-Point User's Manual"
*
* void mathHardSincos (dblParam, sinResult, cosResult)
*     double dblParam;		/* angle in radians *
*     double *sinResult;	/* sine result buffer *
*     double *cosResult;	/* cosine result buffer *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardSincos)
	pushl	%ebp
	movl	%esp,%ebp

	fldl	DARG1(%ebp)
	fsincos
	movl	DARG2L(%ebp),%eax
	fstpl	(%eax)
	movl	DARG2(%ebp),%edx
	fstpl	(%edx)

	leave
	ret

/*******************************************************************************
*
* mathHardFmod - ANSI-compatable hardware floating-point modulus (fprem)
*
* RETURNS: 
* Floating-point modulus of (dblParam / dblDivisor) with the sign of dblParam.  
*
* SEE ALSO: 
* floatLib (1), "The C Programming Language - Second Edition"
*
* double mathHardFmod (dblParam, dblDivisor)
*     double dblParam;		/* argument *
*     double dblDivisor;	/* divisor *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardFmod)
	pushl	%ebp
	movl	%esp,%ebp

	fldl	DARG2(%ebp)
	fldl	DARG1(%ebp)

reducePartial:

	fprem			/* fprem for non IEEE */
	fstsw	%ax		/* put the FPU status word in AX */
	test	$0x0400,%ax	/* is there a partial remainder at ST(0) ? */
	jnz	reducePartial

	fstp	%st(1)

	leave
	ret

/*******************************************************************************
*
* mathHardFmodIeee - ANSI-compatable hardware floating-point modulus (fprem1)
*
* RETURNS: 
* Floating-point modulus of (dblParam / dblDivisor) with the sign of dblParam.  
*
* SEE ALSO: 
* floatLib (1), "The C Programming Language - Second Edition"
*
* double mathHardFmodIeee (dblParam, dblDivisor)
*     double dblParam;		/* argument *
*     double dblDivisor;	/* divisor *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardFmodIeee)
	pushl	%ebp
	movl	%esp,%ebp

	fldl	DARG2(%ebp)
	fldl	DARG1(%ebp)

reducePartialIeee:

	fprem1			/* fprem1 for IEEE */
	fstsw	%ax		/* put the FPU status word in AX */
	test	$0x0400,%ax	/* is there a partial remainder at ST(0) ? */
	jnz	reducePartialIeee

	fstp	%st(1)

	leave
	ret

/*******************************************************************************
*
* mathHardFloor - ANSI-compatable hardware floating-point floor
*
* Performs a 'round-to-negative-infinity'.
*
* RETURNS: 
* The largest integral value less than or equal to dblParam,
* result is returned in double precision.
*
* SEE ALSO: 
* floatLib (1), "The C Programming Language - Second Edition"
*
*
* double mathHardFloor (dblParam)
*     double dblParam;	/* argument *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardFloor)
	pushl	%ebp
	movl	%esp,%ebp

	subl	$8,%esp
	fstcw	-4(%ebp)
	fwait
	movw	-4(%ebp),%ax
	andw	$ FPCR_RC_MASK,%ax
	orw	$ FPCR_RC_DOWN,%ax
	movw	%ax,-8(%ebp)
	fldcw	-8(%ebp)
	fldl	DARG1(%ebp)
	frndint
	fldcw	-4(%ebp)
	addl	$8,%esp

	leave
	ret

/*******************************************************************************
*
* mathHardCeil - ANSI-compatable hardware floating-point ceiling
*
* Performs a 'round-to-positive-infinity'
*
* RETURNS: 
* The least integral value greater than or equal to dblParam,
* result is returned in double precision.
*
* SEE ALSO: 
* floatLib (1), "The C Programming Language - Second Edition"
*
* double mathHardCeil (dblParam)
*     double dblParam;	/* argument *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardCeil)
	pushl	%ebp
	movl	%esp,%ebp

	subl	$8,%esp
	fstcw	-4(%ebp)
	fwait
	movw	-4(%ebp),%ax
	andw	$ FPCR_RC_MASK,%ax
	orw	$ FPCR_RC_UP,%ax
	movw	%ax,-8(%ebp)
	fldcw	-8(%ebp)
	fldl	DARG1(%ebp)
	frndint
	fldcw	-4(%ebp)
	addl	$8,%esp

	leave
	ret

/*******************************************************************************
*
* mathHardTrunc - hardware floating-point truncation
*
* Performs FINTRZ.
*
* RETURNS:
* The integer portion of a double-precision number,
* result is in double-precision.
*
* SEE ALSO: floatLib (1)
*
* double mathHardTrunc (dblParam)
*     double dblParam;	/* argument *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardTrunc)
	pushl	%ebp
	movl	%esp,%ebp

	subl	$8,%esp
	fstcw	-4(%ebp)
	fwait
	movw	-4(%ebp),%ax
	andw	$ FPCR_RC_MASK,%ax
	orw	$ FPCR_RC_ZERO,%ax
	movw	%ax,-8(%ebp)
	fldcw	-8(%ebp)
	fldl	DARG1(%ebp)
	frndint
	fldcw	-4(%ebp)
	addl	$8,%esp

	leave
	ret

/*******************************************************************************
*
* mathHardRound - hardware floating-point rounding
*
* Performs a 'round-to-nearest'.
*
* SEE ALSO: floatLib (1)
*
* double mathHardRound (dblParam)
*     double dblParam;	/* argument *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardRound)
	pushl	%ebp
	movl	%esp,%ebp

	subl	$8,%esp
	fstcw	-4(%ebp)
	fwait
	movw	-4(%ebp),%ax
	andw	$ FPCR_RC_MASK,%ax
	orw	$ FPCR_RC_NEAREST,%ax
	movw	%ax,-8(%ebp)
	fldcw	-8(%ebp)
	fldl	DARG1(%ebp)
	frndint
	fldcw	-4(%ebp)
	addl	$8,%esp

	leave
	ret

/*******************************************************************************
*
* mathHardIround - hardware floating-point rounding to nearest integer
*
* Performs a 'round-to-nearest' function.
*
* NOTE:
* If dblParam is spaced evenly between two integers,
* then the  even integer will be returned.
*
* int mathHardIround (dblParam)
*     double dblParam;	/* argument *
*
*/

	.balign 16,0x90
FUNC_LABEL(mathHardIround)
	pushl	%ebp
	movl	%esp,%ebp

	subl	$8,%esp
	fstcw	-4(%ebp)
	fwait
	movw	-4(%ebp),%ax
	andw	$0xf3ff,%ax
	orw	$0x0,%ax
	movw	%ax,-8(%ebp)
	fldcw	-8(%ebp)
	fldl	DARG1(%ebp)
	frndint
	fistpl	DARG1(%ebp)
	fwait
	movl	DARG1(%ebp),%eax
	fldcw	-4(%ebp)
	addl	$8,%esp

	leave
	ret

/********************************************************************************
* mathHardIrint - hardware floating-point double to integer conversion
*
* Convert dblParam to an integer using the selected IEEE
* rounding direction.
*
* CAVEAT:
* The rounding direction is not pre-selectable
* and is fixed for 'round-to-the-nearest'.
*
* SEE ALSO: floatLib (1)
* 
* int mathHardIrint (dblParam)
*     double dblParam;	/* argument *
*
*/
 
	.balign 16,0x90
FUNC_LABEL(mathHardIrint)
	pushl	%ebp
	movl	%esp,%ebp

	fldl	DARG1(%ebp)
	frndint
	fistpl	DARG1(%ebp)
	fwait
	movl	DARG1(%ebp),%eax

	leave
	ret

/********************************************************************************
* mathHardInfinity - hardware floating-point return of a very large double
*
* SEE ALSO: floatLib(1)
* 
* double mathHardInfinity ()
*
*/
 
	.balign 16
mathHardInfinity0:
	.double 0d4.09600000000000000000e+03
	.balign 16

FUNC_LABEL(mathHardInfinity)		/* 10**4096 = 2**(4096 * log2(10)) */
	pushl	%ebp
	movl	%esp,%ebp

	fldl	mathHardInfinity0
	fldl2t
	fmulp	%st,%st(1)
	call	powerOftwo

	leave
	ret