mathalib.s

vxworks的源代码

/* mathALib.s - C interface library to high-level math functions */

/* Copyright 1984-1995 Wind River Systems, Inc. */
	.data
	.globl	_copyright_wind_river
	.long	_copyright_wind_river

/*
modification history
--------------------
01w,09may02,wsl  fix warning about incomplete implementation on some arch's
01v,10oct01,dgp  doc: fix formatting for doc build
01u,25nov95,jdi  doc: removed references to 68k-specific docs.
01t,03feb95,rhp  warn not all functions available on all architectures
01s,09dec94,rhp  fix man pages for inverse trig, hyperbolic fns
01r,09dec94,rhp  mention include file math.h in man pages (SPR #2502)
01q,26nov94,kdl  added 68LC040 support.
01p,02aug94,tpr  added MC68060 cpu support.
01o,15feb93,jdi  made NOMANUAL: hypot() and hypotf().
01n,12feb93,smb  removed pow and fmod for the MC68040
01m,05feb93,jdi  changed sqrt() to sqrtf() in doc for hypotf().
01l,02dec92,jdi  documentation; added modhist entry 01k omitted by jcf in 
		 last checkin (mistakenly called 01j in scl). 
01k,13nov92,jcf  made logMsg calls indirect to reduce coupling.
01j,13oct92,jdi  made mathErrNoInit() nomanual.
01i,26sep92,yp   added title so doc run would work
01h,23aug92,jcf  changed bxxx to jxx.
01g,30jul92,kdl	 changed to ANSI single precision names (e.g. fsin -> sinf)
01f,26may92,rrr  the tree shuffle
01e,04oct91,rrr  passed through the ansification filter
		  -changed VOID to void
		  -changed ASMLANGUAGE to _ASMLANGUAGE
		  -changed copyright notice
01d,27aug91,wmd	 added #include "vxWorks.h".
01c,23jul91,gae  changed 68k/asm.h to asm.h.
01b,30jan91,kdl	 mangen fixes.
01a,28jan91,kdl	 written; old "mathALib" renamed to "mathHardALib".
*/

/*
DESCRIPTION
This library provides a C interface to high-level floating-point math
functions, which can use either a hardware floating-point unit or a
software floating-point emulation library.  The appropriate routine is
called based on whether mathHardInit() or mathSoftInit() or both have
been called to initialize the interface.

All angle-related parameters are expressed in radians.  All functions in
this library with names corresponding to ANSI C specifications are ANSI
compatible.

WARNING
Not all functions in this library are available on all architectures.  For 
information on available math functions, consult the VxWorks architecture 
supplement for your processor.
	
INTERNAL
When generating man pages, the man pages from this library should be
built BEFORE those from ansiMath.  Thus, the equivalent man pages in 
ansiMath will overwrite those from this library, which is the correct
behavior.  This ordering is set up in the overall makefile system.

Even though this library is 68K, the man pages are meant to service
all architectures, within the limitation described in the above WARNING.

INTERNAL
See "MC68881/MC68882 Floating-Point Coprocessor User's Manual, 2nd Edition"

INCLUDE FILES: math.h

SEE ALSO:
'ansiMath', fppLib, floatLib, mathHardLib, mathSoftLib, the various
.I "Architecture Supplements,"
Kernighan & Ritchie:
.I "The C Programming Language, 2nd Edition"
*/

