about summary refs log tree commit diff
path: root/sysdeps/ia64/fpu/libm_support.h
diff options
context:
space:
mode:
Diffstat (limited to 'sysdeps/ia64/fpu/libm_support.h')
-rw-r--r--sysdeps/ia64/fpu/libm_support.h570
1 files changed, 481 insertions, 89 deletions
diff --git a/sysdeps/ia64/fpu/libm_support.h b/sysdeps/ia64/fpu/libm_support.h
index 5d3498dfc9..50dac33133 100644
--- a/sysdeps/ia64/fpu/libm_support.h
+++ b/sysdeps/ia64/fpu/libm_support.h
@@ -1,9 +1,10 @@
-//
-// Copyright (C) 2000, 2001, Intel Corporation
+/* file: libm_support.h */
+
+
+// Copyright (c) 2000 - 2002, Intel Corporation
 // All rights reserved.
 //
-// Contributed 2/2/2000 by John Harrison, Ted Kubaska, Bob Norin, Shane Story,
-// and Ping Tak Peter Tang of the Computational Software Lab, Intel Corporation.
+// 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
@@ -19,14 +20,14 @@
 // * 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
+// "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
+// 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
+// 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
@@ -34,45 +35,51 @@
 //
 // Intel Corporation is the author of this code, and requests that all
 // problem reports or change requests be submitted to it directly at
-// http://developer.intel.com/opensource.
+// http://www.intel.com/software/products/opensource/libraries/num.htm.
 //
 
-// History: 02/02/2000 Initial version
+// History: 02/02/2000 Initial version 
 //          2/28/2000 added tags for logb and nextafter
-//          3/22/2000 Changes to support _LIB_VERSION variable
-//                    and filled some enum gaps. Added support for C99.
+//          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_VERSION to work for library
+//          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
 //
 
-#ifndef __ASSEMBLER__
-#include <math.h>
-
-float __libm_frexp_4f( float x, int*  exp);
-float _GI___libm_frexp_4f( float x, int*  exp);
-float __libm_frexp_8f( float x, int*  exp);
-double __libm_frexp_4( double x, int*  exp);
-double _GI___libm_frexp_4( double x, int*  exp);
-double __libm_frexp_8( double x, int*  exp);
-long double __libm_frexp_4l( long double x, int*  exp);
-long double _GI___libm_frexp_4l( long double x, int*  exp);
-long double __libm_frexp_8l( long double x, int*  exp);
 void __libm_sincos_pi4(double,double*,double*,int);
 void __libm_y0y1(double , double *, double *);
 void __libm_j0j1(double , double *, double *);
-double __libm_lgamma_kernel(double,int*,int,int);
 double __libm_j0(double);
 double __libm_j1(double);
 double __libm_jn(int,double);
 double __libm_y0(double);
 double __libm_y1(double);
 double __libm_yn(int,double);
+double __libm_copysign (double, double);
+float __libm_copysignf (float, float);
+long double __libm_copysignl (long double, long double);
 
-extern double rint(double);
 extern double sqrt(double);
 extern double fabs(double);
 extern double log(double);
@@ -112,24 +119,31 @@ extern long double log1pl(long double);
 extern long double logl(long double);
 extern long double sqrtl(long double);
 extern long double expl(long double);
-
-extern long lround(double);
-extern long lroundf(float);
-extern long lroundl(long double);
+extern long double fabsl(long double);
 
 #if !(defined(SIZE_INT_32) || defined(SIZE_INT_64))
-    #error integer size not established; define SIZE_INT_32 or SIZE_INT_64
+#error integer size not established; define SIZE_INT_32 or SIZE_INT_64
 #endif
 
-struct fp64 { /*/ sign:1 exponent:11 significand:52 (implied leading 1)*/
-  unsigned lo_significand:32;
-  unsigned hi_significand:20;
-  unsigned exponent:11;
-  unsigned sign:1;
-};
+#if (defined(SIZE_INT_32) && defined(SIZE_INT_64))
+#error multiple integer size definitions; define SIZE_INT_32 or SIZE_INT_64
+#endif
 
