math.c File Reference

#include <assert.h>
#include <complex.h>
#include <stdio.h>
#include <fenv.h>
#include <fpieee.h>
#include <limits.h>
#include <locale.h>
#include <math.h>
#include "msvcrt.h"
#include "winternl.h"
#include "wine/asm.h"
#include "wine/debug.h"
#include <stdlib.h>

Include dependency graph for math.c:

Go to the source code of this file.

Macros
#define	_DOMAIN   1 /* domain error in argument */
#define	_SING   2 /* singularity */
#define	_OVERFLOW   3 /* range overflow */
#define	_UNDERFLOW   4 /* range underflow */
#define	SET_X87_CW(MASK)
#define	RESET_X87_CW

Typedefs
typedef int(CDECL *	MSVCRT_matherr_func) (struct _exception *)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msvcrt)
void	msvcrt_init_math (void *module)
static double	ret_nan (BOOL update_sw)
int CDECL	_matherr (struct _exception *e)
double	math_error (int type, const char *name, double arg1, double arg2, double retval)
void CDECL	__setusermatherr (MSVCRT_matherr_func func)
int CDECL	_set_SSE2_enable (int flag)
float CDECL	_chgsignf (float num)
int CDECL	_fpclassf (float num)
int CDECL	_finitef (float num)
int CDECL	_isnanf (float num)
float CDECL	MSVCRT_atanf (float x)
short CDECL	_fdclass (float x)
static BOOL	sqrtf_validate (float *x)
float CDECL	MSVCRT_sqrtf (float x)
float CDECL	MSVCRT_tanhf (float x)
double CDECL	MSVCRT_asin (double x)
double CDECL	MSVCRT_atan (double x)
double CDECL	MSVCRT_exp (double x)
short CDECL	_dclass (double x)
static BOOL	sqrt_validate (double *x, BOOL update_sw)
double CDECL	MSVCRT_sqrt (double x)
double CDECL	MSVCRT_tanh (double x)
int CDECL	_fpclass (double num)
unsigned int CDECL	MSVCRT__rotl (unsigned int num, int shift)
__msvcrt_ulong CDECL	MSVCRT__lrotl (__msvcrt_ulong num, int shift)
__msvcrt_ulong CDECL	MSVCRT__lrotr (__msvcrt_ulong num, int shift)
unsigned int CDECL	MSVCRT__rotr (unsigned int num, int shift)
unsigned __int64 CDECL	MSVCRT__rotl64 (unsigned __int64 num, int shift)
unsigned __int64 CDECL	MSVCRT__rotr64 (unsigned __int64 num, int shift)
int CDECL	abs (int n)
__msvcrt_long CDECL	labs (__msvcrt_long n)
__int64 CDECL	_abs64 (__int64 n)
static void	_setfp (unsigned int *cw, unsigned int cw_mask, unsigned int *sw, unsigned int sw_mask)
unsigned int CDECL	_statusfp (void)
unsigned int CDECL	_clearfp (void)
int *CDECL	__fpecode (void)
double CDECL	ldexp (double num, int exp)
double CDECL	_cabs (struct _complex num)
double CDECL	_chgsign (double num)
unsigned int CDECL	_control87 (unsigned int newval, unsigned int mask)
unsigned int CDECL	_controlfp (unsigned int newval, unsigned int mask)
void CDECL	_set_controlfp (unsigned int newval, unsigned int mask)
int CDECL	_controlfp_s (unsigned int *cur, unsigned int newval, unsigned int mask)
int CDECL	_finite (double num)
void CDECL	_fpreset (void)
int CDECL	_isnan (double num)
char *CDECL	_ecvt (double number, int ndigits, int *decpt, int *sign)
int CDECL	_ecvt_s (char *buffer, size_t length, double number, int ndigits, int *decpt, int *sign)
char *CDECL	_fcvt (double number, int ndigits, int *decpt, int *sign)
int CDECL	_fcvt_s (char *outbuffer, size_t size, double number, int ndigits, int *decpt, int *sign)
char *CDECL	_gcvt (double number, int ndigit, char *buff)
int CDECL	_gcvt_s (char *buff, size_t size, double number, int digits)
div_t CDECL	div (int num, int denom)
ldiv_t CDECL	ldiv (__msvcrt_long num, __msvcrt_long denom)
double CDECL	_scalb (double num, __msvcrt_long power)
float CDECL	_scalbf (float num, __msvcrt_long power)

Variables
static MSVCRT_matherr_func	MSVCRT_default_matherr_func = NULL
BOOL	sse2_supported
static BOOL	sse2_enabled

Macro Definition Documentation

_DOMAIN

#define _DOMAIN   1 /* domain error in argument */

Definition at line 62 of file math.c.

_OVERFLOW

#define _OVERFLOW   3 /* range overflow */

Definition at line 64 of file math.c.

_SING

#define _SING   2 /* singularity */

Definition at line 63 of file math.c.

_UNDERFLOW

#define _UNDERFLOW   4 /* range underflow */

Definition at line 65 of file math.c.

RESET_X87_CW

#define RESET_X87_CW

Value:

    "movw (%esp), %ax\n\t" \
    "cmpw %ax, 2(%esp)\n\t" \
    "je 1f\n\t" \
    "fstpl 8(%esp)\n\t" \
    "fldcw (%esp)\n\t" \
    "fldl 8(%esp)\n\t" \
    "fwait\n\t" \
    "1:\n\t" \
    "addl $4, %esp\n\t" \
    __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")

Definition at line 104 of file math.c.

SET_X87_CW

#define SET_X87_CW

(

MASK

)

Value:

    "subl $4, %esp\n\t" \
    __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t") \
    "fnstcw (%esp)\n\t" \
    "movw (%esp), %ax\n\t" \
    "movw %ax, 2(%esp)\n\t" \
    "testw $" #MASK ", %ax\n\t" \
    "jz 1f\n\t" \
    "andw $~" #MASK ", %ax\n\t" \
    "movw %ax, 2(%esp)\n\t" \
    "fldcw 2(%esp)\n\t" \
    "1:\n\t"

