[PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[Matthew McClintock]

Signed-off-by: Matthew McClintock <msm@freescale.com>
---
 .../eglibc/eglibc-2.16/glibc.fix_sqrt2.patch       | 1488 ++++++++++++++++++++
 .../recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch |  538 -------
 meta/recipes-core/eglibc/eglibc_2.16.bb            |    4 +-
 3 files changed, 1490 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..e098192
--- /dev/null
+++ b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
@@ -0,0 +1,1488 @@
+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 78dc44a..a753882 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 = "r9"
+PR = "r10"
 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 \
-- 
1.7.9.7

[PATCH] eglibc_2.16.bb: refresh ppc_slow_ieee754_sqrt.patch for e6500

[Matthew McClintock]

Make same changes for e6500 fpu as done with others

Signed-off-by: Matthew McClintock <msm@freescale.com>
---
 .../eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch |  101 ++++++++++++++++----
 meta/recipes-core/eglibc/eglibc_2.16.bb            |    2 +-
 2 files changed, 84 insertions(+), 19 deletions(-)

diff --git a/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch b/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch
index 9a932ff..f432b72 100644
--- a/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch
+++ b/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch
@@ -5,9 +5,9 @@ Signed-off-by: Khem Raj <raj.khem@gmail.com>
 Upstream-Status: Pending
 Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
 ===================================================================
---- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c	2012-07-03 22:36:01.172386436 -0700
-+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c	2012-07-03 23:04:37.396469515 -0700
-@@ -40,7 +40,7 @@
+--- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
+@@ -40,7 +40,7 @@ static const float half = 0.5;
     simultaneously.  */
  
  double
@@ -16,7 +16,7 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
  {
    if (__builtin_expect (b > 0, 1))
      {
-@@ -77,7 +77,7 @@
+@@ -77,7 +77,7 @@ __ieee754_sqrt (double b)
    
            /* Handle small numbers by scaling.  */
            if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
@@ -25,7 +25,7 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
  
  #define FMADD(a_, c_, b_)                                               \
            ({ double __r;                                                \
-@@ -126,4 +126,12 @@
+@@ -126,4 +126,12 @@ __ieee754_sqrt (double b)
      }
    return f_wash (b);
  }
@@ -40,9 +40,9 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
  strong_alias (__ieee754_sqrt, __sqrt_finite)
 Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
 ===================================================================
---- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c	2012-07-03 22:36:01.172386436 -0700
-+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c	2012-07-03 23:07:06.260476775 -0700
-@@ -38,7 +38,7 @@
+--- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
+@@ -38,7 +38,7 @@ static const float threehalf = 1.5;
     square root.  */
  
  float
@@ -51,7 +51,7 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
  {
    if (__builtin_expect (b > 0, 1))
      {
-@@ -93,4 +93,10 @@
+@@ -93,4 +93,10 @@ __ieee754_sqrtf (float b)
      }
    return f_washf (b);
  }
@@ -64,9 +64,9 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
  strong_alias (__ieee754_sqrtf, __sqrtf_finite)
 Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
 ===================================================================
---- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c	2012-07-03 22:36:01.176386435 -0700
-+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c	2012-07-03 23:14:16.328497458 -0700
-@@ -40,7 +40,7 @@
+--- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
+@@ -40,7 +40,7 @@ static const float half = 0.5;
     simultaneously.  */
  
  double
@@ -75,7 +75,7 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
  {
    if (__builtin_expect (b > 0, 1))
      {
-@@ -77,7 +77,7 @@
+@@ -77,7 +77,7 @@ __ieee754_sqrt (double b)
    
            /* Handle small numbers by scaling.  */
            if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
@@ -84,7 +84,7 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
  
  #define FMADD(a_, c_, b_)                                               \
            ({ double __r;                                                \
-@@ -126,4 +126,12 @@
+@@ -126,4 +126,12 @@ __ieee754_sqrt (double b)
      }
    return f_wash (b);
  }
@@ -99,9 +99,9 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
  strong_alias (__ieee754_sqrt, __sqrt_finite)
 Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
 ===================================================================
---- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c	2012-07-03 22:36:01.176386435 -0700
-+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c	2012-07-03 23:13:52.732496373 -0700
-@@ -38,7 +38,7 @@
+--- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
+@@ -38,7 +38,7 @@ static const float threehalf = 1.5;
     square root.  */
  
  float
@@ -110,7 +110,7 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
  {
    if (__builtin_expect (b > 0, 1))
      {
-@@ -93,4 +93,10 @@
+@@ -93,4 +93,10 @@ __ieee754_sqrtf (float b)
      }
    return f_washf (b);
  }
@@ -121,3 +121,68 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
 +  return __slow_ieee754_sqrtf (x);
 +}
  strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+Index: libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
+@@ -41,10 +41,10 @@ static const float half = 0.5;
+ 
+ #ifdef __STDC__
+ double
+-__ieee754_sqrt (double b)
++__slow_ieee754_sqrt (double b)
+ #else
+ double
+-__ieee754_sqrt (b)
++__slow_ieee754_sqrt (b)
+      double b;
+ #endif
+ {
+@@ -83,7 +83,7 @@ __ieee754_sqrt (b)
+   
+           /* Handle small numbers by scaling.  */
+           if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
+-            return __ieee754_sqrt (b * two108) * twom54;
++            return __slow_ieee754_sqrt (b * two108) * twom54;
+ 
+ #define FMADD(a_, c_, b_)                                               \
+           ({ double __r;                                                \
+@@ -132,3 +132,10 @@ __ieee754_sqrt (b)
+     }
+   return f_wash (b);
+ }
++
++#undef __ieee754_sqrt
++double
++__ieee754_sqrt (double x)
++{
++   return __slow_ieee754_sqrt (x);
++}
+Index: libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
+@@ -39,10 +39,10 @@ static const float threehalf = 1.5;
+ 
+ #ifdef __STDC__
+ float
+-__ieee754_sqrtf (float b)
++__slow_ieee754_sqrtf (float b)
+ #else
+ float
+-__ieee754_sqrtf (b)
++__slow_ieee754_sqrtf (b)
+      float b;
+ #endif
+ {
+@@ -99,3 +99,10 @@ __ieee754_sqrtf (b)
+     }
+   return f_washf (b);
+ }
++
++#undef __ieee754_sqrtf
++float
++__ieee754_sqrtf (float x)
++{
++  return __slow_ieee754_sqrtf (x);
++}
diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
index a753882..96da9a5 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"
-- 
1.7.9.7

Re: [PATCH] eglibc_2.16.bb: refresh ppc_slow_ieee754_sqrt.patch for e6500

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 5:08 PM, Matthew McClintock <msm@freescale.com> wrote:
> Make same changes for e6500 fpu as done with others

This patch was the problem, I needed to update this for e500mc as well
since the glibc.fix_sqrt2.patch updates it as well. Will submit v2 of
both of the patches.

-M

>
> Signed-off-by: Matthew McClintock <msm@freescale.com>
> ---
>  .../eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch |  101 ++++++++++++++++----
>  meta/recipes-core/eglibc/eglibc_2.16.bb            |    2 +-
>  2 files changed, 84 insertions(+), 19 deletions(-)
>
> diff --git a/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch b/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch
> index 9a932ff..f432b72 100644
> --- a/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch
> +++ b/meta/recipes-core/eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch
> @@ -5,9 +5,9 @@ Signed-off-by: Khem Raj <raj.khem@gmail.com>
>  Upstream-Status: Pending
>  Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
>  ===================================================================
> ---- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c      2012-07-03 22:36:01.172386436 -0700
> -+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c   2012-07-03 23:04:37.396469515 -0700
> -@@ -40,7 +40,7 @@
> +--- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> ++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> +@@ -40,7 +40,7 @@ static const float half = 0.5;
>      simultaneously.  */
>
>   double
> @@ -16,7 +16,7 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
>   {
>     if (__builtin_expect (b > 0, 1))
>       {
> -@@ -77,7 +77,7 @@
> +@@ -77,7 +77,7 @@ __ieee754_sqrt (double b)
>
>             /* Handle small numbers by scaling.  */
>             if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> @@ -25,7 +25,7 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
>
>   #define FMADD(a_, c_, b_)                                               \
>             ({ double __r;                                                \
> -@@ -126,4 +126,12 @@
> +@@ -126,4 +126,12 @@ __ieee754_sqrt (double b)
>       }
>     return f_wash (b);
>   }
> @@ -40,9 +40,9 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
>   strong_alias (__ieee754_sqrt, __sqrt_finite)
>  Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
>  ===================================================================
> ---- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c     2012-07-03 22:36:01.172386436 -0700
> -+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c  2012-07-03 23:07:06.260476775 -0700
> -@@ -38,7 +38,7 @@
> +--- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> ++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> +@@ -38,7 +38,7 @@ static const float threehalf = 1.5;
>      square root.  */
>
>   float
> @@ -51,7 +51,7 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
>   {
>     if (__builtin_expect (b > 0, 1))
>       {
> -@@ -93,4 +93,10 @@
> +@@ -93,4 +93,10 @@ __ieee754_sqrtf (float b)
>       }
>     return f_washf (b);
>   }
> @@ -64,9 +64,9 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
>   strong_alias (__ieee754_sqrtf, __sqrtf_finite)
>  Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
>  ===================================================================
> ---- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c     2012-07-03 22:36:01.176386435 -0700
> -+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c  2012-07-03 23:14:16.328497458 -0700
> -@@ -40,7 +40,7 @@
> +--- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> ++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> +@@ -40,7 +40,7 @@ static const float half = 0.5;
>      simultaneously.  */
>
>   double
> @@ -75,7 +75,7 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
>   {
>     if (__builtin_expect (b > 0, 1))
>       {
> -@@ -77,7 +77,7 @@
> +@@ -77,7 +77,7 @@ __ieee754_sqrt (double b)
>
>             /* Handle small numbers by scaling.  */
>             if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> @@ -84,7 +84,7 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
>
>   #define FMADD(a_, c_, b_)                                               \
>             ({ double __r;                                                \
> -@@ -126,4 +126,12 @@
> +@@ -126,4 +126,12 @@ __ieee754_sqrt (double b)
>       }
>     return f_wash (b);
>   }
> @@ -99,9 +99,9 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
>   strong_alias (__ieee754_sqrt, __sqrt_finite)
>  Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
>  ===================================================================
> ---- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c    2012-07-03 22:36:01.176386435 -0700
> -+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 2012-07-03 23:13:52.732496373 -0700
> -@@ -38,7 +38,7 @@
> +--- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> ++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> +@@ -38,7 +38,7 @@ static const float threehalf = 1.5;
>      square root.  */
>
>   float
> @@ -110,7 +110,7 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
>   {
>     if (__builtin_expect (b > 0, 1))
>       {
> -@@ -93,4 +93,10 @@
> +@@ -93,4 +93,10 @@ __ieee754_sqrtf (float b)
>       }
>     return f_washf (b);
>   }
> @@ -121,3 +121,68 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
>  +  return __slow_ieee754_sqrtf (x);
>  +}
>   strong_alias (__ieee754_sqrtf, __sqrtf_finite)
> +Index: libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
> +===================================================================
> +--- libc.orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
> ++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
> +@@ -41,10 +41,10 @@ static const float half = 0.5;
> +
> + #ifdef __STDC__
> + double
> +-__ieee754_sqrt (double b)
> ++__slow_ieee754_sqrt (double b)
> + #else
> + double
> +-__ieee754_sqrt (b)
> ++__slow_ieee754_sqrt (b)
> +      double b;
> + #endif
> + {
> +@@ -83,7 +83,7 @@ __ieee754_sqrt (b)
> +
> +           /* Handle small numbers by scaling.  */
> +           if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> +-            return __ieee754_sqrt (b * two108) * twom54;
> ++            return __slow_ieee754_sqrt (b * two108) * twom54;
> +
> + #define FMADD(a_, c_, b_)                                               \
> +           ({ double __r;                                                \
> +@@ -132,3 +132,10 @@ __ieee754_sqrt (b)
> +     }
> +   return f_wash (b);
> + }
> ++
> ++#undef __ieee754_sqrt
> ++double
> ++__ieee754_sqrt (double x)
> ++{
> ++   return __slow_ieee754_sqrt (x);
> ++}
> +Index: libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
> +===================================================================
> +--- libc.orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
> ++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
> +@@ -39,10 +39,10 @@ static const float threehalf = 1.5;
> +
> + #ifdef __STDC__
> + float
> +-__ieee754_sqrtf (float b)
> ++__slow_ieee754_sqrtf (float b)
> + #else
> + float
> +-__ieee754_sqrtf (b)
> ++__slow_ieee754_sqrtf (b)
> +      float b;
> + #endif
> + {
> +@@ -99,3 +99,10 @@ __ieee754_sqrtf (b)
> +     }
> +   return f_washf (b);
> + }
> ++
> ++#undef __ieee754_sqrtf
> ++float
> ++__ieee754_sqrtf (float x)
> ++{
> ++  return __slow_ieee754_sqrtf (x);
> ++}
> diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
> index a753882..96da9a5 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"
> --
> 1.7.9.7
>
>
>
> _______________________________________________
> Openembedded-core mailing list
> Openembedded-core@lists.openembedded.org
> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core

[PATCH] arch-powerpc.inc: add altivec as a valid tune feature

[Matthew McClintock]

Signed-off-by: Matthew McClintock <msm@freescale.com>
---
 meta/conf/machine/include/powerpc/arch-powerpc.inc |    2 ++
 1 file changed, 2 insertions(+)

diff --git a/meta/conf/machine/include/powerpc/arch-powerpc.inc b/meta/conf/machine/include/powerpc/arch-powerpc.inc
index 12909d9..ae81cde 100644
--- a/meta/conf/machine/include/powerpc/arch-powerpc.inc
+++ b/meta/conf/machine/include/powerpc/arch-powerpc.inc
@@ -19,6 +19,8 @@ TUNEVALID[fpu-soft] = "Use software FPU."
 TUNE_CCARGS += "${@bb.utils.contains("TUNE_FEATURES", "fpu-soft", "-msoft-float", "", d)}"
 TARGET_FPU .= "${@bb.utils.contains("TUNE_FEATURES", "fpu-soft", "soft", "", d)}"
 
+TUNEVALID[altivec] = "Altivec"
+
 # Basic tune definitions
 AVAILTUNES += "powerpc powerpc-nf" 
 TUNE_FEATURES_tune-powerpc-nf = "m32 fpu-soft"
-- 
1.7.9.7

[PATCH] tune-ppce6500.inc: add e6500 tune files

[Matthew McClintock]

Also supports a new altivec TUNE_FEATURE

Signed-off-by: Matthew McClintock <msm@freescale.com>
---
 meta/conf/machine/include/tune-ppce6500.inc |   21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 meta/conf/machine/include/tune-ppce6500.inc

diff --git a/meta/conf/machine/include/tune-ppce6500.inc b/meta/conf/machine/include/tune-ppce6500.inc
new file mode 100644
index 0000000..982a7a4
--- /dev/null
+++ b/meta/conf/machine/include/tune-ppce6500.inc
@@ -0,0 +1,21 @@
+DEFAULTTUNE ?= "ppce6500"
+
+require conf/machine/include/powerpc/arch-powerpc64.inc
+
+TUNEVALID[e6500] = "Enable Freescale e6500 specific processor optimizations"
+TUNE_CCARGS += "${@bb.utils.contains("TUNE_FEATURES", "e6500", "-mcpu=e6500", "", d)}"
+
+AVAILTUNES += "ppce6500 ppc64e6500"
+TUNE_FEATURES_tune-ppce6500 = "m32 fpu-hard e6500 altivec"
+BASE_LIB_tune-ppce6500 = "lib"
+TUNE_PKGARCH_tune-ppce6500 = "ppce6500"
+PACKAGE_EXTRA_ARCHS_tune-ppce6500 = "${PACKAGE_EXTRA_ARCHS_tune-powerpc} ppce6500"
+
+TUNE_FEATURES_tune-ppc64e6500 = "m64 fpu-hard e6500 altivec"
+BASE_LIB_tune-ppc64e6500 = "lib64"
+TUNE_PKGARCH_tune-ppc64e6500 = "ppc64e6500"
+PACKAGE_EXTRA_ARCHS_tune-ppc64e6500 = "${PACKAGE_EXTRA_ARCHS_tune-powerpc64} ppc64e6500"
+
+# glibc configure options to get e6500 specific library
+GLIBC_EXTRA_OECONF_powerpc64 += "${@bb.utils.contains("TUNE_FEATURES", "e6500", "--with-cpu=e6500", "", d)}"
+GLIBC_EXTRA_OECONF_powerpc += "${@bb.utils.contains("TUNE_FEATURES", "e6500", "--with-cpu=603e", "", d)}"
-- 
1.7.9.7

Re: [PATCH] tune-ppce6500.inc: add e6500 tune files

[Khem Raj]

On Tue, Sep 18, 2012 at 3:08 PM, Matthew McClintock <msm@freescale.com> wrote:
> Also supports a new altivec TUNE_FEATURE

is altivec feature specific to e6500 ? I thought there should be more
tunes using it

Re: [PATCH] tune-ppce6500.inc: add e6500 tune files

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 5:19 PM, Khem Raj <raj.khem@gmail.com> wrote:
> On Tue, Sep 18, 2012 at 3:08 PM, Matthew McClintock <msm@freescale.com> wrote:
>> Also supports a new altivec TUNE_FEATURE
>
> is altivec feature specific to e6500 ? I thought there should be more
> tunes using it

Nothing else AFAIK... other layers could be doing interesting things
here. 86xx parts were the last to have Altivec and those don't build
within Yocto.. they can use this TUNE_FEATURE :)

-M

[PATCH] flac_1.2.1.bb: use TUNE_FEATURES to enable/disable altivec

[Matthew McClintock]

Signed-off-by: Matthew McClintock <msm@freescale.com>
---
 meta/recipes-multimedia/flac/flac_1.2.1.bb |    6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/meta/recipes-multimedia/flac/flac_1.2.1.bb b/meta/recipes-multimedia/flac/flac_1.2.1.bb
index 157128f..6520b71 100644
--- a/meta/recipes-multimedia/flac/flac_1.2.1.bb
+++ b/meta/recipes-multimedia/flac/flac_1.2.1.bb
@@ -36,10 +36,8 @@ EXTRA_OECONF = "--disable-oggtest --disable-id3libtest \
                 --without-xmms-exec-prefix \
                 --without-libiconv-prefix \
                 --without-id3lib"
-EXTRA_OECONF_prepend_e500mc = "--disable-altivec "
-EXTRA_OECONF_prepend_e5500 = "--disable-altivec "
-EXTRA_OECONF_prepend_e5500-64b = "--disable-altivec "
-EXTRA_OECONF_prepend_mpc8315e-rdb = "--disable-altivec "
+
+EXTRA_OECONF += "${@bb.utils.contains("TUNE_FEATURES", "altivec", " --enable-altivec", " --disable-altivec", d)}"
 
 PACKAGES += "libflac libflac++ liboggflac liboggflac++"
 FILES_${PN} = "${bindir}/*"
-- 
1.7.9.7

[PATCH] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe

[Matthew McClintock]

For a 32-bit machine, we still might always (or optionally) want to build a
64-bit kernel so we add an exception.

Signed-off-by: Matthew McClintock <msm@freescale.com>
---
Not sure if we should just skip for all virtual/kernel's?

 meta/classes/insane.bbclass |    6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/meta/classes/insane.bbclass b/meta/classes/insane.bbclass
index e74eb3f..2ca1b49 100644
--- a/meta/classes/insane.bbclass
+++ b/meta/classes/insane.bbclass
@@ -366,11 +366,13 @@ def package_qa_check_arch(path,name,d, elf, messages):
 
     # Check the architecture and endiannes of the binary
     if not ((machine == elf.machine()) or \
-	("virtual/kernel" in provides) and (target_os == "linux-gnux32")):
+	("virtual/kernel" in provides) and (target_os == "linux-gnux32") or \
+	("virtual/kernel" in provides) and (target_arch == "powerpc")):
         messages.append("Architecture did not match (%d to %d) on %s" % \
                  (machine, elf.machine(), package_qa_clean_path(path,d)))
     elif not ((bits == elf.abiSize()) or  \
-	("virtual/kernel" in provides) and (target_os == "linux-gnux32")):
+	("virtual/kernel" in provides) and (target_os == "linux-gnux32") or \
+	("virtual/kernel" in provides) and (target_arch == "powerpc")):
         messages.append("Bit size did not match (%d to %d) %s on %s" % \
                  (bits, elf.abiSize(), bpn, package_qa_clean_path(path,d)))
     elif not littleendian == elf.isLittleEndian():
-- 
1.7.9.7

Re: [PATCH] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe

[Khem Raj]

On Tue, Sep 18, 2012 at 3:08 PM, Matthew McClintock <msm@freescale.com> wrote:
> For a 32-bit machine, we still might always (or optionally) want to build a
> 64-bit kernel so we add an exception.
>
> Signed-off-by: Matthew McClintock <msm@freescale.com>
> ---
> Not sure if we should just skip for all virtual/kernel's?
>
>  meta/classes/insane.bbclass |    6 ++++--
>  1 file changed, 4 insertions(+), 2 deletions(-)
>
> diff --git a/meta/classes/insane.bbclass b/meta/classes/insane.bbclass
> index e74eb3f..2ca1b49 100644
> --- a/meta/classes/insane.bbclass
> +++ b/meta/classes/insane.bbclass
> @@ -366,11 +366,13 @@ def package_qa_check_arch(path,name,d, elf, messages):
>
>      # Check the architecture and endiannes of the binary
>      if not ((machine == elf.machine()) or \
> -       ("virtual/kernel" in provides) and (target_os == "linux-gnux32")):
> +       ("virtual/kernel" in provides) and (target_os == "linux-gnux32") or \
> +       ("virtual/kernel" in provides) and (target_arch == "powerpc")):

I feel using powerpc target_arch here is a broad brush. Can there be
some other variable in metadata
that could indicate 64bit kernel and a 32bit ppc userspace combo of
some sort ? or may be a variable
stating that this machine's kernel is 64bit and use that here instead.

>          messages.append("Architecture did not match (%d to %d) on %s" % \
>                   (machine, elf.machine(), package_qa_clean_path(path,d)))
>      elif not ((bits == elf.abiSize()) or  \
> -       ("virtual/kernel" in provides) and (target_os == "linux-gnux32")):
> +       ("virtual/kernel" in provides) and (target_os == "linux-gnux32") or \
> +       ("virtual/kernel" in provides) and (target_arch == "powerpc")):
>          messages.append("Bit size did not match (%d to %d) %s on %s" % \
>                   (bits, elf.abiSize(), bpn, package_qa_clean_path(path,d)))
>      elif not littleendian == elf.isLittleEndian():
> --
> 1.7.9.7
>
>
>
> _______________________________________________
> Openembedded-core mailing list
> Openembedded-core@lists.openembedded.org
> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core

Re: [PATCH] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 5:44 PM, Khem Raj <raj.khem@gmail.com> wrote:
> On Tue, Sep 18, 2012 at 3:08 PM, Matthew McClintock <msm@freescale.com> wrote:
>> For a 32-bit machine, we still might always (or optionally) want to build a
>> 64-bit kernel so we add an exception.
>>
>> Signed-off-by: Matthew McClintock <msm@freescale.com>
>> ---
>> Not sure if we should just skip for all virtual/kernel's?
>>
>>  meta/classes/insane.bbclass |    6 ++++--
>>  1 file changed, 4 insertions(+), 2 deletions(-)
>>
>> diff --git a/meta/classes/insane.bbclass b/meta/classes/insane.bbclass
>> index e74eb3f..2ca1b49 100644
>> --- a/meta/classes/insane.bbclass
>> +++ b/meta/classes/insane.bbclass
>> @@ -366,11 +366,13 @@ def package_qa_check_arch(path,name,d, elf, messages):
>>
>>      # Check the architecture and endiannes of the binary
>>      if not ((machine == elf.machine()) or \
>> -       ("virtual/kernel" in provides) and (target_os == "linux-gnux32")):
>> +       ("virtual/kernel" in provides) and (target_os == "linux-gnux32") or \
>> +       ("virtual/kernel" in provides) and (target_arch == "powerpc")):
>
> I feel using powerpc target_arch here is a broad brush. Can there be
> some other variable in metadata
> that could indicate 64bit kernel and a 32bit ppc userspace combo of
> some sort ? or may be a variable
> stating that this machine's kernel is 64bit and use that here instead.

I added BUILD_64BIT_KERNEL in my layer for building a 64-bit kernel on
a 32-bit machine, we could use this (or another "better" name)

-M

>
>>          messages.append("Architecture did not match (%d to %d) on %s" % \
>>                   (machine, elf.machine(), package_qa_clean_path(path,d)))
>>      elif not ((bits == elf.abiSize()) or  \
>> -       ("virtual/kernel" in provides) and (target_os == "linux-gnux32")):
>> +       ("virtual/kernel" in provides) and (target_os == "linux-gnux32") or \
>> +       ("virtual/kernel" in provides) and (target_arch == "powerpc")):
>>          messages.append("Bit size did not match (%d to %d) %s on %s" % \
>>                   (bits, elf.abiSize(), bpn, package_qa_clean_path(path,d)))
>>      elif not littleendian == elf.isLittleEndian():
>> --
>> 1.7.9.7
>>
>>
>>
>> _______________________________________________
>> Openembedded-core mailing list
>> Openembedded-core@lists.openembedded.org
>> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core
>
> _______________________________________________
> Openembedded-core mailing list
> Openembedded-core@lists.openembedded.org
> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core