-#define HI_SIGNIFICAND_LESS(X, HI) ((X)->hi_significand < 0x ## HI)
-#define f64abs(x) ((x) < 0.0 ? -(x) : (x))
+#if !(defined(SIZE_LONG_INT_32) || defined(SIZE_LONG_INT_64))
+#error long int size not established; define SIZE_LONG_INT_32 or SIZE_LONG_INT_64
+#endif
+
+#if (defined(SIZE_LONG_INT_32) && defined(SIZE_LONG_INT_64))
+#error multiple long int size definitions; define SIZE_LONG_INT_32 or SIZE_LONG_INT_64
+#endif
+
+#if !(defined(SIZE_LONG_LONG_INT_32) || defined(SIZE_LONG_LONG_INT_64))
+#error long long int size not established; define SIZE_LONG_LONG_INT_32 or SIZE_LONG_LONG_INT_64
+#endif
+
+#if (defined(SIZE_LONG_LONG_INT_32) && defined(SIZE_LONG_LONG_INT_64))
+#error multiple long long int size definitions; define SIZE_LONG_LONG_INT_32 or SIZE_LONG_LONG_INT_64
+#endif
 
 typedef enum
 {
@@ -148,14 +162,14 @@ typedef enum
   powl_neg_to_non_integer,                       /* 22     */
   powl_nan_to_zero,                              /* 23     */
   pow_overflow,  pow_underflow,                  /* 24, 25 */
-  pow_zero_to_zero,                              /* 26     */
+  pow_zero_to_zero,                              /* 26     */ 
   pow_zero_to_negative,                          /* 27     */
   pow_neg_to_non_integer,                        /* 28     */
   pow_nan_to_zero,                               /* 29     */
   powf_overflow, powf_underflow,                 /* 30, 31 */
   powf_zero_to_zero,                             /* 32     */
-  powf_zero_to_negative,                         /* 33     */
-  powf_neg_to_non_integer,                       /* 34     */
+  powf_zero_to_negative,                         /* 33     */ 
+  powf_neg_to_non_integer,                       /* 34     */ 
   powf_nan_to_zero,                              /* 35     */
   atan2l_zero,                                   /* 36     */
   atan2_zero,                                    /* 37     */
@@ -181,13 +195,13 @@ typedef enum
   y0l_zero, y0l_negative,y0l_gt_loss,            /* 66, 67, 68 */
   y0_zero, y0_negative,y0_gt_loss,               /* 69, 70, 71 */
   y0f_zero, y0f_negative,y0f_gt_loss,            /* 72, 73, 74 */
-  y1l_zero, y1l_negative,y1l_gt_loss,            /* 75, 76, 77 */
-  y1_zero, y1_negative,y1_gt_loss,               /* 78, 79, 80 */
-  y1f_zero, y1f_negative,y1f_gt_loss,            /* 81, 82, 83 */
+  y1l_zero, y1l_negative,y1l_gt_loss,            /* 75, 76, 77 */ 
+  y1_zero, y1_negative,y1_gt_loss,               /* 78, 79, 80 */ 
+  y1f_zero, y1f_negative,y1f_gt_loss,            /* 81, 82, 83 */ 
   ynl_zero, ynl_negative,ynl_gt_loss,            /* 84, 85, 86 */
   yn_zero, yn_negative,yn_gt_loss,               /* 87, 88, 89 */
   ynf_zero, ynf_negative,ynf_gt_loss,            /* 90, 91, 92 */
-  j0l_gt_loss,                                   /* 93 */
+  j0l_gt_loss,                                   /* 93 */ 
   j0_gt_loss,                                    /* 94 */
   j0f_gt_loss,                                   /* 95 */
   j1l_gt_loss,                                   /* 96 */
@@ -201,7 +215,7 @@ typedef enum
   lgammaf_overflow, lgammaf_negative, lgammaf_reserve,/* 108, 109, 110 */
   gammal_overflow,gammal_negative, gammal_reserve,    /* 111, 112, 113 */
   gamma_overflow, gamma_negative, gamma_reserve,      /* 114, 115, 116 */
-  gammaf_overflow,gammaf_negative,gammaf_reserve,     /* 117, 118, 119 */
+  gammaf_overflow,gammaf_negative,gammaf_reserve,     /* 117, 118, 119 */   
   fmodl_by_zero,                                 /* 120 */
   fmod_by_zero,                                  /* 121 */
   fmodf_by_zero,                                 /* 122 */
@@ -222,7 +236,7 @@ typedef enum
   ldexp_overflow,    ldexp_underflow,            /* 146, 147 */
   ldexpf_overflow,   ldexpf_underflow,           /* 148, 149 */
   logbl_zero,   logb_zero, logbf_zero,           /* 150, 151, 152 */
-  nextafterl_overflow,   nextafter_overflow,
+  nextafterl_overflow,   nextafter_overflow,  
   nextafterf_overflow,                           /* 153, 154, 155 */
   ilogbl_zero,  ilogb_zero, ilogbf_zero,         /* 156, 157, 158 */
   exp2l_overflow, exp2l_underflow,               /* 159, 160 */
@@ -235,18 +249,406 @@ typedef enum
   log2f_zero,    log2f_negative,                 /* 172, 173 */
   scalbnl_overflow, scalbnl_underflow,           /* 174, 175 */
   scalbn_overflow,  scalbn_underflow,            /* 176, 177 */
-  scalbnf_overflow, scalbnf_underflow            /* 178, 179 */
+  scalbnf_overflow, scalbnf_underflow,           /* 178, 179 */
+  remquol_by_zero,                               /* 180 */
+  remquo_by_zero,                                /* 181 */
+  remquof_by_zero,                               /* 182 */
+  lrintl_large, lrint_large, lrintf_large,       /* 183, 184, 185 */
+  llrintl_large, llrint_large, llrintf_large,    /* 186, 187, 188 */
+  lroundl_large, lround_large, lroundf_large,    /* 189, 190, 191 */
+  llroundl_large, llround_large, llroundf_large, /* 192, 193, 194 */
+  fdiml_overflow, fdim_overflow, fdimf_overflow, /* 195, 196, 197 */
+  nexttowardl_overflow,   nexttoward_overflow,   
+  nexttowardf_overflow,                          /* 198, 199, 200 */
+  scalblnl_overflow, scalblnl_underflow,         /* 201, 202 */
+  scalbln_overflow,  scalbln_underflow,          /* 203, 204 */
+  scalblnf_overflow, scalblnf_underflow,         /* 205, 206 */
+  erfcl_underflow, erfc_underflow, erfcf_underflow, /* 207, 208, 209 */
+  acosdl_gt_one, acosd_gt_one, acosdf_gt_one,    /* 210, 211, 212 */
+  asindl_gt_one, asind_gt_one, asindf_gt_one,    /* 213, 214, 215 */
+  atan2dl_zero, atan2d_zero, atan2df_zero,       /* 216, 217, 218 */
+  tandl_overflow, tand_overflow, tandf_overflow, /* 219, 220, 221 */
+  cotdl_overflow, cotd_overflow, cotdf_overflow, /* 222, 223, 224 */
+  cotl_overflow, cot_overflow, cotf_overflow,    /* 225, 226, 227 */
+  sinhcoshl_overflow, sinhcosh_overflow, sinhcoshf_overflow, /* 228, 229, 230 */
+  annuityl_by_zero, annuity_by_zero, annuityf_by_zero, /* 231, 232, 233 */
+  annuityl_less_m1, annuity_less_m1, annuityf_less_m1, /* 234, 235, 236 */
+  annuityl_overflow, annuity_overflow, annuityf_overflow, /* 237, 238, 239 */
+  annuityl_underflow, annuity_underflow, annuityf_underflow, /* 240, 241, 242 */
+  compoundl_by_zero, compound_by_zero, compoundf_by_zero, /* 243, 244, 245 */
+  compoundl_less_m1, compound_less_m1, compoundf_less_m1, /* 246, 247, 248 */
+  compoundl_overflow, compound_overflow, compoundf_overflow, /* 249, 250, 251 */
+  compoundl_underflow, compound_underflow, compoundf_underflow, /* 252, 253, 254 */
+  tgammal_overflow, tgammal_negative, tgammal_reserve, /* 255, 256, 257 */
+  tgamma_overflow, tgamma_negative, tgamma_reserve, /* 258, 259, 260 */
+  tgammaf_overflow, tgammaf_negative, tgammaf_reserve, /* 261, 262, 263 */
 } error_types;
 
 void __libm_error_support(void*,void*,void*,error_types);