Definition at line 91 of file math.c.

Typedef Documentation

MSVCRT_matherr_func

typedef int(CDECL * MSVCRT_matherr_func) (struct _exception *)

Definition at line 67 of file math.c.

Function Documentation

__fpecode()

int *CDECL __fpecode

(

void

)

Definition at line 1195 of file math.c.

{
    return &msvcrt_get_thread_data()->fpecode;
}

__setusermatherr()

void CDECL __setusermatherr

(

MSVCRT_matherr_func

func

)

Definition at line 159 of file math.c.

{
    MSVCRT_default_matherr_func = func;
    TRACE("new matherr handler %p\n", func);
}

_abs64()

__int64 CDECL _abs64

(

__int64

n

)

Definition at line 711 of file math.c.

{
    return n >= 0 ? n : -n;
}

_cabs()

double CDECL _cabs

(

struct _complex

num

)

Definition at line 1219 of file math.c.

{
  return sqrt(num.x * num.x + num.y * num.y);
}

_chgsign()

double CDECL _chgsign

(

double

num

)

Definition at line 1227 of file math.c.

{
    union { double f; UINT64 i; } u = { num };
    u.i ^= 1ull << 63;
    return u.f;
}

_chgsignf()

float CDECL _chgsignf

(

float

num

)

Definition at line 203 of file math.c.

{
    union { float f; UINT32 i; } u = { num };
    u.i ^= 0x80000000;
    return u.f;
}

_clearfp()

unsigned int CDECL _clearfp

(

void

)

Definition at line 1174 of file math.c.

{
    unsigned int flags = 0;
#ifdef __i386__
    _setfp(NULL, 0, &flags, _MCW_EM);
    if (sse2_supported)
    {
        unsigned int sse_sw = 0;
 
        _setfp_sse(NULL, 0, &sse_sw, _MCW_EM);
        flags |= sse_sw;
    }
#else
    _setfp(NULL, 0, &flags, _MCW_EM);
#endif
    return flags;
}

_control87()

unsigned int CDECL _control87	(	unsigned int	newval,
		unsigned int	mask
	)

Definition at line 1265 of file math.c.

{
    unsigned int flags = 0;
#if defined(__i386__) && (_MSVCR_VER == 0 || _MSVCR_VER >= 80)
    unsigned int sse2_cw;
 
    __control87_2( newval, mask, &flags, &sse2_cw );
 
    if (sse2_supported)
    {
        if ((flags ^ sse2_cw) & (_MCW_EM | _MCW_RC)) flags |= _EM_AMBIGUOUS;
        flags |= sse2_cw;
    }
#else
    flags = newval;
    _setfp(&flags, mask, NULL, 0);
#endif
    return flags;
}

Referenced by _controlfp().

_controlfp()

unsigned int CDECL _controlfp	(	unsigned int	newval,
		unsigned int	mask
	)

Definition at line 1288 of file math.c.

{
  return _control87( newval, mask & ~_EM_DENORMAL );
}

Referenced by _controlfp_s(), and _set_controlfp().

_controlfp_s()

int CDECL _controlfp_s	(	unsigned int *	cur,
		unsigned int	newval,
		unsigned int	mask
	)

Definition at line 1304 of file math.c.

{
    static const unsigned int all_flags = (_MCW_EM | _MCW_IC | _MCW_RC |
                                           _MCW_PC | _MCW_DN);
    unsigned int val;
 
    if (!MSVCRT_CHECK_PMT( !(newval & mask & ~all_flags) ))
    {
        if (cur) *cur = _controlfp( 0, 0 );  /* retrieve it anyway */
        return EINVAL;
    }
    val = _controlfp( newval, mask );
    if (cur) *cur = val;
    return 0;
}

_dclass()

short CDECL _dclass

(

double

x

)

Referenced by sqrt_validate().

_ecvt()

char *CDECL _ecvt	(	double	number,
		int	ndigits,
		int *	decpt,
		int *	sign
	)

Definition at line 1748 of file math.c.

{
    int prec, len;
    thread_data_t *data = msvcrt_get_thread_data();
    /* FIXME: check better for overflow (native supports over 300 chars) */
    ndigits = min( ndigits, 80 - 8); /* 8 : space for sign, dec point, "e",
                                      * 4 for exponent and one for
                                      * terminating '\0' */
    if (!data->efcvt_buffer)
        data->efcvt_buffer = malloc( 80 ); /* ought to be enough */
 
    /* handle cases with zero ndigits or less */
    prec = ndigits;
    if( prec < 1) prec = 2;
    len = _snprintf(data->efcvt_buffer, 80, "%.*le", prec - 1, number);
 
    if (data->efcvt_buffer[0] == '-') {
        memmove( data->efcvt_buffer, data->efcvt_buffer + 1, len-- );
        *sign = 1;
    } else *sign = 0;
 
    /* take the decimal "point away */
    if( prec != 1)
        memmove( data->efcvt_buffer + 1, data->efcvt_buffer + 2, len - 1 );
    /* take the exponential "e" out */
    data->efcvt_buffer[ prec] = '\0';
    /* read the exponent */
    sscanf( data->efcvt_buffer + prec + 1, "%d", decpt);
    (*decpt)++;
    /* adjust for some border cases */
    if( data->efcvt_buffer[0] == '0')/* value is zero */
        *decpt = 0;
    /* handle cases with zero ndigits or less */
    if( ndigits < 1){
        if( data->efcvt_buffer[ 0] >= '5')
            (*decpt)++;
        data->efcvt_buffer[ 0] = '\0';
    }
    TRACE("out=\"%s\"\n",data->efcvt_buffer);
    return data->efcvt_buffer;
}