#define _ASMLANGUAGE
#include "vxWorks.h"
#include "asm.h"
#include "errno.h"

	.data
	.even

	.globl _mathAcosFunc	/* double-precision function pointers */
	.globl _mathAsinFunc
	.globl _mathAtanFunc
	.globl _mathAtan2Func
	.globl _mathCbrtFunc
	.globl _mathCeilFunc
	.globl _mathCosFunc
	.globl _mathCoshFunc
	.globl _mathExpFunc
	.globl _mathFabsFunc
	.globl _mathFloorFunc
	.globl _mathFmodFunc
	.globl _mathHypotFunc
	.globl _mathInfinityFunc
	.globl _mathIrintFunc
	.globl _mathIroundFunc
	.globl _mathLogFunc
	.globl _mathLog2Func
	.globl _mathLog10Func
	.globl _mathPowFunc
	.globl _mathRoundFunc
	.globl _mathSinFunc
	.globl _mathSincosFunc
	.globl _mathSinhFunc
	.globl _mathSqrtFunc
	.globl _mathTanFunc
	.globl _mathTanhFunc
	.globl _mathTruncFunc

	.globl _mathAcosfFunc	/* single-precision function pointers */
	.globl _mathAsinfFunc
	.globl _mathAtanfFunc
	.globl _mathAtan2fFunc
	.globl _mathCbrtfFunc
	.globl _mathCeilfFunc
	.globl _mathCosfFunc
	.globl _mathCoshfFunc
	.globl _mathExpfFunc
	.globl _mathFabsfFunc
	.globl _mathFloorfFunc
	.globl _mathFmodfFunc
	.globl _mathHypotfFunc
	.globl _mathInfinityfFunc
	.globl _mathIrintfFunc
	.globl _mathIroundfFunc
	.globl _mathLogfFunc
	.globl _mathLog2fFunc
	.globl _mathLog10fFunc
	.globl _mathPowfFunc
	.globl _mathRoundfFunc
	.globl _mathSinfFunc
	.globl _mathSincosfFunc
	.globl _mathSinhfFunc
	.globl _mathSqrtfFunc
	.globl _mathTanfFunc
	.globl _mathTanhfFunc
	.globl _mathTruncfFunc


_mathAcosFunc:			/* double-precision function pointers */
	.long	_mathErrNoInit
_mathAsinFunc:
	.long	_mathErrNoInit
_mathAtanFunc:
	.long	_mathErrNoInit
_mathAtan2Func:
	.long	_mathErrNoInit
_mathCbrtFunc:
	.long	_mathErrNoInit
_mathCeilFunc:
	.long	_mathErrNoInit
_mathCosFunc:
	.long	_mathErrNoInit
_mathCoshFunc:
	.long	_mathErrNoInit
_mathExpFunc:
	.long	_mathErrNoInit
_mathFabsFunc:
	.long	_mathErrNoInit
_mathFloorFunc:
	.long	_mathErrNoInit
_mathFmodFunc:
	.long	_mathErrNoInit
_mathHypotFunc:
	.long	_mathErrNoInit
_mathInfinityFunc:
	.long	_mathErrNoInit
_mathIrintFunc:
	.long	_mathErrNoInit
_mathIroundFunc:
	.long	_mathErrNoInit
_mathLogFunc:
	.long	_mathErrNoInit
_mathLog2Func:
	.long	_mathErrNoInit
_mathLog10Func:
	.long	_mathErrNoInit
_mathPowFunc:
	.long	_mathErrNoInit
_mathRoundFunc:
	.long	_mathErrNoInit
_mathSinFunc:
	.long	_mathErrNoInit
_mathSincosFunc:
	.long	_mathErrNoInit
_mathSinhFunc:
	.long	_mathErrNoInit
_mathSqrtFunc:
	.long	_mathErrNoInit
_mathTanFunc:
	.long	_mathErrNoInit
_mathTanhFunc:
	.long	_mathErrNoInit
_mathTruncFunc:
	.long	_mathErrNoInit

_mathAcosfFunc:			/* single-precision function pointers */
	.long	_mathErrNoInit
_mathAsinfFunc:
	.long	_mathErrNoInit
_mathAtanfFunc:
	.long	_mathErrNoInit
_mathAtan2fFunc:
	.long	_mathErrNoInit
_mathCbrtfFunc:
	.long	_mathErrNoInit
_mathCeilfFunc:
	.long	_mathErrNoInit
_mathCosfFunc:
	.long	_mathErrNoInit
_mathCoshfFunc:
	.long	_mathErrNoInit
_mathExpfFunc:
	.long	_mathErrNoInit