+#ifdef _LIBC
 libc_hidden_proto(__libm_error_support)
+#endif
+
+#define HI_SIGNIFICAND_LESS(X, HI) ((X)->hi_significand < 0x ## HI)
+#define f64abs(x) ((x) < 0.0 ? -(x) : (x))
+
+#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
+};
+
+#endif /*__USE_EXTERNAL_FPMEMTYP_H__*/
+
+/* macros to form a double value in hex representation (unsigned int type) */
+
+#define DOUBLE_HEX(hi,lo) 0x##lo,0x##hi /*LITTLE_ENDIAN*/
+
+/* macros to form a long double value in hex representation (unsigned short type) */
+
+#if defined(_WIN32) || defined(_WIN64)
+#define LDOUBLE_ALIGN 16
+#else
+#define LDOUBLE_ALIGN 12
+#endif
+
+#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 */
 
-#define BIAS_64  1023
-#define EXPINF_64  2047
+#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)
 
-#define DOUBLE_HEX(HI, LO) 0x ## LO, 0x ## HI
+#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
+
+
+
+#if (defined(_WIN32) && !defined(_WIN64))
+
+#define FP80_DECLARE()
+#define _FPC_64    0x0300
+static unsigned short __wControlWord, __wNewControlWord;
+#define FP80_SET() { \
+        __asm { fnstcw   word ptr [__wControlWord] }   \
+        __wNewControlWord = __wControlWord | _FPC_64;  \
+        __asm { fldcw   word ptr [__wNewControlWord] } \
+    }
+#define FP80_RESET() { \
+        __asm { fldcw   word ptr [__wControlWord] } \
+    }
+#else /* defined(_WIN32) && !defined(_WIN64) */
+
+#define FP80_DECLARE()
+#define FP80_SET()
+#define FP80_RESET()
+
+#endif  /* defined(_WIN32) && !defined(_WIN64) */
+
+
+#ifdef _LIBC
+# include <math.h>
+#else
 
