Hello community,
here is the log from the commit of package glibc for openSUSE:Factory
checked in at Tue Oct 18 14:04:27 CEST 2011.
--------
--- openSUSE:Factory/glibc/glibc.changes 2011-10-11 16:53:52.000000000
+0200
+++ /mounts/work_src_done/STABLE/glibc/glibc.changes 2011-10-17
10:24:19.000000000 +0200
@@ -1,0 +2,6 @@
+Mon Oct 17 07:47:54 UTC 2011 - a...@suse.de
+
+- Remove fma, fmaf from libm-x86-64.diff.bz2, they are not accurate
+ (bso#13304).
+
+-------------------------------------------------------------------
calling whatdependson for head-i586
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ libm-x86-64.diff.bz2 ++++++
--- /var/tmp/diff_new_pack.Euwxvi/_old 2011-10-18 14:04:22.000000000 +0200
+++ /var/tmp/diff_new_pack.Euwxvi/_new 2011-10-18 14:04:22.000000000 +0200
@@ -193,8 +193,8 @@
+extern double chgsign(double x);
+extern float chgsignf(float x);
+
-+extern double fma(double x, double y, double z);
-+extern float fmaf(float x, float y, float z);
++
++
+
+extern void __remainder_piby2(double x, double *r, double *rr, int *region);
+extern void __remainder_piby2f(float x, double *r, int *region);
@@ -4617,249 +4617,6 @@
+}
+
+weak_alias (__floorf, floorf)
-Index: sysdeps/x86_64/fpu/s_fma.c
-===================================================================
---- /dev/null
-+++ sysdeps/x86_64/fpu/s_fma.c
-@@ -0,0 +1,117 @@
-+/*
-+(C) 2002 Advanced Micro Devices, Inc.
-+** YOUR USE OF THIS LIBRARY IS SUBJECT TO THE TERMS
-+ AND CONDITIONS OF THE GNU LESSER GENERAL PUBLIC
-+ LICENSE FOUND IN THE "README" FILE THAT IS INCLUDED WITH
-+ THIS LIBRARY**
-+*/
-+
-+#include "libm_amd.h"
-+#include "libm_util_amd.h"
-+
-+#define USE_SCALEDOUBLE_1
-+#define USE_SCALEDOUBLE_2
-+#include "libm_inlines_amd.h"
-+#undef USE_SCALEDOUBLE_1
-+#undef USE_SCALEDOUBLE_2
-+
-+double __fma(double a, double b, double sum)
-+{
-+ /* Returns a * b + sum with no intermediate loss of precision */
-+
-+ double ha, ta, hb, tb, z, zz, r, s, az, asum;
-+ int ua, ub, usum;
-+ int scaled, expover, expunder, scaleexp;
-+ unsigned long u;
-+
-+ GET_BITS_DP64(a, u);
-+ ua = (int)((u & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
-+ GET_BITS_DP64(b, u);
-+ ub = (int)((u & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
-+ GET_BITS_DP64(sum, u);
-+ usum = (int)((u & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
-+
-+ if (ua == EMAX_DP64 + 1 || ub == EMAX_DP64 + 1 || usum == EMAX_DP64 + 1)
-+ {
-+ /* One or more of the arguments is NaN or infinity. The
-+ result will also be NaN or infinity. */
-+ return a * b + sum;
-+ }
-+ else if (ua + ub > usum + 2 * MANTLENGTH_DP64)
-+ {
-+ /* sum is negligible compared with the extra-length product a*b */
-+ return a*b;
-+ }
-+ else if (usum > ua + ub + MANTLENGTH_DP64)
-+ {
-+ /* The product a*b is negligible compared with sum */
-+ return sum;
-+ }
-+
-+ expover = EMAX_DP64 - 2;
-+ expunder = EMIN_DP64 + MANTLENGTH_DP64;
-+ scaleexp = 0;
-+
-+
-+ if (ua + ub > expover || usum > expover)
-+ {
-+ /* The result is likely to overflow. Scale down in an attempt
-+ to avoid unnecessary overflow. The true result may still overflow. */
-+ scaled = 1;
-+ scaleexp = expover / 2;
-+ a = scaleDouble_1(a, -scaleexp);
-+ b = scaleDouble_1(b, -scaleexp);
-+ sum = scaleDouble_2(sum, -2*scaleexp);
-+ }
-+ else if (ua + ub < expunder)
-+ {
-+ /* The product a*b is near underflow; scale up */
-+ scaled = 1;
-+ scaleexp = expunder / 2;
-+ a = scaleDouble_1(a, -scaleexp);
-+ b = scaleDouble_1(b, -scaleexp);
-+ sum = scaleDouble_2(sum, -2*scaleexp);
-+ }
-+ else
-+ scaled = 0;
-+
-+ /* Split a into ha (head) and ta (tail). Do the same for b. */
-+ ha = a;
-+ GET_BITS_DP64(ha, u);
-+ u &= 0xfffffffff8000000;
-+ PUT_BITS_DP64(u, ha);
-+ ta = a - ha;
-+ hb = b;
-+ GET_BITS_DP64(hb, u);
-+ u &= 0xfffffffff8000000;
-+ PUT_BITS_DP64(u, hb);
-+ tb = b - hb;
-+
-+ /* Carefully multiply the parts together. z is the most significant
-+ part of the result, and zz the least significant part */
-+ z = a * b;
-+ zz = (((ha * hb - z) + ha * tb) + ta * hb) + ta * tb;
-+
-+ /* Set az = abs(z), asum = abs(sum) */
-+ GET_BITS_DP64(z, u);
-+ u &= ~SIGNBIT_DP64;
-+ PUT_BITS_DP64(u, az);
-+ GET_BITS_DP64(sum, u);
-+ u &= ~SIGNBIT_DP64;
-+ PUT_BITS_DP64(u, asum);
-+
-+ /* Carefully add (z,zz) to sum */
-+ r = z + sum;
-+
-+ if (az > asum)
-+ s = ((z - r) + sum) + zz;
-+ else
-+ s = ((sum - r) + z) + zz;
-+
-+ if (scaled)
-+ return scaleDouble_1(r + s, 2*scaleexp);
-+ else
-+ return r + s;
-+}
-+
-+weak_alias (__fma, fma)
-Index: sysdeps/x86_64/fpu/s_fmaf.c
-===================================================================
---- /dev/null
-+++ sysdeps/x86_64/fpu/s_fmaf.c
-@@ -0,0 +1,116 @@
-+/*
-+(C) 2002 Advanced Micro Devices, Inc.
-+** YOUR USE OF THIS LIBRARY IS SUBJECT TO THE TERMS
-+ AND CONDITIONS OF THE GNU LESSER GENERAL PUBLIC
-+ LICENSE FOUND IN THE "README" FILE THAT IS INCLUDED WITH
-+ THIS LIBRARY**
-+*/
-+
-+#include "libm_amd.h"
-+#include "libm_util_amd.h"
-+
-+#define USE_SCALEFLOAT_1
-+#define USE_SCALEFLOAT_2
-+#include "libm_inlines_amd.h"
-+#undef USE_SCALEFLOAT_1
-+#undef USE_SCALEFLOAT_2
-+
-+float __fmaf(float a, float b, float sum)
-+{
-+ /* Returns a * b + sum with no intermediate loss of precision */
-+
-+ float ha, ta, hb, tb, z, zz, r, s, az, asum;
-+ int ua, ub, usum;
-+ int scaled, expover, expunder, scaleexp;
-+ unsigned int u;
-+
-+ GET_BITS_SP32(a, u);
-+ ua = (int)((u & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
-+ GET_BITS_SP32(b, u);
-+ ub = (int)((u & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
-+ GET_BITS_SP32(sum, u);
-+ usum = (int)((u & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
-+
-+ if (ua == EMAX_SP32 + 1 || ub == EMAX_SP32 + 1 || usum == EMAX_SP32 + 1)
-+ {
-+ /* One or more of the arguments is NaN or infinity. The
-+ result will also be NaN or infinity. */
-+ return a * b + sum;
-+ }
-+ else if (ua + ub > usum + 2 * MANTLENGTH_SP32)
-+ {
-+ /* sum is negligible compared with the extra-length product a*b */
-+ return a*b;
-+ }
-+ else if (usum > ua + ub + MANTLENGTH_SP32)
-+ {
-+ /* The product a*b is negligible compared with sum */
-+ return sum;
-+ }
-+
-+ expover = EMAX_SP32 - 2;
-+ expunder = EMIN_SP32 + MANTLENGTH_SP32;
-+ scaleexp = 0;
-+
-+ if (ua + ub > expover || usum > expover)
-+ {
-+ /* The result is likely to overflow. Scale down in an attempt
-+ to avoid unnecessary overflow. The true result may still overflow. */
-+ scaled = 1;
-+ scaleexp = expover / 2;
-+ a = scaleFloat_1(a, -scaleexp);
-+ b = scaleFloat_1(b, -scaleexp);
-+ sum = scaleFloat_2(sum, -2*scaleexp);
-+ }
-+ else if (ua + ub < expunder)
-+ {
-+ /* The product a*b is near underflow; scale up */
-+ scaled = 1;
-+ scaleexp = expunder / 2;
-+ a = scaleFloat_1(a, -scaleexp);
-+ b = scaleFloat_1(b, -scaleexp);
-+ sum = scaleFloat_2(sum, -2*scaleexp);
-+ }
-+ else
-+ scaled = 0;
-+
-+ /* Split a into ha (head) and ta (tail). Do the same for b. */
-+ ha = a;
-+ GET_BITS_SP32(ha, u);
-+ u &= 0xfffff000;
-+ PUT_BITS_SP32(u, ha);
-+ ta = a - ha;
-+ hb = b;
-+ GET_BITS_SP32(hb, u);
-+ u &= 0xfffff000;
-+ PUT_BITS_SP32(u, hb);
-+ tb = b - hb;
-+
-+ /* Carefully multiply the parts together. z is the most significant
-+ part of the result, and zz the least significant part */
-+ z = a * b;
-+ zz = (((ha * hb - z) + ha * tb) + ta * hb) + ta * tb;
-+
-+ /* Set az = abs(z), asum = abs(sum) */
-+ GET_BITS_SP32(z, u);
-+ u &= ~SIGNBIT_SP32;
-+ PUT_BITS_SP32(u, az);
-+ GET_BITS_SP32(sum, u);
-+ u &= ~SIGNBIT_SP32;
-+ PUT_BITS_SP32(u, asum);
-+
-+ /* Carefully add (z,zz) to sum */
-+ r = z + sum;
-+
-+ if (az > asum)
-+ s = ((z - r) + sum) + zz;
-+ else
-+ s = ((sum - r) + z) + zz;
-+
-+ if (scaled)
-+ return scaleFloat_1(r + s, 2*scaleexp);
-+ else
-+ return r + s;
-+}
-+
-+weak_alias (__fmaf, fmaf)
Index: sysdeps/x86_64/fpu/s_logb.c
===================================================================
--- /dev/null
continue with "q"...
Remember to have fun...
--
To unsubscribe, e-mail: opensuse-commit+unsubscr...@opensuse.org
For additional commands, e-mail: opensuse-commit+h...@opensuse.org