_mathFabsfFunc:
	.long	_mathErrNoInit
_mathFloorfFunc:
	.long	_mathErrNoInit
_mathFmodfFunc:
	.long	_mathErrNoInit
_mathHypotfFunc:
	.long	_mathErrNoInit
_mathInfinityfFunc:
	.long	_mathErrNoInit
_mathIrintfFunc:
	.long	_mathErrNoInit
_mathIroundfFunc:
	.long	_mathErrNoInit
_mathLogfFunc:
	.long	_mathErrNoInit
_mathLog2fFunc:
	.long	_mathErrNoInit
_mathLog10fFunc:
	.long	_mathErrNoInit
_mathPowfFunc:
	.long	_mathErrNoInit
_mathRoundfFunc:
	.long	_mathErrNoInit
_mathSinfFunc:
	.long	_mathErrNoInit
_mathSincosfFunc:
	.long	_mathErrNoInit
_mathSinhfFunc:
	.long	_mathErrNoInit
_mathSqrtfFunc:
	.long	_mathErrNoInit
_mathTanfFunc:
	.long	_mathErrNoInit
_mathTanhfFunc:
	.long	_mathErrNoInit
_mathTruncfFunc:
	.long	_mathErrNoInit


_mathErrNoInitString:
	.asciz	"ERROR - floating point math not initialized!\n"

        .text
	.even
        .globl  _acos			/* double-precision functions */
        .globl  _asin
        .globl  _atan
	.globl  _atan2
	.globl  _cbrt
	.globl  _ceil
        .globl  _cos
        .globl  _cosh
        .globl  _exp
        .globl  _fabs
	.globl  _floor
#if (CPU!=MC68040) && (CPU!=MC68LC040) && (CPU!=MC68060)
	.globl  _fmod
#endif	/* (CPU!=MC68040) && (CPU!=MC68LC040) && (CPU!=MC68060) */
	.globl	_hypot
	.globl  _infinity
	.globl  _irint
	.globl  _iround
        .globl  _log
        .globl  _log2
        .globl  _log10
#if (CPU!=MC68040) && (CPU!=MC68LC040) && (CPU!=MC68060)
        .globl  _pow
#endif	/* (CPU!=MC68040) && (CPU!=MC68LC040) && (CPU!=MC68060) */
	.globl  _round
        .globl  _sin
	.globl  _sincos
        .globl  _sinh
        .globl  _sqrt
        .globl  _tan
        .globl  _tanh
	.globl  _trunc

        .globl  _acosf			/* single-precision functions */
        .globl  _asinf
        .globl  _atanf
	.globl  _atan2f
	.globl  _cbrtf
	.globl  _ceilf
        .globl  _cosf
        .globl  _coshf
        .globl  _expf
        .globl  _fabsf
	.globl  _floorf
	.globl  _fmodf
	.globl	_hypotf
	.globl  _infinityf
	.globl  _irintf
	.globl  _iroundf
        .globl  _logf
        .globl  _log2f
        .globl  _log10f
        .globl  _powf
	.globl  _roundf
        .globl  _sinf
	.globl  _sincosf
        .globl  _sinhf
        .globl  _sqrtf
        .globl  _tanf
        .globl  _tanhf
	.globl  _truncf

	.globl	_mathErrNoInit		/* default routine (log error msg) */
	.globl	__func_logMsg		/* logMsg virtual function */

/*******************************************************************************
*
* acos - compute an arc cosine (ANSI)
*
* SYNOPSIS
* \ss
* double acos
*     (
*     double x    /@ angle in radians @/
*     )
* \se
*
* INCLUDE FILES: math.h 
*
* RETURNS: The double-precision arc cosine of <x> in the range 0.0
* to pi radians.
*
* SEE ALSO:
* Kernighan & Ritchie,
* .I "The C Programming Language, 2nd Edition"
*
*/

_acos:
	movel	_mathAcosFunc,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* asin - compute an arc sine (ANSI)