-#if 0
 static const unsigned INF[] = {
     DOUBLE_HEX(7ff00000, 00000000),
     DOUBLE_HEX(fff00000, 00000000)
@@ -255,12 +657,12 @@ static const unsigned INF[] = {
 static const double _zeroo = 0.0;
 static const double _bigg = 1.0e300;
 static const double _ponee = 1.0;
-static const double _nonee = -1.0;
+static const double _nonee = -1.0; 
 
 #define INVALID    (_zeroo * *((double*)&INF[0]))
-#define PINF       *((double*)&INF[0])
-#define NINF       -PINF
-#define PINF_DZ    (_ponee/_zeroo)
+#define PINF       *((double*)&INF[0]) 
+#define NINF       -PINF 
+#define PINF_DZ    (_ponee/_zeroo) 
 #define X_TLOSS    1.41484755040568800000e+16
 #endif
 
@@ -278,7 +680,7 @@ struct __exception
   char *name;
   double arg1, arg2, retval;
 };
-# else
+# else 
 
 #  ifndef _LIBC
 struct exception
@@ -300,18 +702,18 @@ struct exceptionl
 };
 
 #ifdef _MS_
-#define        MATHERR_F       _matherrf
-#define        MATHERR_D       _matherr
+#define	MATHERR_F	_matherrf
+#define	MATHERR_D	_matherr
 #else
-#define        MATHERR_F       matherrf
-#define        MATHERR_D       matherr
+#define	MATHERR_F	matherrf
+#define	MATHERR_D	matherr
 #endif
 
 # ifdef __cplusplus
-#define        EXC_DECL_D      __exception
+#define	EXC_DECL_D	__exception
 #else
 // exception is a reserved name in C++
-#define        EXC_DECL_D      exception
+#define	EXC_DECL_D	exception
 #endif
 
 extern int MATHERR_F(struct exceptionf*);
@@ -324,7 +726,7 @@ extern int matherrl(struct exceptionl*);
 #define ERRNO_DOMAIN errno = EDOM
 
 
-// Add code to support _LIB_VERSION
+// Add code to support _LIB_VERSIONIMF
 #ifndef _LIBC
 typedef enum
 {
@@ -335,29 +737,19 @@ typedef enum
     _ISOC_       // ISO C9X
 } _LIB_VERSION_TYPE;
 
-extern _LIB_VERSION_TYPE _LIB_VERSION;
-#endif
 
-// This is a run-time variable and may effect
-// floating point behavior of the libm functions
-
-#elif defined _LIBC
-
-# if !defined NOT_IN_libc && defined SHARED && defined DO_VERSIONING \
-     && !defined HAVE_BROKEN_ALIAS_ATTRIBUTE && !defined NO_HIDDEN
-#  define __libm_error_support  __GI___libm_error_support
-# endif
-
-#endif	/* __ASSEMBLER__ */
-
-/* Support for compatible assembler handling.  */
-#if !defined L && defined _LIBC
-#define L(name) .L##name
-#endif
-#ifdef __ELF__
-#define ASM_SIZE_DIRECTIVE(name) .size name,.-name
-#define ASM_TYPE_DIRECTIVE(name,T) .type name,T
+#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
-#define ASM_SIZE_DIRECTIVE(name)
-#define ASM_TYPE_DIRECTIVE(name,T)
+extern int (*pmatherrf)(struct exceptionf*);
+extern int (*pmatherr)(struct EXC_DECL_D*);
+extern int (*pmatherrl)(struct exceptionl*);
+#endif	/* LIBM_BUILD */
+
+// This is a run-time variable and may affect
+// floating point behavior of the libm functions
 #endif