* [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500
@ 2012-09-28 1:33 Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 02/10] eglibc_2.16.bb: refresh ppc-sqrt_finite.patch for Freescale targets Matthew McClintock
` (9 more replies)
0 siblings, 10 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
v2: add upstream-status and signed off by to patch
.../eglibc/eglibc-2.16/glibc.fix_sqrt2.patch | 1491 ++++++++++++++++++++
.../recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch | 538 -------
meta/recipes-core/eglibc/eglibc_2.16.bb | 4 +-
3 files changed, 1493 insertions(+), 540 deletions(-)
create mode 100644 meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
delete mode 100644 meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
diff --git a/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
new file mode 100644
index 0000000..a669729
--- /dev/null
+++ b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
@@ -0,0 +1,1491 @@
+Signed-of-by: Edmar Wienskoski <edmar@freescale.com>
+Upstream-Status: Pending
+
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
+--- libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 2012-06-14 14:51:50.452001745 -0500
+@@ -0,0 +1,134 @@
++/* Double-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float two108 = 3.245185536584267269e+32;
++static const float twom54 = 5.551115123125782702e-17;
++static const float half = 0.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the actual square root and half of its reciprocal
++ simultaneously. */
++
++#ifdef __STDC__
++double
++__ieee754_sqrt (double b)
++#else
++double
++__ieee754_sqrt (b)
++ double b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++ double y, g, h, d, r;
++ ieee_double_shape_type u;
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ u.value = b;
++
++ relax_fenv_state ();
++
++ __asm__ ("frsqrte %[estimate], %[x]\n"
++ : [estimate] "=f" (y) : [x] "f" (b));
++
++ /* Following Muller et al, page 168, equation 5.20.
++
++ h goes to 1/(2*sqrt(b))
++ g goes to sqrt(b).
++
++ We need three iterations to get within 1ulp. */
++
++ /* Indicate that these can be performed prior to the branch. GCC
++ insists on sinking them below the branch, however; it seems like
++ they'd be better before the branch so that we can cover any latency
++ from storing the argument and loading its high word. Oh well. */
++
++ g = b * y;
++ h = 0.5 * y;
++
++ /* Handle small numbers by scaling. */
++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
++ return __ieee754_sqrt (b * two108) * twom54;
++
++#define FMADD(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
++
++ /* Final refinement. */
++ d = FNMSUB (g, g, b);
++
++ fesetenv_register (fe);
++ return FMADD (d, h, g);
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_wash (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
+--- libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c 2012-06-14 14:51:50.452001745 -0500
+@@ -0,0 +1,101 @@
++/* Single-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float threehalf = 1.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the reciprocal square root and use that to compute the actual
++ square root. */
++
++#ifdef __STDC__
++float
++__ieee754_sqrtf (float b)
++#else
++float
++__ieee754_sqrtf (b)
++ float b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++#define FMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ double y, x;
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ relax_fenv_state ();
++
++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
++ y = FMSUB (threehalf, b, b);
++
++ /* Initial estimate. */
++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
++
++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++
++ /* All done. */
++ fesetenv_register (fe);
++ return x * b;
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_washf (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
+--- libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c 2012-06-14 14:55:14.749001061 -0500
+@@ -0,0 +1,134 @@
++/* Double-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float two108 = 3.245185536584267269e+32;
++static const float twom54 = 5.551115123125782702e-17;
++static const float half = 0.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the actual square root and half of its reciprocal
++ simultaneously. */
++
++#ifdef __STDC__
++double
++__ieee754_sqrt (double b)
++#else
++double
++__ieee754_sqrt (b)
++ double b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++ double y, g, h, d, r;
++ ieee_double_shape_type u;
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ u.value = b;
++
++ relax_fenv_state ();
++
++ __asm__ ("frsqrte %[estimate], %[x]\n"
++ : [estimate] "=f" (y) : [x] "f" (b));
++
++ /* Following Muller et al, page 168, equation 5.20.
++
++ h goes to 1/(2*sqrt(b))
++ g goes to sqrt(b).
++
++ We need three iterations to get within 1ulp. */
++
++ /* Indicate that these can be performed prior to the branch. GCC
++ insists on sinking them below the branch, however; it seems like
++ they'd be better before the branch so that we can cover any latency
++ from storing the argument and loading its high word. Oh well. */
++
++ g = b * y;
++ h = 0.5 * y;
++
++ /* Handle small numbers by scaling. */
++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
++ return __ieee754_sqrt (b * two108) * twom54;
++
++#define FMADD(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
++
++ /* Final refinement. */
++ d = FNMSUB (g, g, b);
++
++ fesetenv_register (fe);
++ return FMADD (d, h, g);
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_wash (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
+--- libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c 2012-06-14 14:55:14.749001061 -0500
+@@ -0,0 +1,101 @@
++/* Single-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float threehalf = 1.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the reciprocal square root and use that to compute the actual
++ square root. */
++
++#ifdef __STDC__
++float
++__ieee754_sqrtf (float b)
++#else
++float
++__ieee754_sqrtf (b)
++ float b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++#define FMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ double y, x;
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ relax_fenv_state ();
++
++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
++ y = FMSUB (threehalf, b, b);
++
++ /* Initial estimate. */
++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
++
++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++
++ /* All done. */
++ fesetenv_register (fe);
++ return x * b;
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_washf (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
+--- libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c 2012-06-14 14:55:21.812002270 -0500
+@@ -0,0 +1,134 @@
++/* Double-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float two108 = 3.245185536584267269e+32;
++static const float twom54 = 5.551115123125782702e-17;
++static const float half = 0.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the actual square root and half of its reciprocal
++ simultaneously. */
++
++#ifdef __STDC__
++double
++__ieee754_sqrt (double b)
++#else
++double
++__ieee754_sqrt (b)
++ double b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++ double y, g, h, d, r;
++ ieee_double_shape_type u;
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ u.value = b;
++
++ relax_fenv_state ();
++
++ __asm__ ("frsqrte %[estimate], %[x]\n"
++ : [estimate] "=f" (y) : [x] "f" (b));
++
++ /* Following Muller et al, page 168, equation 5.20.
++
++ h goes to 1/(2*sqrt(b))
++ g goes to sqrt(b).
++
++ We need three iterations to get within 1ulp. */
++
++ /* Indicate that these can be performed prior to the branch. GCC
++ insists on sinking them below the branch, however; it seems like
++ they'd be better before the branch so that we can cover any latency
++ from storing the argument and loading its high word. Oh well. */
++
++ g = b * y;
++ h = 0.5 * y;
++
++ /* Handle small numbers by scaling. */
++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
++ return __ieee754_sqrt (b * two108) * twom54;
++
++#define FMADD(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
++
++ /* Final refinement. */
++ d = FNMSUB (g, g, b);
++
++ fesetenv_register (fe);
++ return FMADD (d, h, g);
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_wash (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
+--- libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c 2012-06-14 14:55:21.812002270 -0500
+@@ -0,0 +1,101 @@
++/* Single-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float threehalf = 1.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the reciprocal square root and use that to compute the actual
++ square root. */
++
++#ifdef __STDC__
++float
++__ieee754_sqrtf (float b)
++#else
++float
++__ieee754_sqrtf (b)
++ float b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++#define FMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ double y, x;
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ relax_fenv_state ();
++
++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
++ y = FMSUB (threehalf, b, b);
++
++ /* Initial estimate. */
++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
++
++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++
++ /* All done. */
++ fesetenv_register (fe);
++ return x * b;
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_washf (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
+--- libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c 2012-06-14 14:55:24.620001266 -0500
+@@ -0,0 +1,134 @@
++/* Double-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float two108 = 3.245185536584267269e+32;
++static const float twom54 = 5.551115123125782702e-17;
++static const float half = 0.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the actual square root and half of its reciprocal
++ simultaneously. */
++
++#ifdef __STDC__
++double
++__ieee754_sqrt (double b)
++#else
++double
++__ieee754_sqrt (b)
++ double b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++ double y, g, h, d, r;
++ ieee_double_shape_type u;
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ u.value = b;
++
++ relax_fenv_state ();
++
++ __asm__ ("frsqrte %[estimate], %[x]\n"
++ : [estimate] "=f" (y) : [x] "f" (b));
++
++ /* Following Muller et al, page 168, equation 5.20.
++
++ h goes to 1/(2*sqrt(b))
++ g goes to sqrt(b).
++
++ We need three iterations to get within 1ulp. */
++
++ /* Indicate that these can be performed prior to the branch. GCC
++ insists on sinking them below the branch, however; it seems like
++ they'd be better before the branch so that we can cover any latency
++ from storing the argument and loading its high word. Oh well. */
++
++ g = b * y;
++ h = 0.5 * y;
++
++ /* Handle small numbers by scaling. */
++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
++ return __ieee754_sqrt (b * two108) * twom54;
++
++#define FMADD(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
++
++ /* Final refinement. */
++ d = FNMSUB (g, g, b);
++
++ fesetenv_register (fe);
++ return FMADD (d, h, g);
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_wash (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
+--- libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c 2012-06-14 14:55:24.620001266 -0500
+@@ -0,0 +1,101 @@
++/* Single-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float threehalf = 1.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the reciprocal square root and use that to compute the actual
++ square root. */
++
++#ifdef __STDC__
++float
++__ieee754_sqrtf (float b)
++#else
++float
++__ieee754_sqrtf (b)
++ float b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++#define FMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ double y, x;
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ relax_fenv_state ();
++
++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
++ y = FMSUB (threehalf, b, b);
++
++ /* Initial estimate. */
++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
++
++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++
++ /* All done. */
++ fesetenv_register (fe);
++ return x * b;
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_washf (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
+--- libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c 2012-06-14 14:51:50.452001745 -0500
+@@ -0,0 +1,134 @@
++/* Double-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float two108 = 3.245185536584267269e+32;
++static const float twom54 = 5.551115123125782702e-17;
++static const float half = 0.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the actual square root and half of its reciprocal
++ simultaneously. */
++
++#ifdef __STDC__
++double
++__ieee754_sqrt (double b)
++#else
++double
++__ieee754_sqrt (b)
++ double b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++ double y, g, h, d, r;
++ ieee_double_shape_type u;
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ u.value = b;
++
++ relax_fenv_state ();
++
++ __asm__ ("frsqrte %[estimate], %[x]\n"
++ : [estimate] "=f" (y) : [x] "f" (b));
++
++ /* Following Muller et al, page 168, equation 5.20.
++
++ h goes to 1/(2*sqrt(b))
++ g goes to sqrt(b).
++
++ We need three iterations to get within 1ulp. */
++
++ /* Indicate that these can be performed prior to the branch. GCC
++ insists on sinking them below the branch, however; it seems like
++ they'd be better before the branch so that we can cover any latency
++ from storing the argument and loading its high word. Oh well. */
++
++ g = b * y;
++ h = 0.5 * y;
++
++ /* Handle small numbers by scaling. */
++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
++ return __ieee754_sqrt (b * two108) * twom54;
++
++#define FMADD(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
++
++ /* Final refinement. */
++ d = FNMSUB (g, g, b);
++
++ fesetenv_register (fe);
++ return FMADD (d, h, g);
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_wash (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
+--- libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 2012-06-14 14:51:50.452001745 -0500
+@@ -0,0 +1,101 @@
++/* Single-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float threehalf = 1.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the reciprocal square root and use that to compute the actual
++ square root. */
++
++#ifdef __STDC__
++float
++__ieee754_sqrtf (float b)
++#else
++float
++__ieee754_sqrtf (b)
++ float b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++#define FMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ double y, x;
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ relax_fenv_state ();
++
++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
++ y = FMSUB (threehalf, b, b);
++
++ /* Initial estimate. */
++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
++
++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++
++ /* All done. */
++ fesetenv_register (fe);
++ return x * b;
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_washf (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
+--- libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c 2012-06-14 14:56:02.080000985 -0500
+@@ -0,0 +1,134 @@
++/* Double-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float two108 = 3.245185536584267269e+32;
++static const float twom54 = 5.551115123125782702e-17;
++static const float half = 0.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the actual square root and half of its reciprocal
++ simultaneously. */
++
++#ifdef __STDC__
++double
++__ieee754_sqrt (double b)
++#else
++double
++__ieee754_sqrt (b)
++ double b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++ double y, g, h, d, r;
++ ieee_double_shape_type u;
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ u.value = b;
++
++ relax_fenv_state ();
++
++ __asm__ ("frsqrte %[estimate], %[x]\n"
++ : [estimate] "=f" (y) : [x] "f" (b));
++
++ /* Following Muller et al, page 168, equation 5.20.
++
++ h goes to 1/(2*sqrt(b))
++ g goes to sqrt(b).
++
++ We need three iterations to get within 1ulp. */
++
++ /* Indicate that these can be performed prior to the branch. GCC
++ insists on sinking them below the branch, however; it seems like
++ they'd be better before the branch so that we can cover any latency
++ from storing the argument and loading its high word. Oh well. */
++
++ g = b * y;
++ h = 0.5 * y;
++
++ /* Handle small numbers by scaling. */
++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
++ return __ieee754_sqrt (b * two108) * twom54;
++
++#define FMADD(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ r = FNMSUB (g, h, half);
++ g = FMADD (g, r, g);
++ h = FMADD (h, r, h);
++
++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
++
++ /* Final refinement. */
++ d = FNMSUB (g, g, b);
++
++ fesetenv_register (fe);
++ return FMADD (d, h, g);
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_wash (b);
++}
+diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
+--- libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c 2012-06-14 14:56:02.080000985 -0500
+@@ -0,0 +1,101 @@
++/* Single-precision floating point square root.
++ Copyright (C) 2010 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, write to the Free
++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++ 02111-1307 USA. */
++
++#include <math.h>
++#include <math_private.h>
++#include <fenv_libc.h>
++#include <inttypes.h>
++
++#include <sysdep.h>
++#include <ldsodefs.h>
++
++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
++static const float threehalf = 1.5;
++
++/* The method is based on the descriptions in:
++
++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
++
++ We find the reciprocal square root and use that to compute the actual
++ square root. */
++
++#ifdef __STDC__
++float
++__ieee754_sqrtf (float b)
++#else
++float
++__ieee754_sqrtf (b)
++ float b;
++#endif
++{
++ if (__builtin_expect (b > 0, 1))
++ {
++#define FMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++#define FNMSUB(a_, c_, b_) \
++ ({ double __r; \
++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
++ __r;})
++
++ if (__builtin_expect (b != a_inf.value, 1))
++ {
++ double y, x;
++ fenv_t fe;
++
++ fe = fegetenv_register ();
++
++ relax_fenv_state ();
++
++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
++ y = FMSUB (threehalf, b, b);
++
++ /* Initial estimate. */
++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
++
++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++ x = x * FNMSUB (y, x * x, threehalf);
++
++ /* All done. */
++ fesetenv_register (fe);
++ return x * b;
++ }
++ }
++ else if (b < 0)
++ {
++ /* For some reason, some PowerPC32 processors don't implement
++ FE_INVALID_SQRT. */
++#ifdef FE_INVALID_SQRT
++ feraiseexcept (FE_INVALID_SQRT);
++
++ fenv_union_t u = { .fenv = fegetenv_register () };
++ if ((u.l[1] & FE_INVALID) == 0)
++#endif
++ feraiseexcept (FE_INVALID);
++ b = a_nan.value;
++ }
++ return f_washf (b);
++}
+diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
+--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies 2012-06-14 14:51:50.452001745 -0500
+@@ -0,0 +1 @@
++powerpc/powerpc32/603e/fpu
+diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
+--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies 2012-06-14 14:54:00.481000876 -0500
+@@ -0,0 +1 @@
++powerpc/powerpc32/e500mc/fpu
+diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
+--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies 2012-06-14 14:54:17.000001007 -0500
+@@ -0,0 +1 @@
++powerpc/powerpc32/e5500/fpu
+diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies
+--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies 2012-06-14 14:54:31.054001299 -0500
+@@ -0,0 +1 @@
++powerpc/powerpc32/e6500/fpu
+diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
+--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies 2012-06-14 14:51:50.453001709 -0500
+@@ -0,0 +1 @@
++powerpc/powerpc64/e5500/fpu
+diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies
+--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies 2012-06-14 14:58:14.298001288 -0500
+@@ -0,0 +1 @@
++powerpc/powerpc64/e6500/fpu
diff --git a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch b/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
deleted file mode 100644
index 203040c..0000000
--- a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
+++ /dev/null
@@ -1,538 +0,0 @@
-Upstream-Status: Pending
-
-2011-03-22 Joseph Myers <joseph@codesourcery.com>
-
- Merge from SG++ 2.11:
-
- 2010-10-05 Nathan Froyd <froydnj@codesourcery.com>
-
- Issue #9382
-
- * sysdeps/powerpc/powerpc32/603e/: New directory.
- * sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/: New directory.
- * sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/: New directory.
- * sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/: New directory.
- * sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c: Update.
- * sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c: Update.
- * sysdeps/powerpc/powerpc64/e5500/fpu/Implies: New file.
-
-Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
-===================================================================
---- /dev/null
-+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
-@@ -0,0 +1,134 @@
-+/* Double-precision floating point square root.
-+ Copyright (C) 2010 Free Software Foundation, Inc.
-+ This file is part of the GNU C Library.
-+
-+ The GNU C Library is free software; you can redistribute it and/or
-+ modify it under the terms of the GNU Lesser General Public
-+ License as published by the Free Software Foundation; either
-+ version 2.1 of the License, or (at your option) any later version.
-+
-+ The GNU C Library is distributed in the hope that it will be useful,
-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ Lesser General Public License for more details.
-+
-+ You should have received a copy of the GNU Lesser General Public
-+ License along with the GNU C Library; if not, write to the Free
-+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ 02111-1307 USA. */
-+
-+#include <math.h>
-+#include <math_private.h>
-+#include <fenv_libc.h>
-+#include <inttypes.h>
-+
-+#include <sysdep.h>
-+#include <ldsodefs.h>
-+
-+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
-+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
-+static const float two108 = 3.245185536584267269e+32;
-+static const float twom54 = 5.551115123125782702e-17;
-+static const float half = 0.5;
-+
-+/* The method is based on the descriptions in:
-+
-+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
-+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
-+
-+ We find the actual square root and half of its reciprocal
-+ simultaneously. */
-+
-+#ifdef __STDC__
-+double
-+__ieee754_sqrt (double b)
-+#else
-+double
-+__ieee754_sqrt (b)
-+ double b;
-+#endif
-+{
-+ if (__builtin_expect (b > 0, 1))
-+ {
-+ double y, g, h, d, r;
-+ ieee_double_shape_type u;
-+
-+ if (__builtin_expect (b != a_inf.value, 1))
-+ {
-+ fenv_t fe;
-+
-+ fe = fegetenv_register ();
-+
-+ u.value = b;
-+
-+ relax_fenv_state ();
-+
-+ __asm__ ("frsqrte %[estimate], %[x]\n"
-+ : [estimate] "=f" (y) : [x] "f" (b));
-+
-+ /* Following Muller et al, page 168, equation 5.20.
-+
-+ h goes to 1/(2*sqrt(b))
-+ g goes to sqrt(b).
-+
-+ We need three iterations to get within 1ulp. */
-+
-+ /* Indicate that these can be performed prior to the branch. GCC
-+ insists on sinking them below the branch, however; it seems like
-+ they'd be better before the branch so that we can cover any latency
-+ from storing the argument and loading its high word. Oh well. */
-+
-+ g = b * y;
-+ h = 0.5 * y;
-+
-+ /* Handle small numbers by scaling. */
-+ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
-+ return __ieee754_sqrt (b * two108) * twom54;
-+
-+#define FMADD(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+#define FNMSUB(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+
-+ r = FNMSUB (g, h, half);
-+ g = FMADD (g, r, g);
-+ h = FMADD (h, r, h);
-+
-+ r = FNMSUB (g, h, half);
-+ g = FMADD (g, r, g);
-+ h = FMADD (h, r, h);
-+
-+ r = FNMSUB (g, h, half);
-+ g = FMADD (g, r, g);
-+ h = FMADD (h, r, h);
-+
-+ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
-+
-+ /* Final refinement. */
-+ d = FNMSUB (g, g, b);
-+
-+ fesetenv_register (fe);
-+ return FMADD (d, h, g);
-+ }
-+ }
-+ else if (b < 0)
-+ {
-+ /* For some reason, some PowerPC32 processors don't implement
-+ FE_INVALID_SQRT. */
-+#ifdef FE_INVALID_SQRT
-+ feraiseexcept (FE_INVALID_SQRT);
-+
-+ fenv_union_t u = { .fenv = fegetenv_register () };
-+ if ((u.l[1] & FE_INVALID) == 0)
-+#endif
-+ feraiseexcept (FE_INVALID);
-+ b = a_nan.value;
-+ }
-+ return f_wash (b);
-+}
-Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
-===================================================================
---- /dev/null
-+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
-@@ -0,0 +1,101 @@
-+/* Single-precision floating point square root.
-+ Copyright (C) 2010 Free Software Foundation, Inc.
-+ This file is part of the GNU C Library.
-+
-+ The GNU C Library is free software; you can redistribute it and/or
-+ modify it under the terms of the GNU Lesser General Public
-+ License as published by the Free Software Foundation; either
-+ version 2.1 of the License, or (at your option) any later version.
-+
-+ The GNU C Library is distributed in the hope that it will be useful,
-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ Lesser General Public License for more details.
-+
-+ You should have received a copy of the GNU Lesser General Public
-+ License along with the GNU C Library; if not, write to the Free
-+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ 02111-1307 USA. */
-+
-+#include <math.h>
-+#include <math_private.h>
-+#include <fenv_libc.h>
-+#include <inttypes.h>
-+
-+#include <sysdep.h>
-+#include <ldsodefs.h>
-+
-+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
-+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
-+static const float threehalf = 1.5;
-+
-+/* The method is based on the descriptions in:
-+
-+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
-+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
-+
-+ We find the reciprocal square root and use that to compute the actual
-+ square root. */
-+
-+#ifdef __STDC__
-+float
-+__ieee754_sqrtf (float b)
-+#else
-+float
-+__ieee754_sqrtf (b)
-+ float b;
-+#endif
-+{
-+ if (__builtin_expect (b > 0, 1))
-+ {
-+#define FMSUB(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+#define FNMSUB(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+
-+ if (__builtin_expect (b != a_inf.value, 1))
-+ {
-+ double y, x;
-+ fenv_t fe;
-+
-+ fe = fegetenv_register ();
-+
-+ relax_fenv_state ();
-+
-+ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
-+ y = FMSUB (threehalf, b, b);
-+
-+ /* Initial estimate. */
-+ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
-+
-+ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
-+ x = x * FNMSUB (y, x * x, threehalf);
-+ x = x * FNMSUB (y, x * x, threehalf);
-+ x = x * FNMSUB (y, x * x, threehalf);
-+
-+ /* All done. */
-+ fesetenv_register (fe);
-+ return x * b;
-+ }
-+ }
-+ else if (b < 0)
-+ {
-+ /* For some reason, some PowerPC32 processors don't implement
-+ FE_INVALID_SQRT. */
-+#ifdef FE_INVALID_SQRT
-+ feraiseexcept (FE_INVALID_SQRT);
-+
-+ fenv_union_t u = { .fenv = fegetenv_register () };
-+ if ((u.l[1] & FE_INVALID) == 0)
-+#endif
-+ feraiseexcept (FE_INVALID);
-+ b = a_nan.value;
-+ }
-+ return f_washf (b);
-+}
-Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
-===================================================================
---- /dev/null
-+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
-@@ -0,0 +1,134 @@
-+/* Double-precision floating point square root.
-+ Copyright (C) 2010 Free Software Foundation, Inc.
-+ This file is part of the GNU C Library.
-+
-+ The GNU C Library is free software; you can redistribute it and/or
-+ modify it under the terms of the GNU Lesser General Public
-+ License as published by the Free Software Foundation; either
-+ version 2.1 of the License, or (at your option) any later version.
-+
-+ The GNU C Library is distributed in the hope that it will be useful,
-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ Lesser General Public License for more details.
-+
-+ You should have received a copy of the GNU Lesser General Public
-+ License along with the GNU C Library; if not, write to the Free
-+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ 02111-1307 USA. */
-+
-+#include <math.h>
-+#include <math_private.h>
-+#include <fenv_libc.h>
-+#include <inttypes.h>
-+
-+#include <sysdep.h>
-+#include <ldsodefs.h>
-+
-+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
-+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
-+static const float two108 = 3.245185536584267269e+32;
-+static const float twom54 = 5.551115123125782702e-17;
-+static const float half = 0.5;
-+
-+/* The method is based on the descriptions in:
-+
-+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
-+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
-+
-+ We find the actual square root and half of its reciprocal
-+ simultaneously. */
-+
-+#ifdef __STDC__
-+double
-+__ieee754_sqrt (double b)
-+#else
-+double
-+__ieee754_sqrt (b)
-+ double b;
-+#endif
-+{
-+ if (__builtin_expect (b > 0, 1))
-+ {
-+ double y, g, h, d, r;
-+ ieee_double_shape_type u;
-+
-+ if (__builtin_expect (b != a_inf.value, 1))
-+ {
-+ fenv_t fe;
-+
-+ fe = fegetenv_register ();
-+
-+ u.value = b;
-+
-+ relax_fenv_state ();
-+
-+ __asm__ ("frsqrte %[estimate], %[x]\n"
-+ : [estimate] "=f" (y) : [x] "f" (b));
-+
-+ /* Following Muller et al, page 168, equation 5.20.
-+
-+ h goes to 1/(2*sqrt(b))
-+ g goes to sqrt(b).
-+
-+ We need three iterations to get within 1ulp. */
-+
-+ /* Indicate that these can be performed prior to the branch. GCC
-+ insists on sinking them below the branch, however; it seems like
-+ they'd be better before the branch so that we can cover any latency
-+ from storing the argument and loading its high word. Oh well. */
-+
-+ g = b * y;
-+ h = 0.5 * y;
-+
-+ /* Handle small numbers by scaling. */
-+ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
-+ return __ieee754_sqrt (b * two108) * twom54;
-+
-+#define FMADD(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+#define FNMSUB(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+
-+ r = FNMSUB (g, h, half);
-+ g = FMADD (g, r, g);
-+ h = FMADD (h, r, h);
-+
-+ r = FNMSUB (g, h, half);
-+ g = FMADD (g, r, g);
-+ h = FMADD (h, r, h);
-+
-+ r = FNMSUB (g, h, half);
-+ g = FMADD (g, r, g);
-+ h = FMADD (h, r, h);
-+
-+ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
-+
-+ /* Final refinement. */
-+ d = FNMSUB (g, g, b);
-+
-+ fesetenv_register (fe);
-+ return FMADD (d, h, g);
-+ }
-+ }
-+ else if (b < 0)
-+ {
-+ /* For some reason, some PowerPC32 processors don't implement
-+ FE_INVALID_SQRT. */
-+#ifdef FE_INVALID_SQRT
-+ feraiseexcept (FE_INVALID_SQRT);
-+
-+ fenv_union_t u = { .fenv = fegetenv_register () };
-+ if ((u.l[1] & FE_INVALID) == 0)
-+#endif
-+ feraiseexcept (FE_INVALID);
-+ b = a_nan.value;
-+ }
-+ return f_wash (b);
-+}
-Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
-===================================================================
---- /dev/null
-+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
-@@ -0,0 +1,101 @@
-+/* Single-precision floating point square root.
-+ Copyright (C) 2010 Free Software Foundation, Inc.
-+ This file is part of the GNU C Library.
-+
-+ The GNU C Library is free software; you can redistribute it and/or
-+ modify it under the terms of the GNU Lesser General Public
-+ License as published by the Free Software Foundation; either
-+ version 2.1 of the License, or (at your option) any later version.
-+
-+ The GNU C Library is distributed in the hope that it will be useful,
-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ Lesser General Public License for more details.
-+
-+ You should have received a copy of the GNU Lesser General Public
-+ License along with the GNU C Library; if not, write to the Free
-+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-+ 02111-1307 USA. */
-+
-+#include <math.h>
-+#include <math_private.h>
-+#include <fenv_libc.h>
-+#include <inttypes.h>
-+
-+#include <sysdep.h>
-+#include <ldsodefs.h>
-+
-+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
-+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
-+static const float threehalf = 1.5;
-+
-+/* The method is based on the descriptions in:
-+
-+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
-+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
-+
-+ We find the reciprocal square root and use that to compute the actual
-+ square root. */
-+
-+#ifdef __STDC__
-+float
-+__ieee754_sqrtf (float b)
-+#else
-+float
-+__ieee754_sqrtf (b)
-+ float b;
-+#endif
-+{
-+ if (__builtin_expect (b > 0, 1))
-+ {
-+#define FMSUB(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+#define FNMSUB(a_, c_, b_) \
-+ ({ double __r; \
-+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
-+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
-+ __r;})
-+
-+ if (__builtin_expect (b != a_inf.value, 1))
-+ {
-+ double y, x;
-+ fenv_t fe;
-+
-+ fe = fegetenv_register ();
-+
-+ relax_fenv_state ();
-+
-+ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
-+ y = FMSUB (threehalf, b, b);
-+
-+ /* Initial estimate. */
-+ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
-+
-+ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
-+ x = x * FNMSUB (y, x * x, threehalf);
-+ x = x * FNMSUB (y, x * x, threehalf);
-+ x = x * FNMSUB (y, x * x, threehalf);
-+
-+ /* All done. */
-+ fesetenv_register (fe);
-+ return x * b;
-+ }
-+ }
-+ else if (b < 0)
-+ {
-+ /* For some reason, some PowerPC32 processors don't implement
-+ FE_INVALID_SQRT. */
-+#ifdef FE_INVALID_SQRT
-+ feraiseexcept (FE_INVALID_SQRT);
-+
-+ fenv_union_t u = { .fenv = fegetenv_register () };
-+ if ((u.l[1] & FE_INVALID) == 0)
-+#endif
-+ feraiseexcept (FE_INVALID);
-+ b = a_nan.value;
-+ }
-+ return f_washf (b);
-+}
-Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
-===================================================================
---- /dev/null
-+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
-@@ -0,0 +1 @@
-+powerpc/powerpc32/603e/fpu
-Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/fpu/Implies
-===================================================================
---- /dev/null
-+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/fpu/Implies
-@@ -0,0 +1 @@
-+powerpc/powerpc32/603e/fpu
-Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
-===================================================================
---- /dev/null
-+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
-@@ -0,0 +1 @@
-+powerpc/powerpc32/603e/fpu
-Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
-===================================================================
---- /dev/null
-+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
-@@ -0,0 +1 @@
-+powerpc/powerpc64/e5500/fpu
-Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
-===================================================================
---- /dev/null
-+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
-@@ -0,0 +1 @@
-+powerpc/powerpc32/603e/fpu
diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
index 72d134a..c97a792 100644
--- a/meta/recipes-core/eglibc/eglibc_2.16.bb
+++ b/meta/recipes-core/eglibc/eglibc_2.16.bb
@@ -3,7 +3,7 @@ require eglibc.inc
SRCREV = "20393"
DEPENDS += "gperf-native kconfig-frontends-native"
-PR = "r10"
+PR = "r11"
PR_append = "+svnr${SRCPV}"
EGLIBC_BRANCH="eglibc-2_16"
@@ -13,7 +13,7 @@ SRC_URI = "svn://www.eglibc.org/svn/branches/;module=${EGLIBC_BRANCH};protocol=h
file://mips-rld-map-check.patch \
file://etc/ld.so.conf \
file://generate-supported.mk \
- file://ppc-sqrt.patch \
+ file://glibc.fix_sqrt2.patch \
file://multilib_readlib.patch \
file://use-sysroot-cxx-headers.patch \
file://ppc-sqrt_finite.patch \
--
1.7.9.7
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 02/10] eglibc_2.16.bb: refresh ppc-sqrt_finite.patch for Freescale targets
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 03/10] eglibc_2.16.bb: refresh ppc_slow_ieee754_sqrt.patch " Matthew McClintock
` (8 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
v2: add the current changes for the new arches here as well
.../eglibc/eglibc-2.16/ppc-sqrt_finite.patch | 104 +++++++++++++++++---
meta/recipes-core/eglibc/eglibc_2.16.bb | 2 +-
2 files changed, 89 insertions(+), 17 deletions(-)
diff --git a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt_finite.patch b/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt_finite.patch
index 5289051..6ea666b 100644
--- a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt_finite.patch
+++ b/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt_finite.patch
@@ -16,9 +16,9 @@ ChangeLog
Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
===================================================================
---- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 2012-01-06 18:07:42.296909187 -0800
-+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 2012-01-06 18:09:22.572914856 -0800
-@@ -39,14 +39,8 @@
+--- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
+@@ -39,14 +39,8 @@ static const float half = 0.5;
We find the actual square root and half of its reciprocal
simultaneously. */
@@ -33,16 +33,16 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
{
if (__builtin_expect (b > 0, 1))
{
-@@ -132,3 +126,4 @@
+@@ -132,3 +126,4 @@ __ieee754_sqrt (b)
}
return f_wash (b);
}
+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-01-06 18:10:37.068917644 -0800
-+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c 2012-01-06 18:11:33.408920635 -0800
-@@ -37,14 +37,8 @@
+--- libc.orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
+@@ -37,14 +37,8 @@ static const float threehalf = 1.5;
We find the reciprocal square root and use that to compute the actual
square root. */
@@ -57,16 +57,16 @@ Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
{
if (__builtin_expect (b > 0, 1))
{
-@@ -99,3 +93,4 @@
+@@ -99,3 +93,4 @@ __ieee754_sqrtf (b)
}
return f_washf (b);
}
+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-01-06 18:11:51.460925644 -0800
-+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c 2012-01-06 18:12:39.344924405 -0800
-@@ -39,14 +39,8 @@
+--- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
+@@ -39,14 +39,8 @@ static const float half = 0.5;
We find the actual square root and half of its reciprocal
simultaneously. */
@@ -81,16 +81,16 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
{
if (__builtin_expect (b > 0, 1))
{
-@@ -132,3 +126,4 @@
+@@ -132,3 +126,4 @@ __ieee754_sqrt (b)
}
return f_wash (b);
}
+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-01-06 18:13:00.892924586 -0800
-+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 2012-01-06 18:15:27.992931106 -0800
-@@ -37,14 +37,8 @@
+--- libc.orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
+@@ -37,14 +37,8 @@ static const float threehalf = 1.5;
We find the reciprocal square root and use that to compute the actual
square root. */
@@ -105,7 +105,79 @@ Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
{
if (__builtin_expect (b > 0, 1))
{
-@@ -99,3 +93,4 @@
+@@ -99,3 +93,4 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
+@@ -132,3 +132,4 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++strong_alias (__ieee754_sqrt, __sqrt_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
+@@ -99,3 +99,4 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
+@@ -132,3 +132,4 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++strong_alias (__ieee754_sqrt, __sqrt_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
+@@ -99,3 +99,4 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++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
+@@ -132,3 +132,4 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++strong_alias (__ieee754_sqrt, __sqrt_finite)
+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
+@@ -99,3 +99,4 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
+@@ -132,3 +132,4 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++strong_alias (__ieee754_sqrt, __sqrt_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
+@@ -99,3 +99,4 @@ __ieee754_sqrtf (b)
}
return f_washf (b);
}
diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
index c97a792..b7f297f 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 = "r11"
+PR = "r12"
PR_append = "+svnr${SRCPV}"
EGLIBC_BRANCH="eglibc-2_16"
--
1.7.9.7
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 03/10] eglibc_2.16.bb: refresh ppc_slow_ieee754_sqrt.patch for Freescale targets
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 02/10] eglibc_2.16.bb: refresh ppc-sqrt_finite.patch for Freescale targets Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 04/10] eglibc_2.16.bb: refresh fsl-ppc-no-fsqrt.patch " Matthew McClintock
` (7 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Make same changes for e6500 fpu as done with others
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
v2: refresh patch for other new arches that were added by the previous commit
which was causing new build errors
.../eglibc/eglibc-2.16/ppc_slow_ieee754_sqrt.patch | 278 ++++++++++++++++++--
meta/recipes-core/eglibc/eglibc_2.16.bb | 2 +-
2 files changed, 261 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..60532cb 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,11 @@ __ieee754_sqrtf (float b)
}
return f_washf (b);
}
@@ -120,4 +120,246 @@ 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,4 +132,12 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++
++#undef __ieee754_sqrt
++double
++__ieee754_sqrt (double x)
++{
++ return __slow_ieee754_sqrt (x);
++}
++
+ strong_alias (__ieee754_sqrt, __sqrt_finite)
+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,4 +99,12 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++
++#undef __ieee754_sqrtf
++float
++__ieee754_sqrtf (float x)
++{
++ return __slow_ieee754_sqrtf (x);
++}
++
+ strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/e500mc/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,4 +132,12 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++
++#undef __ieee754_sqrt
++double
++__ieee754_sqrt (double x)
++{
++ return __slow_ieee754_sqrt (x);
++}
++
+ strong_alias (__ieee754_sqrt, __sqrt_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/e500mc/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,4 +99,12 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++
++#undef __ieee754_sqrtf
++float
++__ieee754_sqrtf (float x)
++{
++ return __slow_ieee754_sqrtf (x);
++}
++
+ strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/e5500/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,4 +132,12 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++
++#undef __ieee754_sqrt
++double
++__ieee754_sqrt (double x)
++{
++ return __slow_ieee754_sqrt (x);
++}
++
+ strong_alias (__ieee754_sqrt, __sqrt_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/e5500/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,4 +99,12 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++
++#undef __ieee754_sqrtf
++float
++__ieee754_sqrtf (float x)
++{
++ return __slow_ieee754_sqrtf (x);
++}
++
+ strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
+@@ -132,4 +132,12 @@ __ieee754_sqrt (b)
+ }
+ return f_wash (b);
+ }
++
++#undef __ieee754_sqrt
++double
++__ieee754_sqrt (double x)
++{
++ return __slow_ieee754_sqrt (x);
++}
++
+ strong_alias (__ieee754_sqrt, __sqrt_finite)
+Index: libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
+===================================================================
+--- libc.orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
+@@ -99,4 +99,12 @@ __ieee754_sqrtf (b)
+ }
+ return f_washf (b);
+ }
++
++#undef __ieee754_sqrtf
++float
++__ieee754_sqrtf (float x)
++{
++ return __slow_ieee754_sqrtf (x);
++}
++
strong_alias (__ieee754_sqrtf, __sqrtf_finite)
diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
index b7f297f..5d88831 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 = "r12"
+PR = "r13"
PR_append = "+svnr${SRCPV}"
EGLIBC_BRANCH="eglibc-2_16"
--
1.7.9.7
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 04/10] eglibc_2.16.bb: refresh fsl-ppc-no-fsqrt.patch for Freescale targets
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 02/10] eglibc_2.16.bb: refresh ppc-sqrt_finite.patch for Freescale targets Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 03/10] eglibc_2.16.bb: refresh ppc_slow_ieee754_sqrt.patch " Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 05/10] arch-powerpc.inc: add altivec as a valid tune feature Matthew McClintock
` (6 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
v2: refresh for all Freescale targets, and fix mixup between
single and double precision
.../eglibc/eglibc-2.16/fsl-ppc-no-fsqrt.patch | 50 ++++++++++++++++++--
meta/recipes-core/eglibc/eglibc_2.16.bb | 2 +-
2 files changed, 47 insertions(+), 5 deletions(-)
diff --git a/meta/recipes-core/eglibc/eglibc-2.16/fsl-ppc-no-fsqrt.patch b/meta/recipes-core/eglibc/eglibc-2.16/fsl-ppc-no-fsqrt.patch
index 712b353..f619f08 100644
--- a/meta/recipes-core/eglibc/eglibc-2.16/fsl-ppc-no-fsqrt.patch
+++ b/meta/recipes-core/eglibc/eglibc-2.16/fsl-ppc-no-fsqrt.patch
@@ -9,8 +9,8 @@ Upstream-Status: Pending
Index: libc/sysdeps/powerpc/fpu/math_private.h
===================================================================
---- libc.orig/sysdeps/powerpc/fpu/math_private.h 2012-09-03 22:37:58.000000000 -0700
-+++ libc/sysdeps/powerpc/fpu/math_private.h 2012-09-17 09:35:09.709124003 -0700
+--- libc.orig/sysdeps/powerpc/fpu/math_private.h
++++ libc/sysdeps/powerpc/fpu/math_private.h
@@ -25,10 +25,12 @@
#include <dl-procinfo.h>
#include_next <math_private.h>
@@ -30,8 +30,50 @@ Index: libc/sysdeps/powerpc/fpu/math_private.h
extern double __slow_ieee754_sqrt (double);
Index: libc/ports/sysdeps/powerpc/powerpc64/e5500/fpu/math_private.h
===================================================================
---- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ libc/ports/sysdeps/powerpc/powerpc64/e5500/fpu/math_private.h 2012-09-17 09:56:59.129124074 -0700
+--- /dev/null
++++ libc/ports/sysdeps/powerpc/powerpc64/e5500/fpu/math_private.h
+@@ -0,0 +1,9 @@
++#ifndef _E5500_MATH_PRIVATE_H_
++#define _E5500_MATH_PRIVATE_H_ 1
++/* E5500 core FPU does not implement
++ fsqrt */
++
++#define __CPU_HAS_FSQRT 0
++#include_next <math_private.h>
++
++#endif /* _E5500_MATH_PRIVATE_H_ */
+Index: libc/ports/sysdeps/powerpc/powerpc64/e6500/fpu/math_private.h
+===================================================================
+--- /dev/null
++++ libc/ports/sysdeps/powerpc/powerpc64/e6500/fpu/math_private.h
+@@ -0,0 +1,9 @@
++#ifndef _E6500_MATH_PRIVATE_H_
++#define _E6500_MATH_PRIVATE_H_ 1
++/* E6500 core FPU does not implement
++ fsqrt */
++
++#define __CPU_HAS_FSQRT 0
++#include_next <math_private.h>
++
++#endif /* _E6500_MATH_PRIVATE_H_ */
+Index: libc/ports/sysdeps/powerpc/powerpc32/e500mc/fpu/math_private.h
+===================================================================
+--- /dev/null
++++ libc/ports/sysdeps/powerpc/powerpc32/e500mc/fpu/math_private.h
+@@ -0,0 +1,9 @@
++#ifndef _E500MC_MATH_PRIVATE_H_
++#define _E500MC_MATH_PRIVATE_H_ 1
++/* E500MC core FPU does not implement
++ fsqrt */
++
++#define __CPU_HAS_FSQRT 0
++#include_next <math_private.h>
++
++#endif /* _E500MC_MATH_PRIVATE_H_ */
+Index: libc/ports/sysdeps/powerpc/powerpc32/e5500/fpu/math_private.h
+===================================================================
+--- /dev/null
++++ libc/ports/sysdeps/powerpc/powerpc32/e5500/fpu/math_private.h
@@ -0,0 +1,9 @@
+#ifndef _E5500_MATH_PRIVATE_H_
+#define _E5500_MATH_PRIVATE_H_ 1
diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
index 5d88831..a0824cd 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 = "r13"
+PR = "r14"
PR_append = "+svnr${SRCPV}"
EGLIBC_BRANCH="eglibc-2_16"
--
1.7.9.7
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 05/10] arch-powerpc.inc: add altivec as a valid tune feature
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
` (2 preceding siblings ...)
2012-09-28 1:33 ` [PATCH v2 04/10] eglibc_2.16.bb: refresh fsl-ppc-no-fsqrt.patch " Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 06/10] tune-ppce6500.inc: add e6500 tune files Matthew McClintock
` (5 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
v2: no changes
This patch and the others should fix Yocto bug #3072
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
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 06/10] tune-ppce6500.inc: add e6500 tune files
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
` (3 preceding siblings ...)
2012-09-28 1:33 ` [PATCH v2 05/10] arch-powerpc.inc: add altivec as a valid tune feature Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 07/10] flac_1.2.1.bb: use TUNE_FEATURES to enable/disable altivec Matthew McClintock
` (4 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Also supports a new altivec TUNE_FEATURE
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
v2: no changes
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
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 07/10] flac_1.2.1.bb: use TUNE_FEATURES to enable/disable altivec
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
` (4 preceding siblings ...)
2012-09-28 1:33 ` [PATCH v2 06/10] tune-ppce6500.inc: add e6500 tune files Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 08/10] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe Matthew McClintock
` (3 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
v2: no changes
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
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 08/10] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
` (5 preceding siblings ...)
2012-09-28 1:33 ` [PATCH v2 07/10] flac_1.2.1.bb: use TUNE_FEATURES to enable/disable altivec Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE Matthew McClintock
` (2 subsequent siblings)
9 siblings, 0 replies; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
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?
Should we use some variable for this instead?
-BUILD_64BIT_KERNEL? PROMOTE_TO_64BIT_KERNEL?
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 1fb8970..173b71f 100644
--- a/meta/classes/insane.bbclass
+++ b/meta/classes/insane.bbclass
@@ -402,11 +402,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
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
` (6 preceding siblings ...)
2012-09-28 1:33 ` [PATCH v2 08/10] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 10:32 ` Richard Purdie
2012-09-28 1:33 ` [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros Matthew McClintock
2012-10-02 14:53 ` [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Saul Wold
9 siblings, 1 reply; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
binutils will build differently if this feature is enabled, so
make the do_configure step depend on it
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
Not sure if we should try to fix via configure options
v2: update commit message a bit
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
^ permalink raw reply related [flat|nested] 19+ messages in thread
* [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
` (7 preceding siblings ...)
2012-09-28 1:33 ` [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE Matthew McClintock
@ 2012-09-28 1:33 ` Matthew McClintock
2012-09-28 14:52 ` Burton, Ross
2012-10-02 14:53 ` [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Saul Wold
9 siblings, 1 reply; 19+ messages in thread
From: Matthew McClintock @ 2012-09-28 1:33 UTC (permalink / raw)
To: openembedded-core
Fixes these sorts of issues present on older gcc (CentOS 5.x in this case)
| cc1: error: unrecognized command line option "-Werror=implicit"
| cc1: error: unrecognized command line option "-Werror=nonnull"
| cc1: error: unrecognized command line option "-Werror=init-self"
| cc1: error: unrecognized command line option "-Werror=main"
| cc1: error: unrecognized command line option "-Werror=missing-braces"
| cc1: error: unrecognized command line option "-Werror=sequence-point"
| cc1: error: unrecognized command line option "-Werror=return-type"
| cc1: error: unrecognized command line option "-Werror=trigraphs"
| cc1: error: unrecognized command line option "-Werror=array-bounds"
| cc1: error: unrecognized command line option "-Werror=write-strings"
| cc1: error: unrecognized command line option "-Werror=address"
| cc1: error: unrecognized command line option "-Werror=int-to-pointer-cast"
| cc1: error: unrecognized command line option "-Werror=pointer-to-int-cast"
Also fixes:
makekeys-makekeys.o: In function `main':
makekeys.c:(.text+0x85): undefined reference to `__isoc99_sscanf'
makekeys.c:(.text+0xa7): undefined reference to `__isoc99_sscanf'
collect2: ld returned 1 exit status
make: *** [makekeys] Error 1
Older libc do not have this defined, we can use the -D_GNU_SOURCE
to the compiler to prevent generating calls to this function and
make linking work
Signed-off-by: Matthew McClintock <msm@freescale.com>
---
This replaces the previous patch series that fixes libx11 issues
meta/recipes-graphics/xorg-lib/libx11.inc | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/meta/recipes-graphics/xorg-lib/libx11.inc b/meta/recipes-graphics/xorg-lib/libx11.inc
index 3ecd9e5..97bd1c2 100644
--- a/meta/recipes-graphics/xorg-lib/libx11.inc
+++ b/meta/recipes-graphics/xorg-lib/libx11.inc
@@ -11,7 +11,7 @@ inherit siteinfo
FILESPATH = "${FILE_DIRNAME}/libx11"
PE = "1"
-INC_PR = "r8"
+INC_PR = "r9"
PROVIDES = "virtual/libx11"
@@ -23,6 +23,7 @@ DEPENDS += "xproto xextproto xtrans libxcb kbproto inputproto"
DEPENDS += "xproto-native"
EXTRA_OECONF += "--with-keysymdefdir=${STAGING_INCDIR}/X11/"
+EXTRA_OEMAKE += 'CWARNFLAGS=""'
# Let people with incredibly archaic requirements enable Xcms and BigFont, but
# disable them by default.
@@ -33,7 +34,7 @@ PACKAGECONFIG[bigfont] = "--enable-xf86bigfont,--disable-xf86bigfont,xf86bigfont
# src/util/makekeys needs to be compiled natively, so tell it what compiler to
# use.
export CC_FOR_BUILD = "${BUILD_CC}"
-export CFLAGS_FOR_BUILD = "${BUILD_CFLAGS}"
+export CFLAGS_FOR_BUILD = "${BUILD_CFLAGS} -D_GNU_SOURCE"
export CPPFLAGS_FOR_BUILD = "${BUILD_CPPFLAGS}"
export LDFLAGS_FOR_BUILD = "${BUILD_LDFLAGS}"
--
1.7.9.7
^ permalink raw reply related [flat|nested] 19+ messages in thread
* Re: [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE
2012-09-28 1:33 ` [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE Matthew McClintock
@ 2012-09-28 10:32 ` Richard Purdie
2012-09-28 15:07 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNedwk-YhQLgJXf7Jffm7DDR0A49fg-T0imC90x-EJS98A@mail.gmail.com>
0 siblings, 2 replies; 19+ messages in thread
From: Richard Purdie @ 2012-09-28 10:32 UTC (permalink / raw)
To: Matthew McClintock; +Cc: openembedded-core
On Thu, 2012-09-27 at 20:33 -0500, Matthew McClintock wrote:
> binutils will build differently if this feature is enabled, so
> make the do_configure step depend on it
>
> Signed-off-by: Matthew McClintock <msm@freescale.com>
> ---
> Not sure if we should try to fix via configure options
>
> v2: update commit message a bit
>
> 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
This doesn't make sense. oe_runconf should depend on EXTRA_OECONF and
that should depend on DISTRO_FEATURES so the dependency should already
exist?
Cheers,
Richard
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros
2012-09-28 1:33 ` [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros Matthew McClintock
@ 2012-09-28 14:52 ` Burton, Ross
2012-09-28 14:57 ` Burton, Ross
` (2 more replies)
0 siblings, 3 replies; 19+ messages in thread
From: Burton, Ross @ 2012-09-28 14:52 UTC (permalink / raw)
To: Matthew McClintock; +Cc: openembedded-core
On 28 September 2012 02:33, Matthew McClintock <msm@freescale.com> wrote:
> Fixes these sorts of issues present on older gcc (CentOS 5.x in this case)
>
> | cc1: error: unrecognized command line option "-Werror=implicit"
> | cc1: error: unrecognized command line option "-Werror=nonnull"
Took me a minute to realise why this happens. This happens when
cross-building because although configure is checking that the flags
it uses are supported by the compiler, it's only doing that for the
cross and not the host compiler. Right?
(upstream bug alert)
Ross
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros
2012-09-28 14:52 ` Burton, Ross
@ 2012-09-28 14:57 ` Burton, Ross
2012-09-28 15:03 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNeVxSgoZR6jQyEQ16P-_b+1_AQPcpFqcO5NPr=j8SkDVQ@mail.gmail.com>
2 siblings, 0 replies; 19+ messages in thread
From: Burton, Ross @ 2012-09-28 14:57 UTC (permalink / raw)
To: Matthew McClintock; +Cc: openembedded-core
FWIW, I've just filed #55423 and #55424 upstream for these issues.
Ross
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros
2012-09-28 14:52 ` Burton, Ross
2012-09-28 14:57 ` Burton, Ross
@ 2012-09-28 15:03 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNeVxSgoZR6jQyEQ16P-_b+1_AQPcpFqcO5NPr=j8SkDVQ@mail.gmail.com>
2 siblings, 0 replies; 19+ messages in thread
From: McClintock Matthew-B29882 @ 2012-09-28 15:03 UTC (permalink / raw)
To: Burton, Ross; +Cc: openembedded-core@lists.openembedded.org
On Fri, Sep 28, 2012 at 9:52 AM, Burton, Ross <ross.burton@intel.com> wrote:
> On 28 September 2012 02:33, Matthew McClintock <msm@freescale.com> wrote:
>> Fixes these sorts of issues present on older gcc (CentOS 5.x in this case)
>>
>> | cc1: error: unrecognized command line option "-Werror=implicit"
>> | cc1: error: unrecognized command line option "-Werror=nonnull"
>
> Took me a minute to realise why this happens. This happens when
> cross-building because although configure is checking that the flags
> it uses are supported by the compiler, it's only doing that for the
> cross and not the host compiler. Right?
>
> (upstream bug alert)
Yea, I suppose the the host compiler should be checked by autotools
if it supports these warning flags.
-M
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE
2012-09-28 10:32 ` Richard Purdie
@ 2012-09-28 15:07 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNedwk-YhQLgJXf7Jffm7DDR0A49fg-T0imC90x-EJS98A@mail.gmail.com>
1 sibling, 0 replies; 19+ messages in thread
From: McClintock Matthew-B29882 @ 2012-09-28 15:07 UTC (permalink / raw)
To: Richard Purdie; +Cc: openembedded-core@lists.openembedded.org
On Fri, Sep 28, 2012 at 5:32 AM, Richard Purdie
<richard.purdie@linuxfoundation.org> wrote:
> On Thu, 2012-09-27 at 20:33 -0500, Matthew McClintock wrote:
>> binutils will build differently if this feature is enabled, so
>> make the do_configure step depend on it
>>
>> Signed-off-by: Matthew McClintock <msm@freescale.com>
>> ---
>> Not sure if we should try to fix via configure options
>>
>> v2: update commit message a bit
>>
>> 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
>
> This doesn't make sense. oe_runconf should depend on EXTRA_OECONF and
> that should depend on DISTRO_FEATURES so the dependency should already
> exist?
OK, maybe... let me just explain what I did to see an issue.
Let's say I did a build without MULTIARCH and everything went fine.
Then I went back and added mutliarch. binutils would not rebuild with
the new features and things would break. With this patch, after added
multiarch binutils would rebuild and the the build work OK.
As you say though, if this was an actual dep it should have rebuilt
already? Has anything changed in this area very recently?
-M
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE
[not found] ` <CAEsOVNedwk-YhQLgJXf7Jffm7DDR0A49fg-T0imC90x-EJS98A@mail.gmail.com>
@ 2012-09-28 16:15 ` McClintock Matthew-B29882
0 siblings, 0 replies; 19+ messages in thread
From: McClintock Matthew-B29882 @ 2012-09-28 16:15 UTC (permalink / raw)
To: Richard Purdie; +Cc: openembedded-core@lists.openembedded.org
On Fri, Sep 28, 2012 at 10:06 AM, Matthew McClintock <msm@freescale.com> wrote:
> On Fri, Sep 28, 2012 at 5:32 AM, Richard Purdie
> <richard.purdie@linuxfoundation.org> wrote:
>> On Thu, 2012-09-27 at 20:33 -0500, Matthew McClintock wrote:
>>> binutils will build differently if this feature is enabled, so
>>> make the do_configure step depend on it
>>>
>>> Signed-off-by: Matthew McClintock <msm@freescale.com>
>>> ---
>>> Not sure if we should try to fix via configure options
>>>
>>> v2: update commit message a bit
>>>
>>> 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
>>
>> This doesn't make sense. oe_runconf should depend on EXTRA_OECONF and
>> that should depend on DISTRO_FEATURES so the dependency should already
>> exist?
>
> OK, maybe... let me just explain what I did to see an issue.
>
> Let's say I did a build without MULTIARCH and everything went fine.
> Then I went back and added mutliarch. binutils would not rebuild with
> the new features and things would break. With this patch, after added
> multiarch binutils would rebuild and the the build work OK.
>
> As you say though, if this was an actual dep it should have rebuilt
> already? Has anything changed in this area very recently?
Looking closer it seems like EXTRA_OECONF does not do this quite right
when resolving base_contains parameters:
List of dependencies for variable EXTRA_OECONF is
set(['gettext_oeconf', 'STAGING_DIR_TARGET', 'base_contains',
'TARGET_PREFIX'])
-M
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
` (8 preceding siblings ...)
2012-09-28 1:33 ` [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros Matthew McClintock
@ 2012-10-02 14:53 ` Saul Wold
9 siblings, 0 replies; 19+ messages in thread
From: Saul Wold @ 2012-10-02 14:53 UTC (permalink / raw)
To: Matthew McClintock; +Cc: openembedded-core
Richard merged the first seven patches into OE-Core, there is some
discussion about the remaining 3.
Thanks
Sau!
On 09/27/2012 06:33 PM, Matthew McClintock wrote:
> Signed-off-by: Matthew McClintock <msm@freescale.com>
> ---
> v2: add upstream-status and signed off by to patch
>
> .../eglibc/eglibc-2.16/glibc.fix_sqrt2.patch | 1491 ++++++++++++++++++++
> .../recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch | 538 -------
> meta/recipes-core/eglibc/eglibc_2.16.bb | 4 +-
> 3 files changed, 1493 insertions(+), 540 deletions(-)
> create mode 100644 meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
> delete mode 100644 meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
>
> diff --git a/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
> new file mode 100644
> index 0000000..a669729
> --- /dev/null
> +++ b/meta/recipes-core/eglibc/eglibc-2.16/glibc.fix_sqrt2.patch
> @@ -0,0 +1,1491 @@
> +Signed-of-by: Edmar Wienskoski <edmar@freescale.com>
> +Upstream-Status: Pending
> +
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrt.c 2012-06-14 14:55:14.749001061 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e500mc/fpu/e_sqrtf.c 2012-06-14 14:55:14.749001061 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrt.c 2012-06-14 14:55:21.812002270 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e5500/fpu/e_sqrtf.c 2012-06-14 14:55:21.812002270 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrt.c 2012-06-14 14:55:24.620001266 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc32/e6500/fpu/e_sqrtf.c 2012-06-14 14:55:24.620001266 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrt.c 2012-06-14 14:56:02.080000985 -0500
> +@@ -0,0 +1,134 @@
> ++/* Double-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float two108 = 3.245185536584267269e+32;
> ++static const float twom54 = 5.551115123125782702e-17;
> ++static const float half = 0.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the actual square root and half of its reciprocal
> ++ simultaneously. */
> ++
> ++#ifdef __STDC__
> ++double
> ++__ieee754_sqrt (double b)
> ++#else
> ++double
> ++__ieee754_sqrt (b)
> ++ double b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++ double y, g, h, d, r;
> ++ ieee_double_shape_type u;
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ u.value = b;
> ++
> ++ relax_fenv_state ();
> ++
> ++ __asm__ ("frsqrte %[estimate], %[x]\n"
> ++ : [estimate] "=f" (y) : [x] "f" (b));
> ++
> ++ /* Following Muller et al, page 168, equation 5.20.
> ++
> ++ h goes to 1/(2*sqrt(b))
> ++ g goes to sqrt(b).
> ++
> ++ We need three iterations to get within 1ulp. */
> ++
> ++ /* Indicate that these can be performed prior to the branch. GCC
> ++ insists on sinking them below the branch, however; it seems like
> ++ they'd be better before the branch so that we can cover any latency
> ++ from storing the argument and loading its high word. Oh well. */
> ++
> ++ g = b * y;
> ++ h = 0.5 * y;
> ++
> ++ /* Handle small numbers by scaling. */
> ++ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> ++ return __ieee754_sqrt (b * two108) * twom54;
> ++
> ++#define FMADD(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ r = FNMSUB (g, h, half);
> ++ g = FMADD (g, r, g);
> ++ h = FMADD (h, r, h);
> ++
> ++ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> ++
> ++ /* Final refinement. */
> ++ d = FNMSUB (g, g, b);
> ++
> ++ fesetenv_register (fe);
> ++ return FMADD (d, h, g);
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_wash (b);
> ++}
> +diff -ruN libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c
> +--- libc-orig/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/powerpc/powerpc64/e6500/fpu/e_sqrtf.c 2012-06-14 14:56:02.080000985 -0500
> +@@ -0,0 +1,101 @@
> ++/* Single-precision floating point square root.
> ++ Copyright (C) 2010 Free Software Foundation, Inc.
> ++ This file is part of the GNU C Library.
> ++
> ++ The GNU C Library is free software; you can redistribute it and/or
> ++ modify it under the terms of the GNU Lesser General Public
> ++ License as published by the Free Software Foundation; either
> ++ version 2.1 of the License, or (at your option) any later version.
> ++
> ++ The GNU C Library is distributed in the hope that it will be useful,
> ++ but WITHOUT ANY WARRANTY; without even the implied warranty of
> ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> ++ Lesser General Public License for more details.
> ++
> ++ You should have received a copy of the GNU Lesser General Public
> ++ License along with the GNU C Library; if not, write to the Free
> ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> ++ 02111-1307 USA. */
> ++
> ++#include <math.h>
> ++#include <math_private.h>
> ++#include <fenv_libc.h>
> ++#include <inttypes.h>
> ++
> ++#include <sysdep.h>
> ++#include <ldsodefs.h>
> ++
> ++static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> ++static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> ++static const float threehalf = 1.5;
> ++
> ++/* The method is based on the descriptions in:
> ++
> ++ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> ++ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> ++
> ++ We find the reciprocal square root and use that to compute the actual
> ++ square root. */
> ++
> ++#ifdef __STDC__
> ++float
> ++__ieee754_sqrtf (float b)
> ++#else
> ++float
> ++__ieee754_sqrtf (b)
> ++ float b;
> ++#endif
> ++{
> ++ if (__builtin_expect (b > 0, 1))
> ++ {
> ++#define FMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++#define FNMSUB(a_, c_, b_) \
> ++ ({ double __r; \
> ++ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> ++ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> ++ __r;})
> ++
> ++ if (__builtin_expect (b != a_inf.value, 1))
> ++ {
> ++ double y, x;
> ++ fenv_t fe;
> ++
> ++ fe = fegetenv_register ();
> ++
> ++ relax_fenv_state ();
> ++
> ++ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> ++ y = FMSUB (threehalf, b, b);
> ++
> ++ /* Initial estimate. */
> ++ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> ++
> ++ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++ x = x * FNMSUB (y, x * x, threehalf);
> ++
> ++ /* All done. */
> ++ fesetenv_register (fe);
> ++ return x * b;
> ++ }
> ++ }
> ++ else if (b < 0)
> ++ {
> ++ /* For some reason, some PowerPC32 processors don't implement
> ++ FE_INVALID_SQRT. */
> ++#ifdef FE_INVALID_SQRT
> ++ feraiseexcept (FE_INVALID_SQRT);
> ++
> ++ fenv_union_t u = { .fenv = fegetenv_register () };
> ++ if ((u.l[1] & FE_INVALID) == 0)
> ++#endif
> ++ feraiseexcept (FE_INVALID);
> ++ b = a_nan.value;
> ++ }
> ++ return f_washf (b);
> ++}
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies 2012-06-14 14:51:50.452001745 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/603e/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies 2012-06-14 14:54:00.481000876 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/e500mc/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies 2012-06-14 14:54:17.000001007 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/e5500/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e6500/fpu/Implies 2012-06-14 14:54:31.054001299 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc32/e6500/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies 2012-06-14 14:51:50.453001709 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc64/e5500/fpu
> +diff -ruN libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies
> +--- libc-orig/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies 1969-12-31 18:00:00.000000000 -0600
> ++++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e6500/fpu/Implies 2012-06-14 14:58:14.298001288 -0500
> +@@ -0,0 +1 @@
> ++powerpc/powerpc64/e6500/fpu
> diff --git a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch b/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
> deleted file mode 100644
> index 203040c..0000000
> --- a/meta/recipes-core/eglibc/eglibc-2.16/ppc-sqrt.patch
> +++ /dev/null
> @@ -1,538 +0,0 @@
> -Upstream-Status: Pending
> -
> -2011-03-22 Joseph Myers <joseph@codesourcery.com>
> -
> - Merge from SG++ 2.11:
> -
> - 2010-10-05 Nathan Froyd <froydnj@codesourcery.com>
> -
> - Issue #9382
> -
> - * sysdeps/powerpc/powerpc32/603e/: New directory.
> - * sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/: New directory.
> - * sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/: New directory.
> - * sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/: New directory.
> - * sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c: Update.
> - * sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c: Update.
> - * sysdeps/powerpc/powerpc64/e5500/fpu/Implies: New file.
> -
> -Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrt.c
> -@@ -0,0 +1,134 @@
> -+/* Double-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float two108 = 3.245185536584267269e+32;
> -+static const float twom54 = 5.551115123125782702e-17;
> -+static const float half = 0.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the actual square root and half of its reciprocal
> -+ simultaneously. */
> -+
> -+#ifdef __STDC__
> -+double
> -+__ieee754_sqrt (double b)
> -+#else
> -+double
> -+__ieee754_sqrt (b)
> -+ double b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+ double y, g, h, d, r;
> -+ ieee_double_shape_type u;
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ u.value = b;
> -+
> -+ relax_fenv_state ();
> -+
> -+ __asm__ ("frsqrte %[estimate], %[x]\n"
> -+ : [estimate] "=f" (y) : [x] "f" (b));
> -+
> -+ /* Following Muller et al, page 168, equation 5.20.
> -+
> -+ h goes to 1/(2*sqrt(b))
> -+ g goes to sqrt(b).
> -+
> -+ We need three iterations to get within 1ulp. */
> -+
> -+ /* Indicate that these can be performed prior to the branch. GCC
> -+ insists on sinking them below the branch, however; it seems like
> -+ they'd be better before the branch so that we can cover any latency
> -+ from storing the argument and loading its high word. Oh well. */
> -+
> -+ g = b * y;
> -+ h = 0.5 * y;
> -+
> -+ /* Handle small numbers by scaling. */
> -+ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> -+ return __ieee754_sqrt (b * two108) * twom54;
> -+
> -+#define FMADD(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> -+
> -+ /* Final refinement. */
> -+ d = FNMSUB (g, g, b);
> -+
> -+ fesetenv_register (fe);
> -+ return FMADD (d, h, g);
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_wash (b);
> -+}
> -Index: libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc32/603e/fpu/e_sqrtf.c
> -@@ -0,0 +1,101 @@
> -+/* Single-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float threehalf = 1.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the reciprocal square root and use that to compute the actual
> -+ square root. */
> -+
> -+#ifdef __STDC__
> -+float
> -+__ieee754_sqrtf (float b)
> -+#else
> -+float
> -+__ieee754_sqrtf (b)
> -+ float b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+#define FMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ double y, x;
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ relax_fenv_state ();
> -+
> -+ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> -+ y = FMSUB (threehalf, b, b);
> -+
> -+ /* Initial estimate. */
> -+ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> -+
> -+ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+
> -+ /* All done. */
> -+ fesetenv_register (fe);
> -+ return x * b;
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_washf (b);
> -+}
> -Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrt.c
> -@@ -0,0 +1,134 @@
> -+/* Double-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float two108 = 3.245185536584267269e+32;
> -+static const float twom54 = 5.551115123125782702e-17;
> -+static const float half = 0.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the actual square root and half of its reciprocal
> -+ simultaneously. */
> -+
> -+#ifdef __STDC__
> -+double
> -+__ieee754_sqrt (double b)
> -+#else
> -+double
> -+__ieee754_sqrt (b)
> -+ double b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+ double y, g, h, d, r;
> -+ ieee_double_shape_type u;
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ u.value = b;
> -+
> -+ relax_fenv_state ();
> -+
> -+ __asm__ ("frsqrte %[estimate], %[x]\n"
> -+ : [estimate] "=f" (y) : [x] "f" (b));
> -+
> -+ /* Following Muller et al, page 168, equation 5.20.
> -+
> -+ h goes to 1/(2*sqrt(b))
> -+ g goes to sqrt(b).
> -+
> -+ We need three iterations to get within 1ulp. */
> -+
> -+ /* Indicate that these can be performed prior to the branch. GCC
> -+ insists on sinking them below the branch, however; it seems like
> -+ they'd be better before the branch so that we can cover any latency
> -+ from storing the argument and loading its high word. Oh well. */
> -+
> -+ g = b * y;
> -+ h = 0.5 * y;
> -+
> -+ /* Handle small numbers by scaling. */
> -+ if (__builtin_expect ((u.parts.msw & 0x7ff00000) <= 0x02000000, 0))
> -+ return __ieee754_sqrt (b * two108) * twom54;
> -+
> -+#define FMADD(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmadd %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ r = FNMSUB (g, h, half);
> -+ g = FMADD (g, r, g);
> -+ h = FMADD (h, r, h);
> -+
> -+ /* g is now +/- 1ulp, or exactly equal to, the square root of b. */
> -+
> -+ /* Final refinement. */
> -+ d = FNMSUB (g, g, b);
> -+
> -+ fesetenv_register (fe);
> -+ return FMADD (d, h, g);
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_wash (b);
> -+}
> -Index: libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/powerpc/powerpc64/e5500/fpu/e_sqrtf.c
> -@@ -0,0 +1,101 @@
> -+/* Single-precision floating point square root.
> -+ Copyright (C) 2010 Free Software Foundation, Inc.
> -+ This file is part of the GNU C Library.
> -+
> -+ The GNU C Library is free software; you can redistribute it and/or
> -+ modify it under the terms of the GNU Lesser General Public
> -+ License as published by the Free Software Foundation; either
> -+ version 2.1 of the License, or (at your option) any later version.
> -+
> -+ The GNU C Library is distributed in the hope that it will be useful,
> -+ but WITHOUT ANY WARRANTY; without even the implied warranty of
> -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> -+ Lesser General Public License for more details.
> -+
> -+ You should have received a copy of the GNU Lesser General Public
> -+ License along with the GNU C Library; if not, write to the Free
> -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
> -+ 02111-1307 USA. */
> -+
> -+#include <math.h>
> -+#include <math_private.h>
> -+#include <fenv_libc.h>
> -+#include <inttypes.h>
> -+
> -+#include <sysdep.h>
> -+#include <ldsodefs.h>
> -+
> -+static const ieee_float_shape_type a_nan = {.word = 0x7fc00000 };
> -+static const ieee_float_shape_type a_inf = {.word = 0x7f800000 };
> -+static const float threehalf = 1.5;
> -+
> -+/* The method is based on the descriptions in:
> -+
> -+ _The Handbook of Floating-Pointer Arithmetic_ by Muller et al., chapter 5;
> -+ _IA-64 and Elementary Functions: Speed and Precision_ by Markstein, chapter 9
> -+
> -+ We find the reciprocal square root and use that to compute the actual
> -+ square root. */
> -+
> -+#ifdef __STDC__
> -+float
> -+__ieee754_sqrtf (float b)
> -+#else
> -+float
> -+__ieee754_sqrtf (b)
> -+ float b;
> -+#endif
> -+{
> -+ if (__builtin_expect (b > 0, 1))
> -+ {
> -+#define FMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+#define FNMSUB(a_, c_, b_) \
> -+ ({ double __r; \
> -+ __asm__ ("fnmsub %[r], %[a], %[c], %[b]\n" \
> -+ : [r] "=f" (__r) : [a] "f" (a_), [c] "f" (c_), [b] "f" (b_)); \
> -+ __r;})
> -+
> -+ if (__builtin_expect (b != a_inf.value, 1))
> -+ {
> -+ double y, x;
> -+ fenv_t fe;
> -+
> -+ fe = fegetenv_register ();
> -+
> -+ relax_fenv_state ();
> -+
> -+ /* Compute y = 1.5 * b - b. Uses fewer constants than y = 0.5 * b. */
> -+ y = FMSUB (threehalf, b, b);
> -+
> -+ /* Initial estimate. */
> -+ __asm__ ("frsqrte %[x], %[b]\n" : [x] "=f" (x) : [b] "f" (b));
> -+
> -+ /* Iterate. x_{n+1} = x_n * (1.5 - y * (x_n * x_n)). */
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+ x = x * FNMSUB (y, x * x, threehalf);
> -+
> -+ /* All done. */
> -+ fesetenv_register (fe);
> -+ return x * b;
> -+ }
> -+ }
> -+ else if (b < 0)
> -+ {
> -+ /* For some reason, some PowerPC32 processors don't implement
> -+ FE_INVALID_SQRT. */
> -+#ifdef FE_INVALID_SQRT
> -+ feraiseexcept (FE_INVALID_SQRT);
> -+
> -+ fenv_union_t u = { .fenv = fegetenv_register () };
> -+ if ((u.l[1] & FE_INVALID) == 0)
> -+#endif
> -+ feraiseexcept (FE_INVALID);
> -+ b = a_nan.value;
> -+ }
> -+ return f_washf (b);
> -+}
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/603e/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/7400/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e500mc/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc64/e5500/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc64/e5500/fpu
> -Index: libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
> -===================================================================
> ---- /dev/null
> -+++ libc/sysdeps/unix/sysv/linux/powerpc/powerpc32/e5500/fpu/Implies
> -@@ -0,0 +1 @@
> -+powerpc/powerpc32/603e/fpu
> diff --git a/meta/recipes-core/eglibc/eglibc_2.16.bb b/meta/recipes-core/eglibc/eglibc_2.16.bb
> index 72d134a..c97a792 100644
> --- a/meta/recipes-core/eglibc/eglibc_2.16.bb
> +++ b/meta/recipes-core/eglibc/eglibc_2.16.bb
> @@ -3,7 +3,7 @@ require eglibc.inc
> SRCREV = "20393"
>
> DEPENDS += "gperf-native kconfig-frontends-native"
> -PR = "r10"
> +PR = "r11"
> PR_append = "+svnr${SRCPV}"
>
> EGLIBC_BRANCH="eglibc-2_16"
> @@ -13,7 +13,7 @@ SRC_URI = "svn://www.eglibc.org/svn/branches/;module=${EGLIBC_BRANCH};protocol=h
> file://mips-rld-map-check.patch \
> file://etc/ld.so.conf \
> file://generate-supported.mk \
> - file://ppc-sqrt.patch \
> + file://glibc.fix_sqrt2.patch \
> file://multilib_readlib.patch \
> file://use-sysroot-cxx-headers.patch \
> file://ppc-sqrt_finite.patch \
>
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros
[not found] ` <CAEsOVNeVxSgoZR6jQyEQ16P-_b+1_AQPcpFqcO5NPr=j8SkDVQ@mail.gmail.com>
@ 2012-10-02 15:50 ` McClintock Matthew-B29882
2012-10-02 15:54 ` Burton, Ross
0 siblings, 1 reply; 19+ messages in thread
From: McClintock Matthew-B29882 @ 2012-10-02 15:50 UTC (permalink / raw)
To: Burton, Ross; +Cc: openembedded-core@lists.openembedded.org
On Fri, Sep 28, 2012 at 10:03 AM, Matthew McClintock <msm@freescale.com> wrote:
> On Fri, Sep 28, 2012 at 9:52 AM, Burton, Ross <ross.burton@intel.com> wrote:
>> On 28 September 2012 02:33, Matthew McClintock <msm@freescale.com> wrote:
>>> Fixes these sorts of issues present on older gcc (CentOS 5.x in this case)
>>>
>>> | cc1: error: unrecognized command line option "-Werror=implicit"
>>> | cc1: error: unrecognized command line option "-Werror=nonnull"
>>
>> Took me a minute to realise why this happens. This happens when
>> cross-building because although configure is checking that the flags
>> it uses are supported by the compiler, it's only doing that for the
>> cross and not the host compiler. Right?
>>
>> (upstream bug alert)
>
> Yea, I suppose the the host compiler should be checked by autotools
> if it supports these warning flags.
Should this block applying this patch to oe-core or will there be
upstream fixes before 1.3?
-M
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros
2012-10-02 15:50 ` McClintock Matthew-B29882
@ 2012-10-02 15:54 ` Burton, Ross
0 siblings, 0 replies; 19+ messages in thread
From: Burton, Ross @ 2012-10-02 15:54 UTC (permalink / raw)
To: McClintock Matthew-B29882; +Cc: openembedded-core@lists.openembedded.org
On 2 October 2012 16:50, McClintock Matthew-B29882 <B29882@freescale.com> wrote:
>> Yea, I suppose the the host compiler should be checked by autotools
>> if it supports these warning flags.
>
> Should this block applying this patch to oe-core or will there be
> upstream fixes before 1.3?
This is the right fix for the short term, fixing upstream is more
complicated because they have the pain of Solaris to deal with.
Ross
^ permalink raw reply [flat|nested] 19+ messages in thread
end of thread, other threads:[~2012-10-02 16:07 UTC | newest]
Thread overview: 19+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2012-09-28 1:33 [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 02/10] eglibc_2.16.bb: refresh ppc-sqrt_finite.patch for Freescale targets Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 03/10] eglibc_2.16.bb: refresh ppc_slow_ieee754_sqrt.patch " Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 04/10] eglibc_2.16.bb: refresh fsl-ppc-no-fsqrt.patch " Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 05/10] arch-powerpc.inc: add altivec as a valid tune feature Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 06/10] tune-ppce6500.inc: add e6500 tune files Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 07/10] flac_1.2.1.bb: use TUNE_FEATURES to enable/disable altivec Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 08/10] insane.bbclass: skip checking arch (machine/bits) for powerpc kernel recipe Matthew McClintock
2012-09-28 1:33 ` [PATCH v2 09/10] binutils.inc: add vardep on multiarch DISTRO_FEATURE Matthew McClintock
2012-09-28 10:32 ` Richard Purdie
2012-09-28 15:07 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNedwk-YhQLgJXf7Jffm7DDR0A49fg-T0imC90x-EJS98A@mail.gmail.com>
2012-09-28 16:15 ` McClintock Matthew-B29882
2012-09-28 1:33 ` [PATCH v2 10/10] libx11.inc: fix build issues for older CentOS distros Matthew McClintock
2012-09-28 14:52 ` Burton, Ross
2012-09-28 14:57 ` Burton, Ross
2012-09-28 15:03 ` McClintock Matthew-B29882
[not found] ` <CAEsOVNeVxSgoZR6jQyEQ16P-_b+1_AQPcpFqcO5NPr=j8SkDVQ@mail.gmail.com>
2012-10-02 15:50 ` McClintock Matthew-B29882
2012-10-02 15:54 ` Burton, Ross
2012-10-02 14:53 ` [PATCH v2 01/10] eglibc_2.16.bb: replace patch with updated version that supports e6500 Saul Wold
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox