From: Saul Wold <sgw@linux.intel.com>
To: Matthew McClintock <msm@freescale.com>
Cc: openembedded-core@lists.openembedded.org
Subject: Re: [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500
Date: Tue, 02 Oct 2012 07:53:42 -0700 [thread overview]
Message-ID: <506AFFF6.5060107@linux.intel.com> (raw)
In-Reply-To: <1348795994-21695-1-git-send-email-msm@freescale.com>
Richard merged the first seven patches into OE-Core, there is some
discussion about the remaining 3.
Thanks
Sau!
On 09/27/2012 06:33 PM, Matthew McClintock wrote:
> Signed-off-by: Matthew McClintock <msm@freescale.com>
> ---
> v2: add upstream-status and signed off by to patch
>
> .../eglibc/eglibc-2.16/glibc.fix_sqrt2.patch | 1491 ++++++++++++++++++++
> .../recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch | 538 -------
> meta/recipes-core/eglibc/eglibc_2.16.bb | 4 +-
> 3 files changed, 1493 insertions(+), 540 deletions(-)
> create mode 100644 meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
> delete mode 100644 meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
>
> diff --git a/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
> new file mode 100644
> index 0000000..a669729
> --- /dev/null
> +++ b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
> @@ -0,0 +1,1491 @@
> +Signed-of-by: Edmar Wienskoski <edmar@freescale.com>
> +Upstream-Status: Pending
> +
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c 2012-06-14 14:55:14.749001061 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c 2012-06-14 14:55:14.749001061 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c 2012-06-14 14:55:21.812002270 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c 2012-06-14 14:55:21.812002270 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c 2012-06-14 14:55:24.620001266 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c 2012-06-14 14:55:24.620001266 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c 2012-06-14 14:56:02.080000985 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c 2012-06-14 14:56:02.080000985 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/603e/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies 2012-06-14 14:54:00.481000876 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/e500mc/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies 2012-06-14 14:54:17.000001007 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/e5500/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies 2012-06-14 14:54:31.054001299 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/e6500/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies 2012-06-14 14:51:50.453001709 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc64/e5500/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies 2012-06-14 14:58:14.298001288 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc64/e6500/fpu
> diff --git a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch b/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
> deleted file mode 100644
> index 203040c..0000000
> --- a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
> +++ /dev/null
> @@ -1,538 +0,0 @@
> -Upstream-Status: Pending
> -
> -2011-03-22 Joseph Myers <joseph@codesourcery.com>
> -
> - Merge from SG++ 2.11:
> -
> - 2010-10-05 Nathan Froyd <froydnj@codesourcery.com>
> -
> - Issue #9382
> -
> - * sysdeps/powerpc/powerpc32/603e/: New directory.
> - * sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/: New directory.
> - * sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/: New directory.
> - * sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/: New directory.
> - * sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c: Update.
> - * sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c: Update.
> - * sysdeps/powerpc/powerpc64/e5500/fpu/Implies: New file.
> -
> -Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> -@@ -0,0 +1,134 @@
> -+/* Double-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float two108 = 3.245185536584267269e+32;
> -+static const float twom54 = 5.551115123125782702e-17;
> -+static const float half = 0.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the actual square root and half of its reciprocal
> -+ simultaneously. */
> -+
> -+#ifdef __STDC__
> -+double
> -+__ieee754_sqrt (double b)
> -+#else
> -+double
> -+__ieee754_sqrt (b)
> -+ double b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+ double y, g, h, d, r;
> -+ ieee_double_shape_type u;
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ u.value = b;
> -+
> -+ relax_fenv_state ();
> -+
> -+ __asm__ ("frsqrte %[estimate], %[x]\n"
> -+ : [estimate] "=f" (y) : [x] "f" (b));
> -+
> -+ /* Following Muller et al, page 168, equation 5.20.
> -+
> -+ h goes to 1/(2*sqrt(b))
> -+ g goes to sqrt(b).
> -+
> -+ We need three iterations to get within 1ulp. */
> -+
> -+ /* Indicate that these can be performed prior to the branch. GCC
> -+ insists on sinking them below the branch, however; it seems like
> -+ they'd be better before the branch so that we can cover any latency
> -+ from storing the argument and loading its high word. Oh well. */
> -+
> -+ g = b * y;
> -+ h = 0.5 * y;
> -+
> -+ /* Handle small numbers by scaling. */
> -+ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> -+ return __ieee754_sqrt (b * two108) * twom54;
> -+
> -+#define FMADD(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> -+
> -+ /* Final refinement. */
> -+ d = FNMSUB (g, g, b);
> -+
> -+ fesetenv_register (fe);
> -+ return FMADD (d, h, g);
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_wash (b);
> -+}
> -Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> -@@ -0,0 +1,101 @@
> -+/* Single-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float threehalf = 1.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the reciprocal square root and use that to compute the actual
> -+ square root. */
> -+
> -+#ifdef __STDC__
> -+float
> -+__ieee754_sqrtf (float b)
> -+#else
> -+float
> -+__ieee754_sqrtf (b)
> -+ float b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+#define FMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ double y, x;
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ relax_fenv_state ();
> -+
> -+ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> -+ y = FMSUB (threehalf, b, b);
> -+
> -+ /* Initial estimate. */
> -+ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> -+
> -+ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+
> -+ /* All done. */
> -+ fesetenv_register (fe);
> -+ return x * b;
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_washf (b);
> -+}
> -Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> -@@ -0,0 +1,134 @@
> -+/* Double-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float two108 = 3.245185536584267269e+32;
> -+static const float twom54 = 5.551115123125782702e-17;
> -+static const float half = 0.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the actual square root and half of its reciprocal
> -+ simultaneously. */
> -+
> -+#ifdef __STDC__
> -+double
> -+__ieee754_sqrt (double b)
> -+#else
> -+double
> -+__ieee754_sqrt (b)
> -+ double b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+ double y, g, h, d, r;
> -+ ieee_double_shape_type u;
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ u.value = b;
> -+
> -+ relax_fenv_state ();
> -+
> -+ __asm__ ("frsqrte %[estimate], %[x]\n"
> -+ : [estimate] "=f" (y) : [x] "f" (b));
> -+
> -+ /* Following Muller et al, page 168, equation 5.20.
> -+
> -+ h goes to 1/(2*sqrt(b))
> -+ g goes to sqrt(b).
> -+
> -+ We need three iterations to get within 1ulp. */
> -+
> -+ /* Indicate that these can be performed prior to the branch. GCC
> -+ insists on sinking them below the branch, however; it seems like
> -+ they'd be better before the branch so that we can cover any latency
> -+ from storing the argument and loading its high word. Oh well. */
> -+
> -+ g = b * y;
> -+ h = 0.5 * y;
> -+
> -+ /* Handle small numbers by scaling. */
> -+ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> -+ return __ieee754_sqrt (b * two108) * twom54;
> -+
> -+#define FMADD(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> -+
> -+ /* Final refinement. */
> -+ d = FNMSUB (g, g, b);
> -+
> -+ fesetenv_register (fe);
> -+ return FMADD (d, h, g);
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_wash (b);
> -+}
> -Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> -@@ -0,0 +1,101 @@
> -+/* Single-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float threehalf = 1.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the reciprocal square root and use that to compute the actual
> -+ square root. */
> -+
> -+#ifdef __STDC__
> -+float
> -+__ieee754_sqrtf (float b)
> -+#else
> -+float
> -+__ieee754_sqrtf (b)
> -+ float b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+#define FMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ double y, x;
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ relax_fenv_state ();
> -+
> -+ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> -+ y = FMSUB (threehalf, b, b);
> -+
> -+ /* Initial estimate. */
> -+ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> -+
> -+ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+
> -+ /* All done. */
> -+ fesetenv_register (fe);
> -+ return x * b;
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_washf (b);
> -+}
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc64/e5500/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
> index 72d134a..c97a792 100644
> --- a/meta/recipes-core/eglibc/eglibc_2.16.bb
> +++ b/meta/recipes-core/eglibc/eglibc_2.16.bb
> @@ -3,7 +3,7 @@ require eglibc.inc
> SRCREV = "20393"
>
> DEPENDS += "gperf-native kconfig-frontends-native"
> -PR = "r10"
> +PR = "r11"
> PR_append = "+svnr${SRCPV}"
>
> EGLIBC_BRANCH="eglibc-2_16"
> @@ -13,7 +13,7 @@ SRC_URI = "svn://www.eglibc.org/svn/branches/;module=${EGLIBC_BRANCH};protocol=h
> file://mips-rld-map-check.patch \
> file://etc/ld.so.conf \
> file://generate-supported.mk \
> - file://ppc-sqrt.patch \
> + file://glibc.fix_sqrt2.patch \
> file://multilib_readlib.patch \
> file://use-sysroot-cxx-headers.patch \
> file://ppc-sqrt_finite.patch \
>
prev parent reply other threads:[~2012-10-02 15:06 UTC|newest]
Thread overview: 19+ messages / expand[flat|nested] mbox.gz Atom feed top
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 02/10] eglibc_2.16.bb: refresh ppc-sqrt_finite.patch for Freescale targets Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 03/10] eglibc_2.16.bb: refresh ppc_slow_ieee754_sqrt.patch " Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 04/10] eglibc_2.16.bb: refresh fsl-ppc-no-fsqrt.patch " Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 05/10] arch-powerpc.inc: add altivec as a valid tune feature Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 06/10] tune-ppce6500.inc: add e6500 tune files Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 07/10] flac_1.2.1.bb: use TUNE_FEATURES to enable/disable altivec Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 08/10] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE Matthew McClintock
2012-09-28 10:32 ` Richard Purdie
2012-09-28 15:07 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNedwk-YhQLgJXf7Jffm7DDR0A49fg-T0imC90x-EJS98A@mail.gmail.com>
2012-09-28 16:15 ` McClintock Matthew-B29882
2012-09-28 1:33 ` [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros Matthew McClintock
2012-09-28 14:52 ` Burton, Ross
2012-09-28 14:57 ` Burton, Ross
2012-09-28 15:03 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNeVxSgoZR6jQyEQ16P-_b+1_AQPcpFqcO5NPr=j8SkDVQ@mail.gmail.com>
2012-10-02 15:50 ` McClintock Matthew-B29882
2012-10-02 15:54 ` Burton, Ross
2012-10-02 14:53 ` Saul Wold [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=506AFFF6.5060107@linux.intel.com \
--to=sgw@linux.intel.com \
--cc=msm@freescale.com \
--cc=openembedded-core@lists.openembedded.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.