_ecvt_s()

int CDECL _ecvt_s	(	char *	buffer,
		size_t	length,
		double	number,
		int	ndigits,
		int *	decpt,
		int *	sign
	)

Definition at line 1793 of file math.c.

{
    int prec, len;
    char *result;
 
    if (!MSVCRT_CHECK_PMT(buffer != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(decpt != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(sign != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT_ERR( length > 2, ERANGE )) return ERANGE;
    if (!MSVCRT_CHECK_PMT_ERR(ndigits < (int)length - 1, ERANGE )) return ERANGE;
 
    /* handle cases with zero ndigits or less */
    prec = ndigits;
    if( prec < 1) prec = 2;
    result = malloc(prec + 8);
 
    len = _snprintf(result, prec + 8, "%.*le", prec - 1, number);
    if (result[0] == '-') {
        memmove( result, result + 1, len-- );
        *sign = 1;
    } else *sign = 0;
 
    /* take the decimal "point away */
    if( prec != 1)
        memmove( result + 1, result + 2, len - 1 );
    /* take the exponential "e" out */
    result[ prec] = '\0';
    /* read the exponent */
    sscanf( result + prec + 1, "%d", decpt);
    (*decpt)++;
    /* adjust for some border cases */
    if( result[0] == '0')/* value is zero */
        *decpt = 0;
    /* handle cases with zero ndigits or less */
    if( ndigits < 1){
        if( result[ 0] >= '5')
            (*decpt)++;
        result[ 0] = '\0';
    }
    memcpy( buffer, result, max(ndigits + 1, 1) );
    free( result );
    return 0;
}

_fcvt()

char *CDECL _fcvt	(	double	number,
		int	ndigits,
		int *	decpt,
		int *	sign
	)

Definition at line 1840 of file math.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
    int stop, dec1, dec2;
    char *ptr1, *ptr2, *first;
    char buf[80]; /* ought to be enough */
    char decimal_separator = get_locinfo()->lconv->decimal_point[0];
 
    if (!data->efcvt_buffer)
        data->efcvt_buffer = malloc( 80 ); /* ought to be enough */
 
    stop = _snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
    ptr1 = buf;
    ptr2 = data->efcvt_buffer;
    first = NULL;
    dec1 = 0;
    dec2 = 0;
 
    if (*ptr1 == '-') {
        *sign = 1;
        ptr1++;
    } else *sign = 0;
 
    /* For numbers below the requested resolution, work out where
       the decimal point will be rather than finding it in the string */
    if (number < 1.0 && number > 0.0) {
    dec2 = log10(number + 1e-10);
    if (-dec2 <= ndigits) dec2 = 0;
    }
 
    /* If requested digits is zero or less, we will need to truncate
     * the returned string */
    if (ndigits < 1) {
    stop += ndigits;
    }
 
    while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
    while (*ptr1 != '\0' && *ptr1 != decimal_separator) {
    if (!first) first = ptr2;
    if ((ptr1 - buf) < stop) {
        *ptr2++ = *ptr1++;
    } else {
        ptr1++;
    }
    dec1++;
    }
 
    if (ndigits > 0) {
    ptr1++;
    if (!first) {
        while (*ptr1 == '0') { /* Process leading zeroes */
        *ptr2++ = *ptr1++;
        dec1--;
        }
    }
    while (*ptr1 != '\0') {
        if (!first) first = ptr2;
        *ptr2++ = *ptr1++;
    }
    }
 
    *ptr2 = '\0';
 
    /* We never found a non-zero digit, then our number is either
     * smaller than the requested precision, or 0.0 */
    if (!first) {
    if (number > 0.0) {
        first = ptr2;
    } else {
        first = data->efcvt_buffer;
        dec1 = 0;
    }
    }
 
    *decpt = dec2 ? dec2 : dec1;
    return first;
}

_fcvt_s()

int CDECL _fcvt_s	(	char *	outbuffer,
		size_t	size,
		double	number,
		int	ndigits,
		int *	decpt,
		int *	sign
	)

Definition at line 1921 of file math.c.

{
    int stop, dec1, dec2;
    char *ptr1, *ptr2, *first;
    char buf[80]; /* ought to be enough */
    char decimal_separator = get_locinfo()->lconv->decimal_point[0];
 
    if (!outbuffer || !decpt || !sign || size == 0)
    {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    stop = _snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
    ptr1 = buf;
    ptr2 = outbuffer;
    first = NULL;
    dec1 = 0;
    dec2 = 0;
 
    if (*ptr1 == '-') {
        *sign = 1;
        ptr1++;
    } else *sign = 0;
 
    /* For numbers below the requested resolution, work out where
       the decimal point will be rather than finding it in the string */
    if (number < 1.0 && number > 0.0) {
    dec2 = log10(number + 1e-10);
    if (-dec2 <= ndigits) dec2 = 0;
    }
 
    /* If requested digits is zero or less, we will need to truncate
     * the returned string */
    if (ndigits < 1) {
    stop += ndigits;
    }
 
    while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
    while (*ptr1 != '\0' && *ptr1 != decimal_separator) {
    if (!first) first = ptr2;
    if ((ptr1 - buf) < stop) {
        if (size > 1) {
                *ptr2++ = *ptr1++;
                size--;
            }
    } else {
        ptr1++;
    }
    dec1++;
    }
 
    if (ndigits > 0) {
    ptr1++;
    if (!first) {
        while (*ptr1 == '0') { /* Process leading zeroes */
                if (number == 0.0 && size > 1) {
                    *ptr2++ = '0';
                    size--;
                }
                ptr1++;
        dec1--;
        }
    }
    while (*ptr1 != '\0') {
        if (!first) first = ptr2;
        if (size > 1) {
                *ptr2++ = *ptr1++;
                size--;
            }
    }
    }
 
    *ptr2 = '\0';
 
    /* We never found a non-zero digit, then our number is either
     * smaller than the requested precision, or 0.0 */
    if (!first && (number <= 0.0))
        dec1 = 0;
 
    *decpt = dec2 ? dec2 : dec1;
    return 0;
}

_fdclass()

short CDECL _fdclass

(

float

x

)

Referenced by sqrtf_validate().

_finite()

int CDECL _finite

(

double

num

)

Definition at line 1582 of file math.c.

{
    union { double f; UINT64 i; } u = { num };
    return (u.i & ~0ull >> 1) < 0x7ffull << 52;
}

_finitef()

int CDECL _finitef

(

float

num

)

Definition at line 239 of file math.c.

{
    union { float f; UINT32 i; } u = { num };
    return (u.i & 0x7fffffff) < 0x7f800000;
}

_fpclass()

int CDECL _fpclass

(

double

num

)

Definition at line 595 of file math.c.

{
    union { double f; UINT64 i; } u = { num };
    int e = u.i >> 52 & 0x7ff;
    int s = u.i >> 63;
 
    switch (e)
    {
    case 0:
        if (u.i << 1) return s ? _FPCLASS_ND : _FPCLASS_PD;
        return s ? _FPCLASS_NZ : _FPCLASS_PZ;
    case 0x7ff:
        if (u.i << 12) return ((u.i >> 51) & 1) ? _FPCLASS_QNAN : _FPCLASS_SNAN;
        return s ? _FPCLASS_NINF : _FPCLASS_PINF;
    default:
        return s ? _FPCLASS_NN : _FPCLASS_PN;
    }
}

_fpclassf()

int CDECL _fpclassf

(

float

num

)

Definition at line 217 of file math.c.

{
    union { float f; UINT32 i; } u = { num };
    int e = u.i >> 23 & 0xff;
    int s = u.i >> 31;
 
    switch (e)
    {
    case 0:
        if (u.i << 1) return s ? _FPCLASS_ND : _FPCLASS_PD;
        return s ? _FPCLASS_NZ : _FPCLASS_PZ;
    case 0xff:
        if (u.i << 9) return ((u.i >> 22) & 1) ? _FPCLASS_QNAN : _FPCLASS_SNAN;
        return s ? _FPCLASS_NINF : _FPCLASS_PINF;
    default:
        return s ? _FPCLASS_NN : _FPCLASS_PN;
    }
}

_fpreset()

void CDECL _fpreset

(

void

)

Definition at line 1591 of file math.c.

{
#if (defined(__GNUC__) || defined(__clang__)) && defined(__i386__)
    const unsigned int x86_cw = 0x27f;
    __asm__ __volatile__( "fninit; fldcw %0" : : "m" (x86_cw) );
    if (sse2_supported)
    {
        unsigned int cw = _MCW_EM, sw = 0;
        _setfp_sse(&cw, ~0, &sw, ~0);
    }
#else
    unsigned int cw = _MCW_EM, sw = 0;
    _setfp(&cw, ~0, &sw, ~0);
#endif
}

_gcvt()

char *CDECL _gcvt	(	double	number,
		int	ndigit,
		char *	buff
	)

Definition at line 2008 of file math.c.

{
    if(!buff) {
        *_errno() = EINVAL;
        return NULL;
    }
 
    if(ndigit < 0) {
        *_errno() = ERANGE;
        return NULL;
    }
 
    sprintf(buff, "%.*g", ndigit, number);
    return buff;
}

_gcvt_s()

int CDECL _gcvt_s	(	char *	buff,
		size_t	size,
		double	number,
		int	digits
	)

Definition at line 2027 of file math.c.

{
    int len;
 
    if(!buff) {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    if( digits<0 || digits>=size) {
        if(size)
            buff[0] = '\0';
 
        *_errno() = ERANGE;
        return ERANGE;
    }
 
    len = _scprintf("%.*g", digits, number);
    if(len > size) {
        buff[0] = '\0';
        *_errno() = ERANGE;
        return ERANGE;
    }
 
    sprintf(buff, "%.*g", digits, number);
    return 0;
}

_isnan()

int CDECL _isnan

(

double

num

)

Definition at line 1660 of file math.c.

{
    union { double f; UINT64 i; } u = { num };
    return (u.i & ~0ull >> 1) > 0x7ffull << 52;
}

Referenced by cvt(), format_float(), ldexp(), nexttowardf(), rpn_acos(), rpn_acosh(), rpn_asin(), rpn_asinh(), rpn_atan(), rpn_atanh(), rpn_cosh(), rpn_pow_f(), rpn_sinh(), rpn_sqr_f(), rpn_tanh(), Test__isnan(), test_isnan(), TRIO_ARGS1(), ulp_error_dbl(), and ulp_error_flt().

_isnanf()

int CDECL _isnanf

(

float

num

)

Definition at line 248 of file math.c.

{
    union { float f; UINT32 i; } u = { num };
    return (u.i & 0x7fffffff) > 0x7f800000;
}

Referenced by Test__isnanf().

_matherr()

int CDECL _matherr

(

struct _exception *

e

)

Definition at line 119 of file math.c.

{
    return 0;
}

_scalb()

double CDECL _scalb	(	double	num,
		__msvcrt_long	power
	)

Definition at line 2874 of file math.c.

{
  return ldexp(num, power);
}

_scalbf()

float CDECL _scalbf	(	float	num,
		__msvcrt_long	power
	)

Definition at line 2884 of file math.c.

{
  return ldexp(num, power);
}

_set_controlfp()

void CDECL _set_controlfp	(	unsigned int	newval,
		unsigned int	mask
	)

Definition at line 1296 of file math.c.

{
    _controlfp( newval, mask );
}

_set_SSE2_enable()

int CDECL _set_SSE2_enable

(

int

flag

)

Definition at line 168 of file math.c.

{
    sse2_enabled = flag && sse2_supported;
    return sse2_enabled;
}

_setfp()

static void _setfp ( unsigned int *  cw, unsigned int  cw_mask, unsigned int *  sw, unsigned int  sw_mask  )

static

Definition at line 842 of file math.c.

{
#if (defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)) && defined(__i386__)
    unsigned long oldcw = 0, newcw = 0;
    unsigned long oldsw = 0, newsw = 0;
    unsigned int flags;
 
    cw_mask &= _MCW_EM | _MCW_IC | _MCW_RC | _MCW_PC;
    sw_mask &= _MCW_EM;
 
    if (sw)
    {
#ifdef _MSC_VER
        __asm { fstsw newsw }
#else
        __asm__ __volatile__( "fstsw %0" : "=m" (newsw) );
#endif
        oldsw = newsw;
 
        flags = 0;
        if (newsw & 0x1) flags |= _SW_INVALID;
        if (newsw & 0x2) flags |= _SW_DENORMAL;
        if (newsw & 0x4) flags |= _SW_ZERODIVIDE;
        if (newsw & 0x8) flags |= _SW_OVERFLOW;
        if (newsw & 0x10) flags |= _SW_UNDERFLOW;
        if (newsw & 0x20) flags |= _SW_INEXACT;
 
        *sw = (flags & ~sw_mask) | (*sw & sw_mask);
        TRACE("x86 update sw %08x to %08x\n", flags, *sw);
        newsw &= ~0x3f;
        if (*sw & _SW_INVALID) newsw |= 0x1;
        if (*sw & _SW_DENORMAL) newsw |= 0x2;
        if (*sw & _SW_ZERODIVIDE) newsw |= 0x4;
        if (*sw & _SW_OVERFLOW) newsw |= 0x8;
        if (*sw & _SW_UNDERFLOW) newsw |= 0x10;
        if (*sw & _SW_INEXACT) newsw |= 0x20;
        *sw = flags;
    }
 
    if (cw)
    {
#ifdef _MSC_VER
        __asm { fstcw newcw }
#else
       __asm__ __volatile__( "fstcw %0" : "=m" (newcw) );
#endif
        oldcw = newcw;
 
        flags = 0;
        if (newcw & 0x1) flags |= _EM_INVALID;
        if (newcw & 0x2) flags |= _EM_DENORMAL;
        if (newcw & 0x4) flags |= _EM_ZERODIVIDE;
        if (newcw & 0x8) flags |= _EM_OVERFLOW;
        if (newcw & 0x10) flags |= _EM_UNDERFLOW;
        if (newcw & 0x20) flags |= _EM_INEXACT;
        switch (newcw & 0xc00)
        {
        case 0xc00: flags |= _RC_UP|_RC_DOWN; break;
        case 0x800: flags |= _RC_UP; break;
        case 0x400: flags |= _RC_DOWN; break;
        }
        switch (newcw & 0x300)
        {
        case 0x0: flags |= _PC_24; break;
        case 0x200: flags |= _PC_53; break;
        case 0x300: flags |= _PC_64; break;
        }
        if (newcw & 0x1000) flags |= _IC_AFFINE;
 
        *cw = (flags & ~cw_mask) | (*cw & cw_mask);
        TRACE("x86 update cw %08x to %08x\n", flags, *cw);
        newcw &= ~0x1f3f;
        if (*cw & _EM_INVALID) newcw |= 0x1;
        if (*cw & _EM_DENORMAL) newcw |= 0x2;
        if (*cw & _EM_ZERODIVIDE) newcw |= 0x4;
        if (*cw & _EM_OVERFLOW) newcw |= 0x8;
        if (*cw & _EM_UNDERFLOW) newcw |= 0x10;
        if (*cw & _EM_INEXACT) newcw |= 0x20;
        switch (*cw & _MCW_RC)
        {
        case _RC_UP|_RC_DOWN: newcw |= 0xc00; break;
        case _RC_UP: newcw |= 0x800; break;
        case _RC_DOWN: newcw |= 0x400; break;
        }
        switch (*cw & _MCW_PC)
        {
        case _PC_64: newcw |= 0x300; break;
        case _PC_53: newcw |= 0x200; break;
        case _PC_24: newcw |= 0x0; break;
        }
        if (*cw & _IC_AFFINE) newcw |= 0x1000;
    }
 
    if (oldsw != newsw && (newsw & 0x3f))
    {
        struct {
            WORD control_word;
            WORD unused1;
            WORD status_word;
            WORD unused2;
            WORD tag_word;
            WORD unused3;
            DWORD instruction_pointer;
            WORD code_segment;
            WORD unused4;
            DWORD operand_addr;
            WORD data_segment;
            WORD unused5;
        } fenv;
 
        assert(cw);
 
#ifdef _MSC_VER
        __asm { fnstenv fenv }
#else
        __asm__ __volatile__( "fnstenv %0" : "=m" (fenv) );
#endif
        fenv.control_word = newcw;
        fenv.status_word = newsw;
#ifdef _MSC_VER
        __asm { fldenv fenv }
#else
        __asm__ __volatile__( "fldenv %0" : : "m" (fenv) : "st", "st(1)",
                "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)" );
#endif
        return;
    }
 
    if (oldsw != newsw)
#ifdef _MSC_VER
        __asm { fnclex }
#else
        __asm__ __volatile__( "fnclex" );
#endif
    if (oldcw != newcw)
#ifdef _MSC_VER
        __asm { fldcw newcw }
#else
        __asm__ __volatile__( "fldcw %0" : : "m" (newcw) );
#endif
#elif defined(__x86_64__)
    _setfp_sse(cw, cw_mask, sw, sw_mask);
#elif defined(__aarch64__)
    ULONG_PTR old_fpsr = 0, fpsr = 0, old_fpcr = 0, fpcr = 0;
    unsigned int flags;
 
    cw_mask &= _MCW_EM | _MCW_RC;
    sw_mask &= _MCW_EM;
 
    if (sw)
    {
        __asm__ __volatile__( "mrs %0, fpsr" : "=r" (fpsr) );
        old_fpsr = fpsr;
 
        flags = 0;
        if (fpsr & 0x1) flags |= _SW_INVALID;
        if (fpsr & 0x2) flags |= _SW_ZERODIVIDE;
        if (fpsr & 0x4) flags |= _SW_OVERFLOW;
        if (fpsr & 0x8) flags |= _SW_UNDERFLOW;
        if (fpsr & 0x10) flags |= _SW_INEXACT;
        if (fpsr & 0x80) flags |= _SW_DENORMAL;
 
        *sw = (flags & ~sw_mask) | (*sw & sw_mask);
        TRACE("aarch64 update sw %08x to %08x\n", flags, *sw);
        fpsr &= ~0x9f;
        if (*sw & _SW_INVALID) fpsr |= 0x1;
        if (*sw & _SW_ZERODIVIDE) fpsr |= 0x2;
        if (*sw & _SW_OVERFLOW) fpsr |= 0x4;
        if (*sw & _SW_UNDERFLOW) fpsr |= 0x8;
        if (*sw & _SW_INEXACT) fpsr |= 0x10;
        if (*sw & _SW_DENORMAL) fpsr |= 0x80;
        *sw = flags;
    }
 
    if (cw)
    {
        __asm__ __volatile__( "mrs %0, fpcr" : "=r" (fpcr) );
        old_fpcr = fpcr;
 
        flags = 0;
        if (!(fpcr & 0x100)) flags |= _EM_INVALID;
        if (!(fpcr & 0x200)) flags |= _EM_ZERODIVIDE;
        if (!(fpcr & 0x400)) flags |= _EM_OVERFLOW;
        if (!(fpcr & 0x800)) flags |= _EM_UNDERFLOW;
        if (!(fpcr & 0x1000)) flags |= _EM_INEXACT;
        if (!(fpcr & 0x8000)) flags |= _EM_DENORMAL;
        switch (fpcr & 0xc00000)
        {
        case 0x400000: flags |= _RC_UP; break;
        case 0x800000: flags |= _RC_DOWN; break;
        case 0xc00000: flags |= _RC_CHOP; break;
        }
 
        *cw = (flags & ~cw_mask) | (*cw & cw_mask);
        TRACE("aarch64 update cw %08x to %08x\n", flags, *cw);
        fpcr &= ~0xc09f00ul;
        if (!(*cw & _EM_INVALID)) fpcr |= 0x100;
        if (!(*cw & _EM_ZERODIVIDE)) fpcr |= 0x200;
        if (!(*cw & _EM_OVERFLOW)) fpcr |= 0x400;
        if (!(*cw & _EM_UNDERFLOW)) fpcr |= 0x800;
        if (!(*cw & _EM_INEXACT)) fpcr |= 0x1000;
        if (!(*cw & _EM_DENORMAL)) fpcr |= 0x8000;
        switch (*cw & _MCW_RC)
        {
        case _RC_CHOP: fpcr |= 0xc00000; break;
        case _RC_UP: fpcr |= 0x400000; break;
        case _RC_DOWN: fpcr |= 0x800000; break;
        }
    }
 
    /* mask exceptions if needed */
    if (old_fpcr != fpcr && ~(old_fpcr >> 8) & fpsr & 0x9f != fpsr & 0x9f)
    {
        ULONG_PTR mask = fpcr & ~0x9f00;
        __asm__ __volatile__( "msr fpcr, %0" :: "r" (mask) );
    }
 
    if (old_fpsr != fpsr)
        __asm__ __volatile__( "msr fpsr, %0" :: "r" (fpsr) );
    if (old_fpcr != fpcr)
        __asm__ __volatile__( "msr fpcr, %0" :: "r" (fpcr) );
#elif defined(__arm__)
    DWORD old_fpscr, fpscr;
    unsigned int flags;
 
    __asm__ __volatile__( "vmrs %0, fpscr" : "=r" (fpscr) );
    old_fpscr = fpscr;
 
    cw_mask &= _MCW_EM | _MCW_RC;
    sw_mask &= _MCW_EM;
 
    if (sw)
    {
        flags = 0;
        if (fpscr & 0x1) flags |= _SW_INVALID;
        if (fpscr & 0x2) flags |= _SW_ZERODIVIDE;
        if (fpscr & 0x4) flags |= _SW_OVERFLOW;
        if (fpscr & 0x8) flags |= _SW_UNDERFLOW;
        if (fpscr & 0x10) flags |= _SW_INEXACT;
        if (fpscr & 0x80) flags |= _SW_DENORMAL;
 
        *sw = (flags & ~sw_mask) | (*sw & sw_mask);
        TRACE("arm update sw %08x to %08x\n", flags, *sw);
        fpscr &= ~0x9f;
        if (*sw & _SW_INVALID) fpscr |= 0x1;
        if (*sw & _SW_ZERODIVIDE) fpscr |= 0x2;
        if (*sw & _SW_OVERFLOW) fpscr |= 0x4;
        if (*sw & _SW_UNDERFLOW) fpscr |= 0x8;
        if (*sw & _SW_INEXACT) fpscr |= 0x10;
        if (*sw & _SW_DENORMAL) fpscr |= 0x80;
        *sw = flags;
    }
 
    if (cw)
    {
        flags = 0;
        if (!(fpscr & 0x100)) flags |= _EM_INVALID;
        if (!(fpscr & 0x200)) flags |= _EM_ZERODIVIDE;
        if (!(fpscr & 0x400)) flags |= _EM_OVERFLOW;
        if (!(fpscr & 0x800)) flags |= _EM_UNDERFLOW;
        if (!(fpscr & 0x1000)) flags |= _EM_INEXACT;
        if (!(fpscr & 0x8000)) flags |= _EM_DENORMAL;
        switch (fpscr & 0xc00000)
        {
        case 0x400000: flags |= _RC_UP; break;
        case 0x800000: flags |= _RC_DOWN; break;
        case 0xc00000: flags |= _RC_CHOP; break;
        }
 
        *cw = (flags & ~cw_mask) | (*cw & cw_mask);
        TRACE("arm update cw %08x to %08x\n", flags, *cw);
        fpscr &= ~0xc09f00ul;
        if (!(*cw & _EM_INVALID)) fpscr |= 0x100;
        if (!(*cw & _EM_ZERODIVIDE)) fpscr |= 0x200;
        if (!(*cw & _EM_OVERFLOW)) fpscr |= 0x400;
        if (!(*cw & _EM_UNDERFLOW)) fpscr |= 0x800;
        if (!(*cw & _EM_INEXACT)) fpscr |= 0x1000;
        if (!(*cw & _EM_DENORMAL)) fpscr |= 0x8000;
        switch (*cw & _MCW_RC)
        {
        case _RC_CHOP: fpscr |= 0xc00000; break;
        case _RC_UP: fpscr |= 0x400000; break;
        case _RC_DOWN: fpscr |= 0x800000; break;
        }
    }
 
    if (old_fpscr != fpscr)
        __asm__ __volatile__( "vmsr fpscr, %0" :: "r" (fpscr) );
#else
    FIXME("not implemented\n");
    if (cw) *cw = 0;
    if (sw) *sw = 0;
#endif
}

Referenced by _clearfp(), _control87(), _fpreset(), and _statusfp().

_statusfp()

unsigned int CDECL _statusfp

(

void

)

Definition at line 1156 of file math.c.

{
    unsigned int flags = 0;
#if defined(__i386__)
    unsigned int x86_sw, sse2_sw;
 
    _statusfp2( &x86_sw, &sse2_sw );
    /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
    flags = x86_sw | sse2_sw;
#else
    _setfp(NULL, 0, &flags, 0);
#endif
    return flags;
}

abs()

int CDECL abs

(

int

n

)

Definition at line 672 of file math.c.

{
    return n >= 0 ? n : -n;
}

div()

div_t CDECL div	(	int	num,
		int	denom
	)

Definition at line 2081 of file math.c.

{
    div_t ret;
 
    ret.quot = num / denom;
    ret.rem = num % denom;
    return ret;
}

labs()

__msvcrt_long CDECL labs

(

__msvcrt_long

n

)

Definition at line 680 of file math.c.

{
    return n >= 0 ? n : -n;
}

ldexp()

double CDECL ldexp	(	double	num,
		int	exp
	)

Definition at line 1204 of file math.c.

{
  double z = scalbn(num, exp);
 
  if (isfinite(num) && !isfinite(z))
    return math_error(_OVERFLOW, "ldexp", num, exp, z);
  if (num && isfinite(num) && !z)
    return math_error(_UNDERFLOW, "ldexp", num, exp, z);
  return z;
}

Referenced by _scalb(), and _scalbf().

ldiv()

ldiv_t CDECL ldiv	(	__msvcrt_long	num,
		__msvcrt_long	denom
	)

Definition at line 2115 of file math.c.

{
    ldiv_t ret;
 
    ret.quot = num / denom;
    ret.rem = num % denom;
    return ret;
}

math_error()

double math_error	(	int	type,
		const char *	name,
		double	arg1,
		double	arg2,
		double	retval
	)

Definition at line 125 of file math.c.

{
    struct _exception exception = {type, (char *)name, arg1, arg2, retval};
 
    TRACE("(%d, %s, %g, %g, %g)\n", type, debugstr_a(name), arg1, arg2, retval);
 
    if (MSVCRT_default_matherr_func && MSVCRT_default_matherr_func(&exception))
        return exception.retval;
 
    switch (type)
    {
    case 0:
        /* don't set errno */
        break;
    case _DOMAIN:
        *_errno() = EDOM;
        break;
    case _SING:
    case _OVERFLOW:
        *_errno() = ERANGE;
        break;
    case _UNDERFLOW:
        /* don't set errno */
        break;
    default:
        ERR("Unhandled math error!\n");
    }
 
    return exception.retval;
}

Referenced by ldexp(), MSVCRT_asin(), MSVCRT_atan(), MSVCRT_atanf(), MSVCRT_exp(), MSVCRT_tanh(), MSVCRT_tanhf(), sqrt_validate(), and sqrtf_validate().

MSVCRT__lrotl()

__msvcrt_ulong CDECL MSVCRT__lrotl	(	__msvcrt_ulong	num,
		int	shift
	)

Definition at line 627 of file math.c.

{
  shift &= 0x1f;
  return (num << shift) | (num >> (32-shift));
}

MSVCRT__lrotr()

__msvcrt_ulong CDECL MSVCRT__lrotr	(	__msvcrt_ulong	num,
		int	shift
	)

Definition at line 636 of file math.c.

{
  shift &= 0x1f;
  return (num >> shift) | (num << (32-shift));
}

MSVCRT__rotl()

unsigned int CDECL MSVCRT__rotl	(	unsigned int	num,
		int	shift
	)

Definition at line 618 of file math.c.

{
  shift &= 31;
  return (num << shift) | (num >> (32-shift));
}

MSVCRT__rotl64()

unsigned __int64 CDECL MSVCRT__rotl64	(	unsigned __int64	num,
		int	shift
	)

Definition at line 654 of file math.c.

{
  shift &= 63;
  return (num << shift) | (num >> (64-shift));
}

MSVCRT__rotr()

unsigned int CDECL MSVCRT__rotr	(	unsigned int	num,
		int	shift
	)

Definition at line 645 of file math.c.

{
    shift &= 0x1f;
    return (num >> shift) | (num << (32-shift));
}

MSVCRT__rotr64()

unsigned __int64 CDECL MSVCRT__rotr64	(	unsigned __int64	num,
		int	shift
	)

Definition at line 663 of file math.c.

{
    shift &= 63;
    return (num >> shift) | (num << (64-shift));
}

MSVCRT_asin()

double CDECL MSVCRT_asin

(

double

x

)

Definition at line 352 of file math.c.

{
#ifdef __i386__
    unsigned int x87_cw, sse2_cw;
    unsigned int hx = *(ULONGLONG*)&x >> 32;
    unsigned int ix = hx & 0x7fffffff;
 
    if (isnan(x)) return math_error(_DOMAIN, "asin", x, 0, x);
 
    /* |x| < 1 */
    if (ix < 0x3ff00000)
    {
        __control87_2(0, 0, &x87_cw, &sse2_cw);
        if (!sse2_enabled || (x87_cw & _MCW_EM) != _MCW_EM
            || (sse2_cw & (_MCW_EM | _MCW_RC)) != _MCW_EM)
            return x87_asin(x);
    }
#else
    if (isnan(x)) return x;
#endif
 
    return asin( x );
}

MSVCRT_atan()

double CDECL MSVCRT_atan

(

double

x

)

Definition at line 380 of file math.c.

{
    if (isnan(x)) return math_error(_DOMAIN, "atan", x, 0, x);
    return atan( x );
}

MSVCRT_atanf()

float CDECL MSVCRT_atanf

(

float

x

)

Definition at line 258 of file math.c.

{
    if (isnan(x)) return math_error(_DOMAIN, "atanf", x, 0, x);
    return atanf( x );
}

MSVCRT_exp()

double CDECL MSVCRT_exp

(

double

x

)

Definition at line 391 of file math.c.

{
    if (isnan( x )) return math_error(_DOMAIN, "exp", x, 0, 1.0 + x);
    return exp( x );
}

msvcrt_init_math()

void msvcrt_init_math

(

void *

module

)

Definition at line 74 of file math.c.

{
    sse2_supported = IsProcessorFeaturePresent( PF_XMMI64_INSTRUCTIONS_AVAILABLE );
#if _MSVCR_VER <=71
    sse2_enabled = FALSE;
#else
    sse2_enabled = sse2_supported;
#endif
}

MSVCRT_sqrt()

double CDECL MSVCRT_sqrt

(

double

x

)

Definition at line 452 of file math.c.

{
    if (!sqrt_validate(&x, TRUE))
        return x;
 
    return asm_sqrt(x);
}

MSVCRT_sqrtf()

float CDECL MSVCRT_sqrtf

(

float

x

)

Definition at line 303 of file math.c.

{
#ifndef __i386__
    if (!sqrtf_validate(&x))
        return x;
 
    return asm_sqrtf(x);
#else
    return sqrtf( x );
#endif
}

MSVCRT_tanh()

double CDECL MSVCRT_tanh

(

double

x

)

Definition at line 464 of file math.c.

{
    if (isnan( x ))
    {
        *(UINT64*)&x |= 0x0008000000000000ULL;
        return math_error(_DOMAIN, "tanh", x, 0, x);
    }
    return tanh( x );
}

MSVCRT_tanhf()

float CDECL MSVCRT_tanhf

(

float

x

)

Definition at line 319 of file math.c.

{
    if (isnan( x ))
    {
        *(UINT32*)&x |= 0x400000;
        return math_error(_DOMAIN, "tanhf", x, 0, x);
    }
    return tanhf( x );
}

ret_nan()

static double ret_nan ( BOOL  update_sw )

inlinestatic

Definition at line 84 of file math.c.

{
    double x = 1.0;
    if (!update_sw) return -NAN;
    return (x - x) / (x - x);
}

Referenced by JSGlobal_parseFloat(), sqrt_validate(), and sqrtf_validate().

sqrt_validate()

static BOOL sqrt_validate ( double *  x, BOOL  update_sw  )

static

Definition at line 400 of file math.c.

{
    short c = _dclass(*x);
 
    if (c == FP_ZERO) return FALSE;
    if (c == FP_NAN)
    {
#ifdef __i386__
        if (update_sw)
            *x = math_error(_DOMAIN, "sqrt", *x, 0, *x);
#else
        /* set signaling bit */
        *(ULONGLONG*)x |= 0x8000000000000ULL;
#endif
        return FALSE;
    }
    if (signbit(*x))
    {
        *x = math_error(_DOMAIN, "sqrt", *x, 0, ret_nan(update_sw));
        return FALSE;
    }
    if (c == FP_INFINITE) return FALSE;
    return TRUE;
}

Referenced by MSVCRT_sqrt().

sqrtf_validate()

static BOOL sqrtf_validate ( float *  x )

static

Definition at line 268 of file math.c.

{
    short c = _fdclass(*x);
 
    if (c == FP_ZERO) return FALSE;
    if (c == FP_NAN) return FALSE;
    if (signbit(*x))
    {
        *x = math_error(_DOMAIN, "sqrtf", *x, 0, ret_nan(TRUE));
        return FALSE;
    }
    if (c == FP_INFINITE) return FALSE;
    return TRUE;
}

Referenced by MSVCRT_sqrtf().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msvcrt

)

Variable Documentation

MSVCRT_default_matherr_func

MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL

static

Definition at line 69 of file math.c.

Referenced by __setusermatherr(), and math_error().

sse2_enabled

BOOL sse2_enabled

static

Definition at line 72 of file math.c.

Referenced by _set_SSE2_enable(), MSVCRT_asin(), and msvcrt_init_math().

sse2_supported

BOOL sse2_supported

Definition at line 71 of file math.c.

Referenced by _clearfp(), _control87(), _fpreset(), _set_SSE2_enable(), memmove(), and msvcrt_init_math().