*
* SYNOPSIS
* \ss
* double asin
*     (
*     double x    /@ angle in radians @/
*     )
* \se
*
* INCLUDE FILES: math.h 
*
* RETURNS: The double-precision arc sine of <x> in the range
* -pi/2 to pi/2 radians.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/

_asin:
	movel	_mathAsinFunc,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* atan - compute an arc tangent (ANSI)
*
* SYNOPSIS
* \ss
* double atan
*     (
*     double x    /@ angle in radians @/
*     )
* \se
*
* INCLUDE FILES: math.h 
*
* RETURNS: The double-precision arc tangent of <x> in the range -pi/2 to pi/2.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/
_atan:
	movel	_mathAtanFunc,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* atan2 - compute the arc tangent of y/x (ANSI)
*
* SYNOPSIS
* \ss
* double atan2
*     (
*     double  y,  /@ numerator @/
*     double  x   /@ denominator @/
*     )
* \se
*
* INCLUDE FILES: math.h 
*
* RETURNS:
* The double-precision arc tangent of <y>/<x> in the range -pi to pi.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/

_atan2:

	movel	_mathAtan2Func,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* cbrt - compute a cube root
*
* SYNOPSIS
* \ss
* double cbrt
*     (
*     double x	/@ value to compute the cube root of @/
*     )
* \se
*
* This routine returns the cube root of <x> in double precision.
*
* INCLUDE FILES: math.h 
*
* RETURNS: The double-precision cube root of <x>.
*/

_cbrt:
	movel	_mathCbrtFunc,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* ceil - compute the smallest integer greater than or equal to a specified value (ANSI)
*
* SYNOPSIS
* \ss
* double ceil
*     (
*     double v    /@ value to return the ceiling of @/
*     )
* \se
*
* Performs a round-to-positive-infinity.
*
* INCLUDE FILES: math.h 
*
* RETURNS:
* The smallest integral value greater than or equal to <v>,
* represented in double precision.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/

_ceil:
	movel	_mathCeilFunc,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* cos - compute a cosine (ANSI)
*
* SYNOPSIS
* \ss
* double cos
*     (
*     double x    /@ angle in radians @/
*     )
* \se
*
* INCLUDE FILES: math.h 
*
* RETURNS: The double-precision cosine of <x>.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/

_cos:
	movel	_mathCosFunc,a0		/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* cosh - compute a hyperbolic cosine (ANSI)
*
* SYNOPSIS
* \ss
* double cosh
*     (
*     double x    /@ angle in radians @/
*     )
* \se
*
* INCLUDE FILES: math.h 
*
* RETURNS:
* The double-precision hyperbolic cosine of <x> if the parameter is greater
* than 1.0, or NaN if the parameter is less than 1.0.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/

_cosh:
	movel	_mathCoshFunc,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* exp - compute an exponential value (ANSI)
*
* SYNOPSIS
* \ss
* double exp
*     (
*     double x	/@ exponent @/
*     )
* \se
*
* This routine returns the exponential value of <x> -- the inverse natural
* logarithm (e ** <x>) -- in double precision.
*
* INCLUDE FILES: math.h 
*
* RETURNS:
* The double-precision exponential value of <x>.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/

_exp:
	movel	_mathExpFunc,a0		/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* fabs - compute an absolute value (ANSI)
*
* SYNOPSIS
* \ss
* double fabs
*     (
*     double v    /@ number to return the absolute value of @/
*     )
* \se
*
* INCLUDE FILES: math.h 
*
* RETURNS: The double-precision absolute value of <v>.
*
* SEE ALSO:
* Kernighan & Ritchie:
* .I "The C Programming Language, 2nd Edition"
*/

_fabs:
	movel	_mathFabsFunc,a0	/* get appropriate function addr */
	jmp	a0@			/* jump, let that routine rts */

/*******************************************************************************
*
* floor - compute the largest integer less than or equal to a specified value (ANSI)
*
* SYNOPSIS
* \ss
* double floor
*     (