[PATCH] binutils.inc: binutils will build differently if this feature is enabled, so add a dependency

[Matthew McClintock]

Signed-off-by: Matthew McClintock <msm@freescale.com>
---
Not sure if we should try to fix via configure options

 meta/recipes-devtools/binutils/binutils.inc |    2 ++
 1 file changed, 2 insertions(+)

diff --git a/meta/recipes-devtools/binutils/binutils.inc b/meta/recipes-devtools/binutils/binutils.inc
index ee748a4..ff64882 100644
--- a/meta/recipes-devtools/binutils/binutils.inc
+++ b/meta/recipes-devtools/binutils/binutils.inc
@@ -80,6 +80,8 @@ export CC_FOR_BUILD = "LD_LIBRARY_PATH= ${BUILD_CC}"
 export CPP_FOR_BUILD = "${BUILD_CPP}"
 export CFLAGS_FOR_BUILD = "${BUILD_CFLAGS}"
 
+MULTIARCH := "${@bb.utils.contains("DISTRO_FEATURES", "multiarch", "yes", "no", d)}"
+do_configure[vardeps] += "MULTIARCH"
 do_configure () {
 	(cd ${S}; gnu-configize) || die "Failed to run gnu-configize"
 	oe_runconf
-- 
1.7.9.7

Re: [PATCH] binutils.inc: binutils will build differently if this feature is enabled, so add a dependency

[Burton, Ross]

"this feature"?  Please use descriptive commit logs, so s/this
feature/mulitarch/.

Ross

Re: [PATCH] binutils.inc: binutils will build differently if this feature is enabled, so add a dependency

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 11:35 PM, Burton, Ross <ross.burton@intel.com> wrote:
> "this feature"?  Please use descriptive commit logs, so s/this
> feature/mulitarch/.

I will update this and send a v2, after I wait a bit for more comments.

-M

>
> Ross
>
> _______________________________________________
> Openembedded-core mailing list
> Openembedded-core@lists.openembedded.org
> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[McClintock Matthew-B29882]

Err this was supposed to be a series but I used the wrong format-patch
commands, patches in my tree here:

http://git.yoctoproject.org/cgit/cgit.cgi/poky-contrib/log/?h=mattsm/master

-M

On Tue, Sep 18, 2012 at 5:08 PM, Matthew McClintock <msm@freescale.com> wrote:
> Signed-off-by: Matthew McClintock <msm@freescale.com>
> ---
>  .../eglibc/eglibc-2.16/glibc.fix_sqrt2.patch       | 1488 ++++++++++++++++++++
>  .../recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch |  538 -------
>  meta/recipes-core/eglibc/eglibc_2.16.bb            |    4 +-
>  3 files changed, 1490 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..e098192
> --- /dev/null
> +++ b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
> @@ -0,0 +1,1488 @@
> +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 78dc44a..a753882 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 = "r9"
> +PR = "r10"
>  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 \
> --
> 1.7.9.7
>
>
>
> _______________________________________________
> Openembedded-core mailing list
> Openembedded-core@lists.openembedded.org
> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[Khem Raj]

On Tue, Sep 18, 2012 at 3:12 PM, McClintock Matthew-B29882
<B29882@freescale.com> wrote:
> Err this was supposed to be a series but I used the wrong format-patch
> commands, patches in my tree here:
>
> http://git.yoctoproject.org/cgit/cgit.cgi/poky-contrib/log/?h=mattsm/master
>

what changes are needed for e6500 ? can these files be shadowed from e5500 ?
I am confused with the two patches


> -M
>
> On Tue, Sep 18, 2012 at 5:08 PM, Matthew McClintock <msm@freescale.com> wrote:
>> Signed-off-by: Matthew McClintock <msm@freescale.com>
>> ---
>>  .../eglibc/eglibc-2.16/glibc.fix_sqrt2.patch       | 1488 ++++++++++++++++++++
>>  .../recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch |  538 -------
>>  meta/recipes-core/eglibc/eglibc_2.16.bb            |    4 +-
>>  3 files changed, 1490 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..e098192
>> --- /dev/null
>> +++ b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
>> @@ -0,0 +1,1488 @@
>> +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 78dc44a..a753882 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 = "r9"
>> +PR = "r10"
>>  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 \
>> --
>> 1.7.9.7
>>
>>
>>
>> _______________________________________________
>> Openembedded-core mailing list
>> Openembedded-core@lists.openembedded.org
>> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core
>
> _______________________________________________
> Openembedded-core mailing list
> Openembedded-core@lists.openembedded.org
> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 5:16 PM, Khem Raj <raj.khem@gmail.com> wrote:
> On Tue, Sep 18, 2012 at 3:12 PM, McClintock Matthew-B29882
> <B29882@freescale.com> wrote:
>> Err this was supposed to be a series but I used the wrong format-patch
>> commands, patches in my tree here:
>>
>> http://git.yoctoproject.org/cgit/cgit.cgi/poky-contrib/log/?h=mattsm/master
>>
>
> what changes are needed for e6500 ? can these files be shadowed from e5500 ?
> I am confused with the two patches

It's just renaming the patch, so it's replacing ppc-sqrt.patch with
glibc.fix_sqrt2.patch - and these are not authored by me... which I
realize I forgot to add upstream-status as well.

Back to the patches themselves, ppc-sqrt seemed to be a subset of
glibc.fix_sqrt2.patch or am I wrong? As far as shadowing I'm not sure,
I'd rather not spend time testing that, these patches are used/tested
internally.

-M

>
>
>> -M
>>
>> On Tue, Sep 18, 2012 at 5:08 PM, Matthew McClintock <msm@freescale.com> wrote:
>>> Signed-off-by: Matthew McClintock <msm@freescale.com>
>>> ---
>>>  .../eglibc/eglibc-2.16/glibc.fix_sqrt2.patch       | 1488 ++++++++++++++++++++
>>>  .../recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch |  538 -------
>>>  meta/recipes-core/eglibc/eglibc_2.16.bb            |    4 +-
>>>  3 files changed, 1490 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..e098192
>>> --- /dev/null
>>> +++ b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
>>> @@ -0,0 +1,1488 @@
>>> +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 78dc44a..a753882 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 = "r9"
>>> +PR = "r10"
>>>  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 \
>>> --
>>> 1.7.9.7
>>>
>>>
>>>
>>> _______________________________________________
>>> Openembedded-core mailing list
>>> Openembedded-core@lists.openembedded.org
>>> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core
>>
>> _______________________________________________
>> Openembedded-core mailing list
>> Openembedded-core@lists.openembedded.org
>> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core
>
> _______________________________________________
> Openembedded-core mailing list
> Openembedded-core@lists.openembedded.org
> http://lists.linuxtogo.org/cgi-bin/mailman/listinfo/openembedded-core

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[Khem Raj]

On Tue, Sep 18, 2012 at 3:23 PM, McClintock Matthew-B29882
<B29882@freescale.com> wrote:
>
> It's just renaming the patch, so it's replacing ppc-sqrt.patch with
> glibc.fix_sqrt2.patch - and these are not authored by me... which I
> realize I forgot to add upstream-status as well.
>

OK now I see. The shadowing is there. I dont like renaming the patch.
Is there any reason
why its renamed to glibc.fix_sqrt2.patch ? its easy to spot changes if
it was not renamed

> Back to the patches themselves, ppc-sqrt seemed to be a subset of
> glibc.fix_sqrt2.patch or am I wrong? As far as shadowing I'm not sure,
> I'd rather not spend time testing that, these patches are used/tested
> internally.

Thats fine

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 5:30 PM, Khem Raj <raj.khem@gmail.com> wrote:
> On Tue, Sep 18, 2012 at 3:23 PM, McClintock Matthew-B29882
> <B29882@freescale.com> wrote:
>>
>> It's just renaming the patch, so it's replacing ppc-sqrt.patch with
>> glibc.fix_sqrt2.patch - and these are not authored by me... which I
>> realize I forgot to add upstream-status as well.
>>
>
> OK now I see. The shadowing is there. I dont like renaming the patch.
> Is there any reason
> why its renamed to glibc.fix_sqrt2.patch ? its easy to spot changes if
> it was not renamed

Internal patch name. I can change it if needed. But, then I have to
track patch names differences between internal and external.

-M

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[Khem Raj]

On Tue, Sep 18, 2012 at 3:32 PM, McClintock Matthew-B29882
<B29882@freescale.com> wrote:
>
> Internal patch name. I can change it if needed. But, then I have to
> track patch names differences between internal and external.

Not that I am opposed to it but its hard to review as I said.
cant internal be changed ?

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 5:33 PM, Khem Raj <raj.khem@gmail.com> wrote:
> On Tue, Sep 18, 2012 at 3:32 PM, McClintock Matthew-B29882
> <B29882@freescale.com> wrote:
>>
>> Internal patch name. I can change it if needed. But, then I have to
>> track patch names differences between internal and external.
>
> Not that I am opposed to it but its hard to review as I said.
> cant internal be changed ?

Ha ha ha...

;)

-M

Re: [PATCH] eglibc_2.16.bb: replace patch with updated version that supportds e6500

[McClintock Matthew-B29882]

On Tue, Sep 18, 2012 at 5:35 PM, Matthew McClintock <msm@freescale.com> wrote:
> On Tue, Sep 18, 2012 at 5:33 PM, Khem Raj <raj.khem@gmail.com> wrote:
>> On Tue, Sep 18, 2012 at 3:32 PM, McClintock Matthew-B29882
>> <B29882@freescale.com> wrote:
>>>
>>> Internal patch name. I can change it if needed. But, then I have to
>>> track patch names differences between internal and external.
>>
>> Not that I am opposed to it but its hard to review as I said.
>> cant internal be changed ?
>
> Ha ha ha...

Please hold off on this patch - I believe I've found some more issues
(besides the sign-off and upstream-status on the patch)

-M

>
> ;)
>
> -M