diff options
Diffstat (limited to 'sysdeps/ia64/fpu/libm_support.h')
| -rw-r--r-- | sysdeps/ia64/fpu/libm_support.h | 1051 |
1 files changed, 0 insertions, 1051 deletions
diff --git a/sysdeps/ia64/fpu/libm_support.h b/sysdeps/ia64/fpu/libm_support.h deleted file mode 100644 index dc9c0a2648..0000000000 --- a/sysdeps/ia64/fpu/libm_support.h +++ /dev/null @@ -1,1051 +0,0 @@ -/* file: libm_support.h */ - - -/* -// Copyright (c) 2000 - 2004, Intel Corporation -// All rights reserved. -// -// Contributed 2000 by the Intel Numerics Group, Intel Corporation -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// -// * Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// -// * The name of Intel Corporation may not be used to endorse or promote -// products derived from this software without specific prior written -// permission. - -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS -// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY -// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING -// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Intel Corporation is the author of this code, and requests that all -// problem reports or change requests be submitted to it directly at -// http://www.intel.com/software/products/opensource/libraries/num.htm. -// - -// History: 02/02/2000 Initial version -// 2/28/2000 added tags for logb and nextafter -// 3/22/2000 Changes to support _LIB_VERSIONIMF variable -// and filled some enum gaps. Added support for C99. -// 5/31/2000 added prototypes for __libm_frexp_4l/8l -// 8/10/2000 Changed declaration of _LIB_VERSIONIMF to work for library -// builds and other application builds (precompiler directives). -// 8/11/2000 Added pointers-to-matherr-functions declarations to allow -// for user-defined matherr functions in the dll build. -// 12/07/2000 Added scalbn error_types values. -// 5/01/2001 Added error_types values for C99 nearest integer -// functions. -// 6/07/2001 Added error_types values for fdim. -// 6/18/2001 Added include of complex_support.h. -// 8/03/2001 Added error_types values for nexttoward, scalbln. -// 8/23/2001 Corrected tag numbers from 186 and higher. -// 8/27/2001 Added check for long int and long long int definitions. -// 12/10/2001 Added error_types for erfc. -// 12/27/2001 Added error_types for degree argument functions. -// 01/02/2002 Added error_types for tand, cotd. -// 01/04/2002 Delete include of complex_support.h -// 01/23/2002 Deleted prototypes for __libm_frexp*. Added check for -// multiple int, long int, and long long int definitions. -// 05/20/2002 Added error_types for cot. -// 06/27/2002 Added error_types for sinhcosh. -// 12/05/2002 Added error_types for annuity and compound -// 04/10/2003 Added error_types for tgammal/tgamma/tgammaf -// 05/16/2003 FP-treatment macros copied here from IA32 libm_support.h -// 06/02/2003 Added pad into struct fp80 (12/16 bytes). -// 08/01/2003 Added struct ker80 and macros for multiprecision addition, -// subtraction, multiplication, division, square root. -// 08/07/2003 History section updated. -// 09/03/2003 ALIGN(n) macro added. -// 10/01/2003 LDOUBLE_ALIGN and fp80 corrected on linux to 16 bytes. -// 11/24/2004 Added ifdef around definitions of INT32/64 -// 12/15/2004 Added error_types for exp10, nextafter, nexttoward -// underflow. Moved error codes into libm_error_codes.h. -// -*/ - -#ifndef __LIBM_SUPPORT_H_INCLUDED__ -#define __LIBM_SUPPORT_H_INCLUDED__ - -#ifndef _LIBC -#if !(defined(_WIN32) || defined(_WIN64)) -# pragma const_seg(".rodata") /* place constant data in text (code) section */ -#endif - -#if defined(__ICC) || defined(__ICL) || defined(__ECC) || defined(__ECL) -# pragma warning( disable : 1682 ) /* #1682: ixplicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) */ -# pragma warning( disable : 1683 ) /* #1683: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) */ -#endif -#endif - -/* macros to form a double value in hex representation (unsigned int type) */ - -#define DOUBLE_HEX(hi,lo) 0x##lo,0x##hi /*LITTLE_ENDIAN*/ - -#include "libm_cpu_defs.h" - -#if !(defined (IA64)) -# include "libm_dll.h" -# include "libm_dispatch.h" -#endif - -#include "libm_error_codes.h" - -struct exceptionf -{ - int type; - char *name; - float arg1, arg2, retval; -}; - -# ifdef __cplusplus -struct __exception -{ - int type; - char *name; - double arg1, arg2, retval; -}; -# else - -# ifndef _LIBC -struct exception -{ - int type; - char *name; - double arg1, arg2, retval; -}; -# endif -# endif - -struct exceptionl -{ - int type; - char *name; - long double arg1, arg2, retval; -}; - -#if (defined (_MS_) && defined (IA64)) -#define MATHERR_F _matherrf -#define MATHERR_D _matherr -#else -#define MATHERR_F matherrf -#define MATHERR_D matherr -#endif - -# ifdef __cplusplus -#define EXC_DECL_D __exception -#else -// exception is a reserved name in C++ -#define EXC_DECL_D exception -#endif - -extern int MATHERR_F(struct exceptionf*); -extern int MATHERR_D(struct EXC_DECL_D*); -extern int matherrl(struct exceptionl*); - -#ifndef _LIBC -// Add code to support _LIB_VERSIONIMF -typedef enum -{ - _IEEE_ = -1, // IEEE-like behavior - _SVID_, // SysV, Rel. 4 behavior - _XOPEN_, // Unix98 - _POSIX_, // Posix - _ISOC_ // ISO C9X -} _LIB_VERSION_TYPE; -#endif - -// This is a run-time variable and may affect -// floating point behavior of the libm functions - -#if !defined( LIBM_BUILD ) -#if defined( _DLL ) -extern _LIB_VERSION_TYPE __declspec(dllimport) _LIB_VERSIONIMF; -#else -extern _LIB_VERSION_TYPE _LIB_VERSIONIMF; -#endif /* _DLL */ -#else -extern int (*pmatherrf)(struct exceptionf*); -extern int (*pmatherr)(struct EXC_DECL_D*); -extern int (*pmatherrl)(struct exceptionl*); -#endif /* LIBM_BUILD */ - -/* memory format definitions (LITTLE_ENDIAN only) */ - -#if !(defined(SIZE_INT_32) || defined(SIZE_INT_64)) -# error "You need to define SIZE_INT_32 or SIZE_INT_64" -#endif - -#if (defined(SIZE_INT_32) && defined(SIZE_INT_64)) -#error multiple integer size definitions; define SIZE_INT_32 or SIZE_INT_64 -#endif - -#if !(defined(SIZE_LONG_32) || defined(SIZE_LONG_64)) -# error "You need to define SIZE_LONG_32 or SIZE_LONG_64" -#endif - -#if (defined(SIZE_LONG_32) && defined(SIZE_LONG_64)) -#error multiple integer size definitions; define SIZE_LONG_32 or SIZE_LONG_64 -#endif - -#if !defined(__USE_EXTERNAL_FPMEMTYP_H__) - -#define BIAS_32 0x007F -#define BIAS_64 0x03FF -#define BIAS_80 0x3FFF - -#define MAXEXP_32 0x00FE -#define MAXEXP_64 0x07FE -#define MAXEXP_80 0x7FFE - -#define EXPINF_32 0x00FF -#define EXPINF_64 0x07FF -#define EXPINF_80 0x7FFF - -struct fp32 { /*// sign:1 exponent:8 significand:23 (implied leading 1)*/ -#if defined(SIZE_INT_32) - unsigned significand:23; - unsigned exponent:8; - unsigned sign:1; -#elif defined(SIZE_INT_64) - unsigned significand:23; - unsigned exponent:8; - unsigned sign:1; -#endif -}; - -struct fp64 { /*/ sign:1 exponent:11 significand:52 (implied leading 1)*/ -#if defined(SIZE_INT_32) - unsigned lo_significand:32; - unsigned hi_significand:20; - unsigned exponent:11; - unsigned sign:1; -#elif defined(SIZE_INT_64) - unsigned significand:52; - unsigned exponent:11; - unsigned sign:1; -#endif -}; - -struct fp80 { /*/ sign:1 exponent:15 significand:64 (NO implied bits) */ -#if defined(SIZE_INT_32) - unsigned lo_significand; - unsigned hi_significand; - unsigned exponent:15; - unsigned sign:1; -#elif defined(SIZE_INT_64) - unsigned significand; - unsigned exponent:15; - unsigned sign:1; -#endif - unsigned pad:16; -#if !(defined(__unix__) && defined(__i386__)) - unsigned padwin:32; -#endif -}; - -#endif /*__USE_EXTERNAL_FPMEMTYP_H__*/ - -#if !(defined(opensource)) -typedef __int32 INT32; -typedef signed __int32 SINT32; -typedef unsigned __int32 UINT32; - -typedef __int64 INT64; -typedef signed __int64 SINT64; -typedef unsigned __int64 UINT64; -#else -typedef int INT32; -typedef signed int SINT32; -typedef unsigned int UINT32; - -typedef long long INT64; -typedef signed long long SINT64; -typedef unsigned long long UINT64; -#endif - -#if (defined(_WIN32) || defined(_WIN64)) /* Windows */ -# define I64CONST(bits) 0x##bits##i64 -# define U64CONST(bits) 0x##bits##ui64 -#elif (defined(__linux__) && defined(_M_IA64)) /* Linux,64 */ -# define I64CONST(bits) 0x##bits##L -# define U64CONST(bits) 0x##bits##uL -#else /* Linux,32 */ -# define I64CONST(bits) 0x##bits##LL -# define U64CONST(bits) 0x##bits##uLL -#endif - -struct ker80 { - union { - long double ldhi; - struct fp80 fphi; - }; - union { - long double ldlo; - struct fp80 fplo; - }; - int ex; -}; - -/* Addition: x+y */ -/* The result is sum rhi+rlo */ -/* Temporary variables: t1 */ -/* All variables are in long double precision */ -/* Correct if no overflow (algorithm by D.Knuth) */ -#define __LIBM_ADDL1_K80( rhi,rlo,x,y, t1 ) \ - rhi = x + y; \ - rlo = rhi - x; \ - t1 = rhi - rlo; \ - rlo = y - rlo; \ - t1 = x - t1; \ - rlo = rlo + t1; - -/* Addition: (xhi+xlo) + (yhi+ylo) */ -/* The result is sum rhi+rlo */ -/* Temporary variables: t1 */ -/* All variables are in long double precision */ -/* Correct if no overflow (algorithm by T.J.Dekker) */ -#define __LIBM_ADDL2_K80( rhi,rlo,xhi,xlo,yhi,ylo, t1 ) \ - rlo = xhi+yhi; \ - if ( VALUE_GT_80(FP80(xhi),FP80(yhi)) ) { \ - t1=xhi-rlo;t1=t1+yhi;t1=t1+ylo;t1=t1+xlo; \ - } else { \ - t1=yhi-rlo;t1=t1+xhi;t1=t1+xlo;t1=t1+ylo; \ - } \ - rhi=rlo+t1; \ - rlo=rlo-rhi;rlo=rlo+t1; - -/* Addition: r=x+y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Temporary variables: t1 */ -/* Correct if x and y belong to interval [2^-8000;2^8000], */ -/* or when one or both of them are zero */ -#if defined(SIZE_INT_32) -#define __LIBM_ADDL_K80(r,x,y, t1) \ - if ( ((y)->ex+(y)->fphi.exponent-134 < \ - (x)->ex+(x)->fphi.exponent) && \ - ((x)->ex+(x)->fphi.exponent < \ - (y)->ex+(y)->fphi.exponent+134) && \ - !SIGNIFICAND_ZERO_80(&((x)->fphi)) && \ - !SIGNIFICAND_ZERO_80(&((y)->fphi)) ) \ - { \ - /* y/2^134 < x < y*2^134, */ \ - /* and x,y are nonzero finite numbers */ \ - if ( (x)->ex != (y)->ex ) { \ - /* adjust x->ex to y->ex */ \ - /* t1 = 2^(x->ex - y->ex) */ \ - FP80(t1)->sign = 0; \ - FP80(t1)->exponent = BIAS_80 + (x)->ex-(y)->ex; \ - /* exponent is correct because */ \ - /* |x->ex - y->ex| = */ \ - /* = | (x->ex + x->fphi.exponent) - */ \ - /* -(y->ex + y->fphi.exponent) + */ \ - /* + y->fphi.exponent - */ \ - /* - x->fphi.exponent | < */ \ - /* < | (x->ex+x->fphi.exponent) - */ \ - /* -(y->ex+y->fphi.exponent) | + */ \ - /* +| y->fphi.exponent - */ \ - /* -x->fphi.exponent | < */ \ - /* < 134 + 16000 */ \ - FP80(t1)->hi_significand = 0x80000000; \ - FP80(t1)->lo_significand = 0x00000000; \ - (x)->ex = (y)->ex; \ - (x)->ldhi *= t1; \ - (x)->ldlo *= t1; \ - } \ - /* r==x+y */ \ - (r)->ex = (y)->ex; \ - __LIBM_ADDL2_K80( (r)->ldhi,(r)->ldlo, \ - (x)->ldhi,(x)->ldlo, (y)->ldhi,(y)->ldlo, t1 ); \ - } else if ( SIGNIFICAND_ZERO_80(&((x)->fphi)) || \ - ((y)->ex+(y)->fphi.exponent-BIAS_80 - 134 >= \ - (x)->ex+(x)->fphi.exponent-BIAS_80) ) \ - { \ - /* |x|<<|y| */ \ - *(r) = *(y); \ - } else { \ - /* |y|<<|x| */ \ - *(r) = *(x); \ - } -#elif defined(SIZE_INT_64) -#define __LIBM_ADDL_K80(r,x,y, t1) \ - if ( ((y)->ex+(y)->fphi.exponent-134 < \ - (x)->ex+(x)->fphi.exponent) && \ - ((x)->ex+(x)->fphi.exponent < \ - (y)->ex+(y)->fphi.exponent+134) && \ - !SIGNIFICAND_ZERO_80(&((x)->fphi)) && \ - !SIGNIFICAND_ZERO_80(&((y)->fphi)) ) \ - { \ - /* y/2^134 < x < y*2^134, */ \ - /* and x,y are nonzero finite numbers */ \ - if ( (x)->ex != (y)->ex ) { \ - /* adjust x->ex to y->ex */ \ - /* t1 = 2^(x->ex - y->ex) */ \ - FP80(t1)->sign = 0; \ - FP80(t1)->exponent = BIAS_80 + (x)->ex-(y)->ex; \ - /* exponent is correct because */ \ - /* |x->ex - y->ex| = */ \ - /* = | (x->ex + x->fphi.exponent) - */ \ - /* -(y->ex + y->fphi.exponent) + */ \ - /* + y->fphi.exponent - */ \ - /* - x->fphi.exponent | < */ \ - /* < | (x->ex+x->fphi.exponent) - */ \ - /* -(y->ex+y->fphi.exponent) | + */ \ - /* +| y->fphi.exponent - */ \ - /* -x->fphi.exponent | < */ \ - /* < 134 + 16000 */ \ - FP80(t1)->significand = 0x8000000000000000; \ - (x)->ex = (y)->ex; \ - (x)->ldhi *= t1; \ - (x)->ldlo *= t1; \ - } \ - /* r==x+y */ \ - (r)->ex = (y)->ex; \ - __LIBM_ADDL2_K80( (r)->ldhi,(r)->ldlo, \ - (x)->ldhi,(x)->ldlo, (y)->ldhi,(y)->ldlo, t1 ); \ - } else if ( SIGNIFICAND_ZERO_80(&((x)->fphi)) || \ - ((y)->ex+(y)->fphi.exponent-BIAS_80 - 134 >= \ - (x)->ex+(x)->fphi.exponent-BIAS_80) ) \ - { \ - /* |x|<<|y| */ \ - *(r) = *(y); \ - } else { \ - /* |y|<<|x| */ \ - *(r) = *(x); \ - } -#endif - -/* Addition: r=x+y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Temporary variables: t1 */ -/* Correct for any finite x and y */ -#define __LIBM_ADDL_NORM_K80(r,x,y, t1) \ - if ( ((x)->fphi.exponent-BIAS_80<-8000) || \ - ((x)->fphi.exponent-BIAS_80>+8000) || \ - ((y)->fphi.exponent-BIAS_80<-8000) || \ - ((y)->fphi.exponent-BIAS_80>+8000) ) \ - { \ - __libm_normalizel_k80(x); \ - __libm_normalizel_k80(y); \ - } \ - __LIBM_ADDL_K80(r,x,y, t1) - -/* Subtraction: x-y */ -/* The result is sum rhi+rlo */ -/* Temporary variables: t1 */ -/* All variables are in long double precision */ -/* Correct if no overflow (algorithm by D.Knuth) */ -#define __LIBM_SUBL1_K80( rhi, rlo, x, y, t1 ) \ - rhi = x - y; \ - rlo = rhi - x; \ - t1 = rhi - rlo; \ - rlo = y + rlo; \ - t1 = x - t1; \ - rlo = t1 - rlo; - -/* Subtraction: (xhi+xlo) - (yhi+ylo) */ -/* The result is sum rhi+rlo */ -/* Temporary variables: t1 */ -/* All variables are in long double precision */ -/* Correct if no overflow (algorithm by T.J.Dekker) */ -#define __LIBM_SUBL2_K80( rhi,rlo,xhi,xlo,yhi,ylo, t1 ) \ - rlo = xhi-yhi; \ - if ( VALUE_GT_80(FP80(xhi),FP80(yhi)) ) { \ - t1=xhi-rlo;t1=t1-yhi;t1=t1-ylo;t1=t1+xlo; \ - } else { \ - t1=yhi+rlo;t1=xhi-t1;t1=t1+xlo;t1=t1-ylo; \ - } \ - rhi=rlo+t1; \ - rlo=rlo-rhi;rlo=rlo+t1; - -/* Subtraction: r=x-y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Temporary variables: t1 */ -/* Correct if x and y belong to interval [2^-8000;2^8000], */ -/* or when one or both of them are zero */ -#if defined(SIZE_INT_32) -#define __LIBM_SUBL_K80(r,x,y, t1) \ - if ( ((y)->ex+(y)->fphi.exponent-134 < \ - (x)->ex+(x)->fphi.exponent) && \ - ((x)->ex+(x)->fphi.exponent < \ - (y)->ex+(y)->fphi.exponent+134) && \ - !SIGNIFICAND_ZERO_80(&((x)->fphi)) && \ - !SIGNIFICAND_ZERO_80(&((y)->fphi)) ) \ - { \ - /* y/2^134 < x < y*2^134, */ \ - /* and x,y are nonzero finite numbers */ \ - if ( (x)->ex != (y)->ex ) { \ - /* adjust x->ex to y->ex */ \ - /* t1 = 2^(x->ex - y->ex) */ \ - FP80(t1)->sign = 0; \ - FP80(t1)->exponent = BIAS_80 + (x)->ex-(y)->ex; \ - /* exponent is correct because */ \ - /* |x->ex - y->ex| = */ \ - /* = | (x->ex + x->fphi.exponent) - */ \ - /* -(y->ex + y->fphi.exponent) + */ \ - /* + y->fphi.exponent - */ \ - /* - x->fphi.exponent | < */ \ - /* < | (x->ex+x->fphi.exponent) - */ \ - /* -(y->ex+y->fphi.exponent) | + */ \ - /* +| y->fphi.exponent - */ \ - /* -x->fphi.exponent | < */ \ - /* < 134 + 16000 */ \ - FP80(t1)->hi_significand = 0x80000000; \ - FP80(t1)->lo_significand = 0x00000000; \ - (x)->ex = (y)->ex; \ - (x)->ldhi *= t1; \ - (x)->ldlo *= t1; \ - } \ - /* r==x+y */ \ - (r)->ex = (y)->ex; \ - __LIBM_SUBL2_K80( (r)->ldhi,(r)->ldlo, \ - (x)->ldhi,(x)->ldlo, (y)->ldhi,(y)->ldlo, t1 ); \ - } else if ( SIGNIFICAND_ZERO_80(&((x)->fphi)) || \ - ((y)->ex+(y)->fphi.exponent-BIAS_80 - 134 >= \ - (x)->ex+(x)->fphi.exponent-BIAS_80) ) \ - { \ - /* |x|<<|y| */ \ - (r)->ex = (y)->ex; \ - (r)->ldhi = -((y)->ldhi); \ - (r)->ldlo = -((y)->ldlo); \ - } else { \ - /* |y|<<|x| */ \ - *(r) = *(x); \ - } -#elif defined(SIZE_INT_64) -#define __LIBM_SUBL_K80(r,x,y, t1) \ - if ( ((y)->ex+(y)->fphi.exponent-134 < \ - (x)->ex+(x)->fphi.exponent) && \ - ((x)->ex+(x)->fphi.exponent < \ - (y)->ex+(y)->fphi.exponent+134) && \ - !SIGNIFICAND_ZERO_80(&((x)->fphi)) && \ - !SIGNIFICAND_ZERO_80(&((y)->fphi)) ) \ - { \ - /* y/2^134 < x < y*2^134, */ \ - /* and x,y are nonzero finite numbers */ \ - if ( (x)->ex != (y)->ex ) { \ - /* adjust x->ex to y->ex */ \ - /* t1 = 2^(x->ex - y->ex) */ \ - FP80(t1)->sign = 0; \ - FP80(t1)->exponent = BIAS_80 + (x)->ex-(y)->ex; \ - /* exponent is correct because */ \ - /* |x->ex - y->ex| = */ \ - /* = | (x->ex + x->fphi.exponent) - */ \ - /* -(y->ex + y->fphi.exponent) + */ \ - /* + y->fphi.exponent - */ \ - /* - x->fphi.exponent | < */ \ - /* < | (x->ex+x->fphi.exponent) - */ \ - /* -(y->ex+y->fphi.exponent) | + */ \ - /* +| y->fphi.exponent - */ \ - /* -x->fphi.exponent | < */ \ - /* < 134 + 16000 */ \ - FP80(t1)->significand = 0x8000000000000000; \ - (x)->ex = (y)->ex; \ - (x)->ldhi *= t1; \ - (x)->ldlo *= t1; \ - } \ - /* r==x+y */ \ - (r)->ex = (y)->ex; \ - __LIBM_SUBL2_K80( (r)->ldhi,(r)->ldlo, \ - (x)->ldhi,(x)->ldlo, (y)->ldhi,(y)->ldlo, t1 ); \ - } else if ( SIGNIFICAND_ZERO_80(&((x)->fphi)) || \ - ((y)->ex+(y)->fphi.exponent-BIAS_80 - 134 >= \ - (x)->ex+(x)->fphi.exponent-BIAS_80) ) \ - { \ - /* |x|<<|y| */ \ - (r)->ex = (y)->ex; \ - (r)->ldhi = -((y)->ldhi); \ - (r)->ldlo = -((y)->ldlo); \ - } else { \ - /* |y|<<|x| */ \ - *(r) = *(x); \ - } -#endif - -/* Subtraction: r=x+y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Temporary variables: t1 */ -/* Correct for any finite x and y */ -#define __LIBM_SUBL_NORM_K80(r,x,y, t1) \ - if ( ((x)->fphi.exponent-BIAS_80<-8000) || \ - ((x)->fphi.exponent-BIAS_80>+8000) || \ - ((y)->fphi.exponent-BIAS_80<-8000) || \ - ((y)->fphi.exponent-BIAS_80>+8000) ) \ - { \ - __libm_normalizel_k80(x); \ - __libm_normalizel_k80(y); \ - } \ - __LIBM_SUBL_K80(r,x,y, t1) - -/* Multiplication: x*y */ -/* The result is sum rhi+rlo */ -/* Here t32 is the constant 2^32+1 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6 */ -/* All variables are in long double precision */ -/* Correct if no over/underflow (algorithm by T.J.Dekker) */ -#define __LIBM_MULL1_K80(rhi,rlo,x,y, \ - t32,t1,t2,t3,t4,t5,t6) \ - t1=(x)*(t32); t3=x-t1; t3=t3+t1; t4=x-t3; \ - t1=(y)*(t32); t5=y-t1; t5=t5+t1; t6=y-t5; \ - t1=(t3)*(t5); \ - t2=(t3)*(t6)+(t4)*(t5); \ - rhi=t1+t2; \ - rlo=t1-rhi; rlo=rlo+t2; rlo=rlo+(t4*t6); - -/* Multiplication: (xhi+xlo)*(yhi+ylo) */ -/* The result is sum rhi+rlo */ -/* Here t32 is the constant 2^32+1 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8 */ -/* All variables are in long double precision */ -/* Correct if no over/underflow (algorithm by T.J.Dekker) */ -#define __LIBM_MULL2_K80(rhi,rlo,xhi,xlo,yhi,ylo, \ - t32,t1,t2,t3,t4,t5,t6,t7,t8) \ - __LIBM_MULL1_K80(t7,t8,xhi,yhi, t32,t1,t2,t3,t4,t5,t6) \ - t1=(xhi)*(ylo)+(xlo)*(yhi); t1=t1+t8; \ - rhi=t7+t1; \ - rlo=t7-rhi; rlo=rlo+t1; - -/* Multiplication: r=x*y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Here t32 is the constant 2^32+1 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8 */ -/* Correct if x and y belong to interval [2^-8000;2^8000] */ -#define __LIBM_MULL_K80(r,x,y, t32,t1,t2,t3,t4,t5,t6,t7,t8) \ - (r)->ex = (x)->ex + (y)->ex; \ - __LIBM_MULL2_K80((r)->ldhi,(r)->ldlo, \ - (x)->ldhi,(x)->ldlo,(y)->ldhi,(y)->ldlo, \ - t32,t1,t2,t3,t4,t5,t6,t7,t8) - -/* Multiplication: r=x*y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Here t32 is the constant 2^32+1 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8 */ -/* Correct for any finite x and y */ -#define __LIBM_MULL_NORM_K80(r,x,y, \ - t32,t1,t2,t3,t4,t5,t6,t7,t8) \ - if ( ((x)->fphi.exponent-BIAS_80<-8000) || \ - ((x)->fphi.exponent-BIAS_80>+8000) || \ - ((y)->fphi.exponent-BIAS_80<-8000) || \ - ((y)->fphi.exponent-BIAS_80>+8000) ) \ - { \ - __libm_normalizel_k80(x); \ - __libm_normalizel_k80(y); \ - } \ - __LIBM_MULL_K80(r,x,y, t32,t1,t2,t3,t4,t5,t6,t7,t8) - -/* Division: (xhi+xlo)/(yhi+ylo) */ -/* The result is sum rhi+rlo */ -/* Here t32 is the constant 2^32+1 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8,t9 */ -/* All variables are in long double precision */ -/* Correct if no over/underflow (algorithm by T.J.Dekker) */ -#define __LIBM_DIVL2_K80(rhi,rlo,xhi,xlo,yhi,ylo, \ - t32,t1,t2,t3,t4,t5,t6,t7,t8,t9) \ - t7=(xhi)/(yhi); \ - __LIBM_MULL1_K80(t8,t9,t7,yhi, t32,t1,t2,t3,t4,t5,t6) \ - t1=xhi-t8; t1=t1-t9; t1=t1+xlo; t1=t1-(t7)*(ylo); \ - t1=(t1)/(yhi); \ - rhi=t7+t1; \ - rlo=t7-rhi; rlo=rlo+t1; - -/* Division: r=x/y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Here t32 is the constant 2^32+1 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8,t9 */ -/* Correct if x and y belong to interval [2^-8000;2^8000] */ -#define __LIBM_DIVL_K80(r,x,y, \ - t32,t1,t2,t3,t4,t5,t6,t7,t8,t9) \ - (r)->ex = (x)->ex - (y)->ex; \ - __LIBM_DIVL2_K80( (r)->ldhi,(r)->ldlo, \ - (x)->ldhi,(x)->ldlo,(y)->ldhi,(y)->ldlo, \ - t32,t1,t2,t3,t4,t5,t6,t7,t8,t9) - -/* Division: r=x/y */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Here t32 is the constant 2^32+1 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8 */ -/* Correct for any finite x and y */ -#define __LIBM_DIVL_NORM_K80(r,x,y, \ - t32,t1,t2,t3,t4,t5,t6,t7,t8,t9) \ - if ( ((x)->fphi.exponent-BIAS_80<-8000) || \ - ((x)->fphi.exponent-BIAS_80>+8000) || \ - ((y)->fphi.exponent-BIAS_80<-8000) || \ - ((y)->fphi.exponent-BIAS_80>+8000) ) \ - { \ - __libm_normalizel_k80(x); \ - __libm_normalizel_k80(y); \ - } \ - __LIBM_DIVL_K80(r,x,y, t32,t1,t2,t3,t4,t5,t6,t7,t8,t9) - -/* Square root: sqrt(xhi+xlo) */ -/* The result is sum rhi+rlo */ -/* Here t32 is the constant 2^32+1 */ -/* half is the constant 0.5 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8,t9 */ -/* All variables are in long double precision */ -/* Correct for positive xhi+xlo (algorithm by T.J.Dekker) */ -#define __LIBM_SQRTL2_NORM_K80(rhi,rlo,xhi,xlo, \ - t32,half,t1,t2,t3,t4,t5,t6,t7,t8,t9) \ - t7=sqrtl(xhi); \ - __LIBM_MULL1_K80(t8,t9,t7,t7, t32,t1,t2,t3,t4,t5,t6) \ - t1=xhi-t8; t1=t1-t9; t1=t1+xlo; t1=(t1)*(half); \ - t1=(t1)/(t7); \ - rhi=t7+t1; \ - rlo=t7-rhi; rlo=rlo+t1; - -/* Square root: r=sqrt(x) */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Here t32 is the constant 2^32+1 */ -/* half is the constant 0.5 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8,t9 */ -/* Correct if x belongs to interval [2^-16000;2^16000] */ -#define __LIBM_SQRTL_K80(r,x, \ - t32,half,t1,t2,t3,t4,t5,t6,t7,t8,t9) \ - if ( ((x)->ex & 1) == 1 ) { \ - (x)->ex = (x)->ex + 1; \ - (x)->ldhi *= half; \ - (x)->ldlo *= half; \ - } \ - (r)->ex = (x)->ex >> 1; \ - __LIBM_SQRTL2_NORM_K80( (r)->ldhi,(r)->ldlo, \ - (x)->ldhi,(x)->ldlo, \ - t32,half,t1,t2,t3,t4,t5,t6,t7,t8,t9) - -/* Square root: r=sqrt(x) */ -/* Variables r,x,y are pointers to struct ker80, */ -/* all other variables are in long double precision */ -/* Here t32 is the constant 2^32+1 */ -/* half is the constant 0.5 */ -/* Temporary variables: t1,t2,t3,t4,t5,t6,t7,t8,t9 */ -/* Correct for any positive x */ -#define __LIBM_SQRTL_NORM_K80(r,x, \ - t32,half,t1,t2,t3,t4,t5,t6,t7,t8,t9) \ - if ( ((x)->fphi.exponent-BIAS_80<-16000) || \ - ((x)->fphi.exponent-BIAS_80>+16000) ) \ - { \ - __libm_normalizel_k80(x); \ - } \ - __LIBM_SQRTL_K80(r,x, t32,half,t1,t2,t3,t4,t5,t6,t7,t8,t9) - - -#ifdef __INTEL_COMPILER -#define ALIGN(n) __declspec(align(n)) -#else /* __INTEL_COMPILER */ -#define ALIGN(n) -#endif /* __INTEL_COMPILER */ - -/* macros to form a long double value in hex representation (unsigned short type) */ - -#if (defined(__unix__) && defined(__i386__)) -# define LDOUBLE_ALIGN 12 /* IA32 Linux: 12-byte alignment */ -#else /*__linux__ & IA32*/ -# define LDOUBLE_ALIGN 16 /* EFI2/IA32 Win or IPF Win/Linux: 16-byte alignment */ -#endif /*__linux__ & IA32*/ - -#if (LDOUBLE_ALIGN == 16) -#define _XPD_ ,0x0000,0x0000,0x0000 -#else /*12*/ -#define _XPD_ ,0x0000 -#endif - -#define LDOUBLE_HEX(w4,w3,w2,w1,w0) 0x##w0,0x##w1,0x##w2,0x##w3,0x##w4 _XPD_ /*LITTLE_ENDIAN*/ - -/* macros to sign-expand low 'num' bits of 'val' to native integer */ - -#if defined(SIZE_INT_32) -# define SIGN_EXPAND(val,num) ((int)(val) << (32-(num))) >> (32-(num)) /* sign expand of 'num' LSBs */ -#elif defined(SIZE_INT_64) -# define SIGN_EXPAND(val,num) ((int)(val) << (64-(num))) >> (64-(num)) /* sign expand of 'num' LSBs */ -#endif - -/* macros to form pointers to FP number on-the-fly */ - -#define FP32(f) ((struct fp32 *)&f) -#define FP64(d) ((struct fp64 *)&d) -#define FP80(ld) ((struct fp80 *)&ld) - -/* macros to extract signed low and high doubleword of long double */ - -#if defined(SIZE_INT_32) -# define HI_DWORD_80(ld) ((((FP80(ld)->sign << 15) | FP80(ld)->exponent) << 16) | \ - ((FP80(ld)->hi_significand >> 16) & 0xFFFF)) -# define LO_DWORD_80(ld) SIGN_EXPAND(FP80(ld)->lo_significand, 32) -#elif defined(SIZE_INT_64) -# define HI_DWORD_80(ld) ((((FP80(ld)->sign << 15) | FP80(ld)->exponent) << 16) | \ - ((FP80(ld)->significand >> 48) & 0xFFFF)) -# define LO_DWORD_80(ld) SIGN_EXPAND(FP80(ld)->significand, 32) -#endif - -/* macros to extract hi bits of significand. - * note that explicit high bit do not count (returns as is) - */ - -#if defined(SIZE_INT_32) -# define HI_SIGNIFICAND_80(X,NBITS) ((X)->hi_significand >> (31 - (NBITS))) -#elif defined(SIZE_INT_64) -# define HI_SIGNIFICAND_80(X,NBITS) ((X)->significand >> (63 - (NBITS))) -#endif - -/* macros to check, whether a significand bits are all zero, or some of them are non-zero. - * note that SIGNIFICAND_ZERO_80 tests high bit also, but SIGNIFICAND_NONZERO_80 does not - */ - -#define SIGNIFICAND_ZERO_32(X) ((X)->significand == 0) -#define SIGNIFICAND_NONZERO_32(X) ((X)->significand != 0) - -#if defined(SIZE_INT_32) -# define SIGNIFICAND_ZERO_64(X) (((X)->hi_significand == 0) && ((X)->lo_significand == 0)) -# define SIGNIFICAND_NONZERO_64(X) (((X)->hi_significand != 0) || ((X)->lo_significand != 0)) -#elif defined(SIZE_INT_64) -# define SIGNIFICAND_ZERO_64(X) ((X)->significand == 0) -# define SIGNIFICAND_NONZERO_64(X) ((X)->significand != 0) -#endif - -#if defined(SIZE_INT_32) -# define SIGNIFICAND_ZERO_80(X) (((X)->hi_significand == 0x00000000) && ((X)->lo_significand == 0)) -# define SIGNIFICAND_NONZERO_80(X) (((X)->hi_significand != 0x80000000) || ((X)->lo_significand != 0)) -#elif defined(SIZE_INT_64) -# define SIGNIFICAND_ZERO_80(X) ((X)->significand == 0x0000000000000000) -# define SIGNIFICAND_NONZERO_80(X) ((X)->significand != 0x8000000000000000) -#endif - -/* macros to compare long double with constant value, represented as hex */ - -#define SIGNIFICAND_EQ_HEX_32(X,BITS) ((X)->significand == 0x ## BITS) -#define SIGNIFICAND_GT_HEX_32(X,BITS) ((X)->significand > 0x ## BITS) -#define SIGNIFICAND_GE_HEX_32(X,BITS) ((X)->significand >= 0x ## BITS) -#define SIGNIFICAND_LT_HEX_32(X,BITS) ((X)->significand < 0x ## BITS) -#define SIGNIFICAND_LE_HEX_32(X,BITS) ((X)->significand <= 0x ## BITS) - -#if defined(SIZE_INT_32) -# define SIGNIFICAND_EQ_HEX_64(X,HI,LO) \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand == 0x ## LO)) -# define SIGNIFICAND_GT_HEX_64(X,HI,LO) (((X)->hi_significand > 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand > 0x ## LO))) -# define SIGNIFICAND_GE_HEX_64(X,HI,LO) (((X)->hi_significand > 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand >= 0x ## LO))) -# define SIGNIFICAND_LT_HEX_64(X,HI,LO) (((X)->hi_significand < 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand < 0x ## LO))) -# define SIGNIFICAND_LE_HEX_64(X,HI,LO) (((X)->hi_significand < 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand <= 0x ## LO))) -#elif defined(SIZE_INT_64) -# define SIGNIFICAND_EQ_HEX_64(X,HI,LO) ((X)->significand == 0x ## HI ## LO) -# define SIGNIFICAND_GT_HEX_64(X,HI,LO) ((X)->significand > 0x ## HI ## LO) -# define SIGNIFICAND_GE_HEX_64(X,HI,LO) ((X)->significand >= 0x ## HI ## LO) -# define SIGNIFICAND_LT_HEX_64(X,HI,LO) ((X)->significand < 0x ## HI ## LO) -# define SIGNIFICAND_LE_HEX_64(X,HI,LO) ((X)->significand <= 0x ## HI ## LO) -#endif - -#if defined(SIZE_INT_32) -# define SIGNIFICAND_EQ_HEX_80(X,HI,LO) \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand == 0x ## LO)) -# define SIGNIFICAND_GT_HEX_80(X,HI,LO) (((X)->hi_significand > 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand > 0x ## LO))) -# define SIGNIFICAND_GE_HEX_80(X,HI,LO) (((X)->hi_significand > 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand >= 0x ## LO))) -# define SIGNIFICAND_LT_HEX_80(X,HI,LO) (((X)->hi_significand < 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand < 0x ## LO))) -# define SIGNIFICAND_LE_HEX_80(X,HI,LO) (((X)->hi_significand < 0x ## HI) || \ - (((X)->hi_significand == 0x ## HI) && ((X)->lo_significand <= 0x ## LO))) -#elif defined(SIZE_INT_64) -# define SIGNIFICAND_EQ_HEX_80(X,HI,LO) ((X)->significand == 0x ## HI ## LO) -# define SIGNIFICAND_GT_HEX_80(X,HI,LO) ((X)->significand > 0x ## HI ## LO) -# define SIGNIFICAND_GE_HEX_80(X,HI,LO) ((X)->significand >= 0x ## HI ## LO) -# define SIGNIFICAND_LT_HEX_80(X,HI,LO) ((X)->significand < 0x ## HI ## LO) -# define SIGNIFICAND_LE_HEX_80(X,HI,LO) ((X)->significand <= 0x ## HI ## LO) -#endif - -#define VALUE_EQ_HEX_32(X,EXP,BITS) \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_EQ_HEX_32(X, BITS))) -#define VALUE_GT_HEX_32(X,EXP,BITS) (((X)->exponent > (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_GT_HEX_32(X, BITS)))) -#define VALUE_GE_HEX_32(X,EXP,BITS) (((X)->exponent > (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_GE_HEX_32(X, BITS)))) -#define VALUE_LT_HEX_32(X,EXP,BITS) (((X)->exponent < (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_LT_HEX_32(X, BITS)))) -#define VALUE_LE_HEX_32(X,EXP,BITS) (((X)->exponent < (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_LE_HEX_32(X, BITS)))) - -#define VALUE_EQ_HEX_64(X,EXP,HI,LO) \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_EQ_HEX_64(X, HI, LO))) -#define VALUE_GT_HEX_64(X,EXP,HI,LO) (((X)->exponent > (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_GT_HEX_64(X, HI, LO)))) -#define VALUE_GE_HEX_64(X,EXP,HI,LO) (((X)->exponent > (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_GE_HEX_64(X, HI, LO)))) -#define VALUE_LT_HEX_64(X,EXP,HI,LO) (((X)->exponent < (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_LT_HEX_64(X, HI, LO)))) -#define VALUE_LE_HEX_64(X,EXP,HI,LO) (((X)->exponent < (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_LE_HEX_64(X, HI, LO)))) - -#define VALUE_EQ_HEX_80(X,EXP,HI,LO) \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_EQ_HEX_80(X, HI, LO))) -#define VALUE_GT_HEX_80(X,EXP,HI,LO) (((X)->exponent > (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_GT_HEX_80(X, HI, LO)))) -#define VALUE_GE_HEX_80(X,EXP,HI,LO) (((X)->exponent > (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_GE_HEX_80(X, HI, LO)))) -#define VALUE_LT_HEX_80(X,EXP,HI,LO) (((X)->exponent < (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_LT_HEX_80(X, HI, LO)))) -#define VALUE_LE_HEX_80(X,EXP,HI,LO) (((X)->exponent < (EXP)) || \ - (((X)->exponent == (EXP)) && (SIGNIFICAND_LE_HEX_80(X, HI, LO)))) - -/* macros to compare two long doubles */ - -#define SIGNIFICAND_EQ_32(X,Y) ((X)->significand == (Y)->significand) -#define SIGNIFICAND_GT_32(X,Y) ((X)->significand > (Y)->significand) -#define SIGNIFICAND_GE_32(X,Y) ((X)->significand >= (Y)->significand) -#define SIGNIFICAND_LT_32(X,Y) ((X)->significand < (Y)->significand) -#define SIGNIFICAND_LE_32(X,Y) ((X)->significand <= (Y)->significand) - -#if defined(SIZE_INT_32) -# define SIGNIFICAND_EQ_64(X,Y) \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand == (Y)->lo_significand)) -# define SIGNIFICAND_GT_64(X,Y) (((X)->hi_significand > (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand > (Y)->lo_significand))) -# define SIGNIFICAND_GE_64(X,Y) (((X)->hi_significand > (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand >= (Y)->lo_significand))) -# define SIGNIFICAND_LT_64(X,Y) (((X)->hi_significand < (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand < (Y)->lo_significand))) -# define SIGNIFICAND_LE_64(X,Y) (((X)->hi_significand < (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand <= (Y)->lo_significand))) -#elif defined(SIZE_INT_64) -# define SIGNIFICAND_EQ_64(X,Y) ((X)->significand == (Y)->significand) -# define SIGNIFICAND_GT_64(X,Y) ((X)->significand > (Y)->significand) -# define SIGNIFICAND_GE_64(X,Y) ((X)->significand >= (Y)->significand) -# define SIGNIFICAND_LT_64(X,Y) ((X)->significand < (Y)->significand) -# define SIGNIFICAND_LE_64(X,Y) ((X)->significand <= (Y)->significand) -#endif - -#if defined(SIZE_INT_32) -# define SIGNIFICAND_EQ_80(X,Y) \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand == (Y)->lo_significand)) -# define SIGNIFICAND_GT_80(X,Y) (((X)->hi_significand > (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand > (Y)->lo_significand))) -# define SIGNIFICAND_GE_80(X,Y) (((X)->hi_significand > (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand >= (Y)->lo_significand))) -# define SIGNIFICAND_LT_80(X,Y) (((X)->hi_significand < (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand < (Y)->lo_significand))) -# define SIGNIFICAND_LE_80(X,Y) (((X)->hi_significand < (Y)->hi_significand) || \ - (((X)->hi_significand == (Y)->hi_significand) && ((X)->lo_significand <= (Y)->lo_significand))) -#elif defined(SIZE_INT_64) -# define SIGNIFICAND_EQ_80(X,Y) ((X)->significand == (Y)->significand) -# define SIGNIFICAND_GT_80(X,Y) ((X)->significand > (Y)->significand) -# define SIGNIFICAND_GE_80(X,Y) ((X)->significand >= (Y)->significand) -# define SIGNIFICAND_LT_80(X,Y) ((X)->significand < (Y)->significand) -# define SIGNIFICAND_LE_80(X,Y) ((X)->significand <= (Y)->significand) -#endif - -#define VALUE_EQ_32(X,Y) \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_EQ_32(X, Y))) -#define VALUE_GT_32(X,Y) (((X)->exponent > (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_GT_32(X, Y)))) -#define VALUE_GE_32(X,Y) (((X)->exponent > (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_GE_32(X, Y)))) -#define VALUE_LT_32(X,Y) (((X)->exponent < (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_LT_32(X, Y)))) -#define VALUE_LE_32(X,Y) (((X)->exponent < (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_LE_32(X, Y)))) - -#define VALUE_EQ_64(X,Y) \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_EQ_64(X, Y))) -#define VALUE_GT_64(X,Y) (((X)->exponent > (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_GT_64(X, Y)))) -#define VALUE_GE_64(X,Y) (((X)->exponent > (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_GE_64(X, Y)))) -#define VALUE_LT_64(X,Y) (((X)->exponent < (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_LT_64(X, Y)))) -#define VALUE_LE_64(X,Y) (((X)->exponent < (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_LE_64(X, Y)))) - -#define VALUE_EQ_80(X,Y) \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_EQ_80(X, Y))) -#define VALUE_GT_80(X,Y) (((X)->exponent > (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_GT_80(X, Y)))) -#define VALUE_GE_80(X,Y) (((X)->exponent > (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_GE_80(X, Y)))) -#define VALUE_LT_80(X,Y) (((X)->exponent < (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_LT_80(X, Y)))) -#define VALUE_LE_80(X,Y) (((X)->exponent < (Y)->exponent) || \ - (((X)->exponent == (Y)->exponent) && (SIGNIFICAND_LE_80(X, Y)))) - -/* add/subtract 1 ulp macros */ - -#if defined(SIZE_INT_32) -# define ADD_ULP_80(X) \ - if ((++(X)->lo_significand == 0) && \ - (++(X)->hi_significand == (((X)->exponent == 0) ? 0x80000000 : 0))) \ - { \ - (X)->hi_significand |= 0x80000000; \ - ++(X)->exponent; \ - } -# define SUB_ULP_80(X) \ - if (--(X)->lo_significand == 0xFFFFFFFF) { \ - --(X)->hi_significand; \ - if (((X)->exponent != 0) && \ - ((X)->hi_significand == 0x7FFFFFFF) && \ - (--(X)->exponent != 0)) \ - { \ - (X)->hi_significand |= 0x80000000; \ - } \ - } -#elif defined(SIZE_INT_64) -# define ADD_ULP_80(X) \ - if (++(X)->significand == (((X)->exponent == 0) ? 0x8000000000000000 : 0))) { \ - (X)->significand |= 0x8000000000000000; \ - ++(X)->exponent; \ - } -# define SUB_ULP_80(X) \ - { \ - --(X)->significand; \ - if (((X)->exponent != 0) && \ - ((X)->significand == 0x7FFFFFFFFFFFFFFF) && \ - (--(X)->exponent != 0)) \ - { \ - (X)->significand |= 0x8000000000000000; \ - } \ - } -#endif - - -/* error codes */ - -#define DOMAIN 1 /* argument domain error */ -#define SING 2 /* argument singularity */ -#define OVERFLOW 3 /* overflow range error */ -#define UNDERFLOW 4 /* underflow range error */ -#define TLOSS 5 /* total loss of precision */ -#define PLOSS 6 /* partial loss of precision */ - -/* */ - -#define VOLATILE_32 /*volatile*/ -#define VOLATILE_64 /*volatile*/ -#define VOLATILE_80 /*volatile*/ - -#define QUAD_TYPE _Quad - -#endif /*__LIBM_SUPPORT_H_INCLUDED__*/ |