Patchwork [v3] Use Solaris prototypes if possible (PR libstdc++-v3/1773)

login
register
mail settings
Submitter Rainer Orth
Date Aug. 9, 2011, 9:55 a.m.
Message ID <ydd39harjsq.fsf@manam.CeBiTec.Uni-Bielefeld.DE>
Download mbox | patch
Permalink /patch/109187/
State New
Headers show

Comments

Rainer Orth - Aug. 9, 2011, 9:55 a.m.
This patch is the last but one in the series to finally fix

PR libstdc++-v3/1773	__cplusplus defined to 1, should be 199711L

Again, this is almost completely Marc's work.  I've only added the
ChangeLog entry and fixed an issue found during Solaris 8 testing:

<iso/math_iso.h> only declares double abs(double) here, so we need to
cope with that.  I've moved config/os/solaris2.7 (which has been a
misnomer for some time) to solaris2.9 and introduced
config/os/solaris2.8.  I don't really like this approach because it
duplicates everything but os_defines.h.  I may introduce
__SunOS_<major>_<minor> as Studio cc/CC does, but I don't really like
that (it lets people get away with OS version tests instead of feature
tests).  If I really follow that road, I'll do a complete comparison of
gcc and cc predefines and create parity there, so it might take a bit.

I really think it would be better to handle this via autoconf instead.

Anyway, with this patch, its companion ones and the next to throw the
lever for the __cplusplus value, I've managed successfully bootstraps on
i386-pc-solaris2.{8, 9, 10, 11} without regressions.

Comments?

	Rainer


2011-08-07  Marc Glisse  <marc.glisse@normalesup.org>
	    Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

	PR libstdc++-v3/1773
	* config/os/solaris2.7: Rename to config/os/solaris2.9.
	* config/os/solaris/solaris2.9/os_defines.h
	(__CORRECT_ISO_CPP_MATH_H_PROTO1)
	(__CORRECT_ISO_CPP_STDLIB_H_PROTO)
	(__CORRECT_ISO_CPP_STRING_H_PROTO)
	(__CORRECT_ISO_CPP_WCHAR_H_PROTO): Define.
	* config/os/solaris2.8/ctype_base.h,
	config/os/solaris2.8/ctype_configure_char.cc,
	config/solaris2.8/ctype_inline.h,
	config/os/solaris2.8/os_defines.h: New files.

	* configure.host (solaris2.[89], solaris2.1[0-9]):
	Split into ...
	(solaris2.8): ... this.
	Use os/solaris/solaris2.8.
	(solaris2.9, solaris2.1[0-9]): ... and this.
	Use os/solaris/solaris2.9.

	* include/c_global/cmath (double abs(double)): Wrap in
	!__CORRECT_ISO_CPP_MATH_H_PROTO1 &&
	!__CORRECT_ISO_CPP_MATH_H_PROTO2.
	(float abs(float), long double abs(long double): Wrap in
	!__CORRECT_ISO_CPP_MATH_H_PROTO1.
	(float acos(float), long double acos(long double)): Likewise.
	(float asin(float), long double asin(long double)): Likewise.
	(float atan(float), long double atan(long double)): Likewise.
	(float atan2(float, float), long double atan2(long double, long
	double)): Likewise.
	(float ceil(float), long double ceil(long double)): Likewise.
	(float cos(float), long double cos(long double)): Likewise.
	(float cosh(float), long double cosh(long double)): Likewise.
	(float exp(float), long double exp(long double)): Likewise.
	(float fabs(float), long double fabs(long double)): Likewise.
	(float floor(float), long double floor(long double)): Likewise.
	(float fmod(float, float), long double fmod(long double, long
	double)): Likewise.
	(float frexp(float, int*), long double frexp(long double, int*)):
	Likewise.
	(float ldexp(float, int), long double ldexp(long double, int)):
	Likewise.
	(float log(float), long double log(long double)): Likewise.
	(float log10(float), long double log10(long double)): Likewise.
	(float modf(float, float*), long double modf(long double, long
	double*))): Likewise.
	(float pow(float, float), long double pow(long double, long
	double)): Likewise.
	(float sin(float), long double sin(long double)): Likewise.
	(float sinh(float), long double sinh(long double)): Likewise.
	(float sqrt(float), long double sqrt(long double)): Likewise.
	(float tan(float), long double tan(long double)): Likewise.
	(float tanh(float), long double tanh(long double)): Likewise.
	* include/c_global/cstdlib (long abs(long), ldiv_t div(long,
	long)): Wrap in !__CORRECT_ISO_CPP_STDLIB_H_PROTO.
	* include/tr1/cmath (float fabs(float), long double fabs(long
	double)): Wrap in !__CORRECT_ISO_CPP_MATH_H_PROTO1.
Marc Glisse - Aug. 18, 2011, 10:24 a.m.
On Tue, 9 Aug 2011, Rainer Orth wrote:

> This patch is the last but one in the series to finally fix
>
> PR libstdc++-v3/1773	__cplusplus defined to 1, should be 199711L

Only piece left before the switch :-)

> 	* include/c_global/cmath (double abs(double)): Wrap in
> 	!__CORRECT_ISO_CPP_MATH_H_PROTO1 &&
> 	!__CORRECT_ISO_CPP_MATH_H_PROTO2.
> 	(float abs(float), long double abs(long double): Wrap in
> 	!__CORRECT_ISO_CPP_MATH_H_PROTO1.
> 	(float acos(float), long double acos(long double)): Likewise.
[...]

I guess it would also be possible to reorder the declarations so as to 
have a single #ifdef (well, two), but then the various overloads of each 
function wouldn't be adjacent anymore.

> 	* include/tr1/cmath (float fabs(float), long double fabs(long
> 	double)): Wrap in !__CORRECT_ISO_CPP_MATH_H_PROTO1.

There is a comment:
   // Note: we deal with fabs in a special way, because an using std::fabs
   // would bring in also the overloads for complex types, which in C++0x
   // mode have a different return type.

and then it proceeds to using ::fabs and declare the float and long double 
overloads. Now on solaris, using ::fabs is going to be equivalent to using 
std::fabs. I don't know if that creates problems for the complex types, 
and in that case what can be done about it (declare fabs(double) instead 
of importing the global one?).
Paolo Carlini - Aug. 18, 2011, 10:41 a.m.
Hi,
> On Tue, 9 Aug 2011, Rainer Orth wrote:
>
>> This patch is the last but one in the series to finally fix
>>
>> PR libstdc++-v3/1773    __cplusplus defined to 1, should be 199711L
>
> Only piece left before the switch :-)
>
>>     * include/c_global/cmath (double abs(double)): Wrap in
>>     !__CORRECT_ISO_CPP_MATH_H_PROTO1 &&
>>     !__CORRECT_ISO_CPP_MATH_H_PROTO2.
>>     (float abs(float), long double abs(long double): Wrap in
>>     !__CORRECT_ISO_CPP_MATH_H_PROTO1.
>>     (float acos(float), long double acos(long double)): Likewise.
> [...]
>
> I guess it would also be possible to reorder the declarations so as to 
> have a single #ifdef (well, two), but then the various overloads of 
> each function wouldn't be adjacent anymore.
Indeed. I would say let's not re-order for now, I'll have a further look 
later on.
>>     * include/tr1/cmath (float fabs(float), long double fabs(long
>>     double)): Wrap in !__CORRECT_ISO_CPP_MATH_H_PROTO1.
>
> There is a comment:
>   // Note: we deal with fabs in a special way, because an using std::fabs
>   // would bring in also the overloads for complex types, which in C++0x
>   // mode have a different return type.
>
> and then it proceeds to using ::fabs and declare the float and long 
> double overloads. Now on solaris, using ::fabs is going to be 
> equivalent to using std::fabs. I don't know if that creates problems 
> for the complex types, and in that case what can be done about it 
> (declare fabs(double) instead of importing the global one?).
We have a testcase for that issue, see Rev 170083,  
testsuite/tr1/headers/c++200x/complex.cc. I think defining fabs(double) 
in namespace tr1 is not an option, because an actual definition vs an 
using leads to errors when the user does an using std::tr1 in the global 
namespace (a recurring issue, this one, we must be very careful). I 
think for now we have to live with a possible regression of the above 
testcase on Solaris, seems a relatively minor issue to me, nobody 
noticed the problem for *years*.

Paolo.
Marc Glisse - Aug. 18, 2011, 11:37 a.m.
On Thu, 18 Aug 2011, Paolo Carlini wrote:

> Indeed. I would say let's not re-order for now, I'll have a further look 
> later on.

Is that a "ok" for Rainer or just part of the discussion?

>>>     * include/tr1/cmath (float fabs(float), long double fabs(long
>>>     double)): Wrap in !__CORRECT_ISO_CPP_MATH_H_PROTO1.
>> 
>> There is a comment:
>>   // Note: we deal with fabs in a special way, because an using std::fabs
>>   // would bring in also the overloads for complex types, which in C++0x
>>   // mode have a different return type.
>> 
>> and then it proceeds to using ::fabs and declare the float and long double 
>> overloads. Now on solaris, using ::fabs is going to be equivalent to using 
>> std::fabs. I don't know if that creates problems for the complex types, and 
>> in that case what can be done about it (declare fabs(double) instead of 
>> importing the global one?).
> We have a testcase for that issue, see Rev 170083, 
> testsuite/tr1/headers/c++200x/complex.cc.

namespace std {
         void f();
}
using std::f;
namespace std {
         struct Complex{};
         void f(Complex){}
}
//using std::f;
namespace std {
         using ::f;
         namespace tr1 {
                 using ::f;
                 void f(std::Complex);
         }
}

The compiler doesn't complain for this. It does if I change which using is 
commented out [namespace.udecl]p11 in C++11. I just learned this rule and 
haven't thought about the consequences yet. It looks like as long as 
math.h is included before complex (and complex includes cmath so that's 
the case), the std::fabs(std::complex) overload is not imported in the 
global namespace and hence not in tr1 either. On the other hand, it means 
that the overloads in cmath for cos/sin/etc taking an integral type are 
not imported in the global namespace (so std::cos(0) works but cos(0) is 
ambiguous). Well, it seems ok for now...
Paolo Carlini - Aug. 18, 2011, 12:09 p.m.
On 08/18/2011 01:37 PM, Marc Glisse wrote:
> On Thu, 18 Aug 2011, Paolo Carlini wrote:
>
>> Indeed. I would say let's not re-order for now, I'll have a further 
>> look later on.
>
> Is that a "ok" for Rainer or just part of the discussion?
Sure. Actually the libstdc++ proper bits always were, I consider those 
more or less straightforward.
> namespace std {
>         void f();
> }
> using std::f;
> namespace std {
>         struct Complex{};
>         void f(Complex){}
> }
> //using std::f;
> namespace std {
>         using ::f;
>         namespace tr1 {
>                 using ::f;
>                 void f(std::Complex);
>         }
> }
>
> The compiler doesn't complain for this. It does if I change which 
> using is commented out [namespace.udecl]p11 in C++11. I just learned 
> this rule and haven't thought about the consequences yet. It looks 
> like as long as math.h is included before complex (and complex 
> includes cmath so that's the case), the std::fabs(std::complex) 
> overload is not imported in the global namespace and hence not in tr1 
> either. On the other hand, it means that the overloads in cmath for 
> cos/sin/etc taking an integral type are not imported in the global 
> namespace (so std::cos(0) works but cos(0) is ambiguous). Well, it 
> seems ok for now...
Thus, if I understand correctly your analysis (sorry I'm in the middle 
of something else) are we already ok? Is there something simple we 
can/should do right now to improve things (on Solaris and/or Linux)?

Thanks,
Paolo.
Marc Glisse - Aug. 18, 2011, 12:31 p.m.
On Thu, 18 Aug 2011, Paolo Carlini wrote:
> On 08/18/2011 01:37 PM, Marc Glisse wrote:
>> namespace std {
>>         void f();
>> }
>> using std::f;
>> namespace std {
>>         struct Complex{};
>>         void f(Complex){}
>> }
>> //using std::f;
>> namespace std {
>>         using ::f;
>>         namespace tr1 {
>>                 using ::f;
>>                 void f(std::Complex);
>>         }
>> }
>> 
>> The compiler doesn't complain for this. It does if I change which using is 
>> commented out [namespace.udecl]p11 in C++11. I just learned this rule and 
>> haven't thought about the consequences yet. It looks like as long as math.h 
>> is included before complex (and complex includes cmath so that's the case), 
>> the std::fabs(std::complex) overload is not imported in the global 
>> namespace and hence not in tr1 either. On the other hand, it means that the 
>> overloads in cmath for cos/sin/etc taking an integral type are not imported 
>> in the global namespace (so std::cos(0) works but cos(0) is ambiguous). 
>> Well, it seems ok for now...
> Thus, if I understand correctly your analysis (sorry I'm in the middle of 
> something else) are we already ok? Is there something simple we can/should do 
> right now to improve things (on Solaris and/or Linux)?

I think the current patch is good enough for now (cool, I am reviewing my 
own patch (improved by Rainer) ;-).

In the longer term, there is the usual idea that we could rename the 
current cmath (just taking this one as an example) to math.h, make it 
#include_next the system math.h (instead of plain #include), and have a 
trivial cmath that just includes math.h. This way all the goodness in 
cmath would already be available in math.h, conforming to D.5 (which one 
between math.h and cmath is a trivial wrapper to the other is a technical 
detail that doesn't matter if both are installed in the same directory).
Paolo Carlini - Aug. 18, 2011, 12:37 p.m.
On 08/18/2011 02:31 PM, Marc Glisse wrote:
> I think the current patch is good enough for now (cool, I am reviewing 
> my own patch (improved by Rainer) ;-).
Eh, eh. Actually you should do it more often ;)
> In the longer term, there is the usual idea that we could rename the 
> current cmath (just taking this one as an example) to math.h, make it 
> #include_next the system math.h (instead of plain #include), and have 
> a trivial cmath that just includes math.h. This way all the goodness 
> in cmath would already be available in math.h, conforming to D.5 
> (which one between math.h and cmath is a trivial wrapper to the other 
> is a technical detail that doesn't matter if both are installed in the 
> same directory).
Noted, thanks.

Paolo.
Marc Glisse - Aug. 18, 2011, 3:41 p.m.
On Thu, 18 Aug 2011, Marc Glisse wrote:

> I think the current patch is good enough for now

Actually, could someone please append to this comment in tr1/cmath:

   // Note: we deal with fabs in a special way, because an using std::fabs
   // would bring in also the overloads for complex types, which in C++0x
   // mode have a different return type.

Something like:

   // With __CORRECT_ISO_CPP_MATH_H_PROTO1, math.h imports std::fabs in the
   // global namespace after the declarations of the float / double / long
   // double overloads but before the std::complex overloads.

so we remember why it works, why it breaks if users do silly things, and 
what needs changing if another platform tries to define 
__CORRECT_ISO_CPP_MATH_H_PROTO1.

> In the longer term, there is the usual idea that we could rename the current 
> cmath (just taking this one as an example) to math.h, make it #include_next 
> the system math.h (instead of plain #include), and have a trivial cmath that 
> just includes math.h. This way all the goodness in cmath would already be 
> available in math.h, conforming to D.5 (which one between math.h and cmath is 
> a trivial wrapper to the other is a technical detail that doesn't matter if 
> both are installed in the same directory).

... and I forgot that this requires adding many lines like:
using std::thing;
in the global namespace after the declarations in namespace std.
Paolo Carlini - Aug. 18, 2011, 4:57 p.m.
Hi,
> Actually, could someone please append to this comment in tr1/cmath:
>
>   // Note: we deal with fabs in a special way, because an using std::fabs
>   // would bring in also the overloads for complex types, which in C++0x
>   // mode have a different return type.
>
> Something like:
>
>   // With __CORRECT_ISO_CPP_MATH_H_PROTO1, math.h imports std::fabs in 
> the
>   // global namespace after the declarations of the float / double / long
>   // double overloads but before the std::complex overloads.
>
> so we remember why it works, why it breaks if users do silly things, 
> and what needs changing if another platform tries to define 
> __CORRECT_ISO_CPP_MATH_H_PROTO1.

Done, thanks!

Paolo.

Patch

diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/ctype_base.h b/libstdc++-v3/config/os/solaris/solaris2.8/ctype_base.h
rename from libstdc++-v3/config/os/solaris/solaris2.7/ctype_base.h
rename to libstdc++-v3/config/os/solaris/solaris2.8/ctype_base.h
diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/ctype_configure_char.cc b/libstdc++-v3/config/os/solaris/solaris2.8/ctype_configure_char.cc
rename from libstdc++-v3/config/os/solaris/solaris2.7/ctype_configure_char.cc
rename to libstdc++-v3/config/os/solaris/solaris2.8/ctype_configure_char.cc
diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/ctype_inline.h b/libstdc++-v3/config/os/solaris/solaris2.8/ctype_inline.h
rename from libstdc++-v3/config/os/solaris/solaris2.7/ctype_inline.h
rename to libstdc++-v3/config/os/solaris/solaris2.8/ctype_inline.h
diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/os_defines.h b/libstdc++-v3/config/os/solaris/solaris2.8/os_defines.h
rename from libstdc++-v3/config/os/solaris/solaris2.7/os_defines.h
rename to libstdc++-v3/config/os/solaris/solaris2.8/os_defines.h
--- a/libstdc++-v3/config/os/solaris/solaris2.7/os_defines.h
+++ b/libstdc++-v3/config/os/solaris/solaris2.8/os_defines.h
@@ -1,6 +1,6 @@ 
-// Specific definitions for Solaris 7,8  -*- C++ -*-
+// Specific definitions for Solaris 8  -*- C++ -*-
 
-// Copyright (C) 2000, 2002, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2000, 2002, 2005, 2009, 2011 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -28,5 +28,12 @@ 
 // System-specific #define, typedefs, corrections, etc, go here.  This
 // file will come before all others.
 
+// FIXME: Autoconf if possible.
+#if __cplusplus >= 199711L
+#define __CORRECT_ISO_CPP_MATH_H_PROTO2
+#define __CORRECT_ISO_CPP_STRING_H_PROTO
+#define __CORRECT_ISO_CPP_WCHAR_H_PROTO
 #endif
 
+#endif
+
diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/ctype_base.h b/libstdc++-v3/config/os/solaris/solaris2.9/ctype_base.h
copy from libstdc++-v3/config/os/solaris/solaris2.7/ctype_base.h
copy to libstdc++-v3/config/os/solaris/solaris2.9/ctype_base.h
diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/ctype_configure_char.cc b/libstdc++-v3/config/os/solaris/solaris2.9/ctype_configure_char.cc
copy from libstdc++-v3/config/os/solaris/solaris2.7/ctype_configure_char.cc
copy to libstdc++-v3/config/os/solaris/solaris2.9/ctype_configure_char.cc
diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/ctype_inline.h b/libstdc++-v3/config/os/solaris/solaris2.9/ctype_inline.h
copy from libstdc++-v3/config/os/solaris/solaris2.7/ctype_inline.h
copy to libstdc++-v3/config/os/solaris/solaris2.9/ctype_inline.h
diff --git a/libstdc++-v3/config/os/solaris/solaris2.7/os_defines.h b/libstdc++-v3/config/os/solaris/solaris2.9/os_defines.h
copy from libstdc++-v3/config/os/solaris/solaris2.7/os_defines.h
copy to libstdc++-v3/config/os/solaris/solaris2.9/os_defines.h
--- a/libstdc++-v3/config/os/solaris/solaris2.7/os_defines.h
+++ b/libstdc++-v3/config/os/solaris/solaris2.9/os_defines.h
@@ -1,6 +1,6 @@ 
-// Specific definitions for Solaris 7,8  -*- C++ -*-
+// Specific definitions for Solaris 9+  -*- C++ -*-
 
-// Copyright (C) 2000, 2002, 2005, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2000, 2002, 2005, 2009, 2011 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -28,5 +28,13 @@ 
 // System-specific #define, typedefs, corrections, etc, go here.  This
 // file will come before all others.
 
+// FIXME: Autoconf if possible.
+#if __cplusplus >= 199711L
+#define __CORRECT_ISO_CPP_MATH_H_PROTO1
+#define __CORRECT_ISO_CPP_STDLIB_H_PROTO
+#define __CORRECT_ISO_CPP_STRING_H_PROTO
+#define __CORRECT_ISO_CPP_WCHAR_H_PROTO
 #endif
 
+#endif
+
diff --git a/libstdc++-v3/configure.host b/libstdc++-v3/configure.host
--- a/libstdc++-v3/configure.host
+++ b/libstdc++-v3/configure.host
@@ -288,8 +288,11 @@  case "${host_os}" in
     echo "Please specify the full version of Solaris, ie. solaris2.9 " 1>&2
     exit 1
     ;;
-  solaris2.[89] | solaris2.1[0-9])
-    os_include_dir="os/solaris/solaris2.7"
+  solaris2.8)
+    os_include_dir="os/solaris/solaris2.8"
+    ;;
+  solaris2.9 | solaris2.1[0-9])
+    os_include_dir="os/solaris/solaris2.9"
     ;;
   tpf)
     os_include_dir="os/tpf"
diff --git a/libstdc++-v3/include/c_global/cmath b/libstdc++-v3/include/c_global/cmath
--- a/libstdc++-v3/include/c_global/cmath
+++ b/libstdc++-v3/include/c_global/cmath
@@ -78,10 +78,14 @@  namespace std _GLIBCXX_VISIBILITY(defaul
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
+#if !defined(__CORRECT_ISO_CPP_MATH_H_PROTO1) \
+  && !defined(__CORRECT_ISO_CPP_MATH_H_PROTO2)
   inline _GLIBCXX_CONSTEXPR double
   abs(double __x)
   { return __builtin_fabs(__x); }
+#endif
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   abs(float __x)
   { return __builtin_fabsf(__x); }
@@ -89,6 +93,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   abs(long double __x)
   { return __builtin_fabsl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -99,6 +104,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::acos;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   acos(float __x)
   { return __builtin_acosf(__x); }
@@ -106,6 +112,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   acos(long double __x)
   { return __builtin_acosl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -116,6 +123,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::asin;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   asin(float __x)
   { return __builtin_asinf(__x); }
@@ -123,6 +131,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   asin(long double __x)
   { return __builtin_asinl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -133,6 +142,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::atan;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   atan(float __x)
   { return __builtin_atanf(__x); }
@@ -140,6 +150,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   atan(long double __x)
   { return __builtin_atanl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -150,6 +161,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::atan2;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   atan2(float __y, float __x)
   { return __builtin_atan2f(__y, __x); }
@@ -157,6 +169,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   atan2(long double __y, long double __x)
   { return __builtin_atan2l(__y, __x); }
+#endif
 
   template<typename _Tp, typename _Up>
     inline _GLIBCXX_CONSTEXPR
@@ -172,6 +185,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::ceil;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   ceil(float __x)
   { return __builtin_ceilf(__x); }
@@ -179,6 +193,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   ceil(long double __x)
   { return __builtin_ceill(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -189,6 +204,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::cos;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   cos(float __x)
   { return __builtin_cosf(__x); }
@@ -196,6 +212,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   cos(long double __x)
   { return __builtin_cosl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -206,6 +223,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::cosh;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   cosh(float __x)
   { return __builtin_coshf(__x); }
@@ -213,6 +231,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   cosh(long double __x)
   { return __builtin_coshl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -223,6 +242,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::exp;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   exp(float __x)
   { return __builtin_expf(__x); }
@@ -230,6 +250,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   exp(long double __x)
   { return __builtin_expl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -240,6 +261,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::fabs;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   fabs(float __x)
   { return __builtin_fabsf(__x); }
@@ -247,6 +269,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   fabs(long double __x)
   { return __builtin_fabsl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -257,6 +280,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::floor;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   floor(float __x)
   { return __builtin_floorf(__x); }
@@ -264,6 +288,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   floor(long double __x)
   { return __builtin_floorl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -274,6 +299,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::fmod;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   fmod(float __x, float __y)
   { return __builtin_fmodf(__x, __y); }
@@ -281,9 +307,11 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   fmod(long double __x, long double __y)
   { return __builtin_fmodl(__x, __y); }
+#endif
 
   using ::frexp;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   frexp(float __x, int* __exp)
   { return __builtin_frexpf(__x, __exp); }
@@ -291,6 +319,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   frexp(long double __x, int* __exp)
   { return __builtin_frexpl(__x, __exp); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -301,6 +330,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::ldexp;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   ldexp(float __x, int __exp)
   { return __builtin_ldexpf(__x, __exp); }
@@ -308,6 +338,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   ldexp(long double __x, int __exp)
   { return __builtin_ldexpl(__x, __exp); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -318,6 +349,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::log;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   log(float __x)
   { return __builtin_logf(__x); }
@@ -325,6 +357,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   log(long double __x)
   { return __builtin_logl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -335,6 +368,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::log10;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   log10(float __x)
   { return __builtin_log10f(__x); }
@@ -342,6 +376,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   log10(long double __x)
   { return __builtin_log10l(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -352,6 +387,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::modf;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   modf(float __x, float* __iptr)
   { return __builtin_modff(__x, __iptr); }
@@ -359,9 +395,11 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   modf(long double __x, long double* __iptr)
   { return __builtin_modfl(__x, __iptr); }
+#endif
 
   using ::pow;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   pow(float __x, float __y)
   { return __builtin_powf(__x, __y); }
@@ -385,6 +423,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   pow(long double __x, int __n)
   { return __builtin_powil(__x, __n); }
 #endif
+#endif
 
   template<typename _Tp, typename _Up>
     inline _GLIBCXX_CONSTEXPR
@@ -400,6 +439,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::sin;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   sin(float __x)
   { return __builtin_sinf(__x); }
@@ -407,6 +447,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   sin(long double __x)
   { return __builtin_sinl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -417,6 +458,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::sinh;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   sinh(float __x)
   { return __builtin_sinhf(__x); }
@@ -424,6 +466,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   sinh(long double __x)
   { return __builtin_sinhl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -434,6 +477,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::sqrt;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   sqrt(float __x)
   { return __builtin_sqrtf(__x); }
@@ -441,6 +485,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   sqrt(long double __x)
   { return __builtin_sqrtl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -451,6 +496,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::tan;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   tan(float __x)
   { return __builtin_tanf(__x); }
@@ -458,6 +504,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   tan(long double __x)
   { return __builtin_tanl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
@@ -468,6 +515,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   using ::tanh;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline _GLIBCXX_CONSTEXPR float
   tanh(float __x)
   { return __builtin_tanhf(__x); }
@@ -475,6 +523,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   inline _GLIBCXX_CONSTEXPR long double
   tanh(long double __x)
   { return __builtin_tanhl(__x); }
+#endif
 
   template<typename _Tp>
     inline _GLIBCXX_CONSTEXPR
diff --git a/libstdc++-v3/include/c_global/cstdlib b/libstdc++-v3/include/c_global/cstdlib
--- a/libstdc++-v3/include/c_global/cstdlib
+++ b/libstdc++-v3/include/c_global/cstdlib
@@ -1,7 +1,7 @@ 
 // -*- C++ -*- forwarding header.
 
 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008, 2009, 2010
+// 2006, 2007, 2008, 2009, 2010, 2011
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -135,11 +135,13 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   using ::wctomb;
 #endif // _GLIBCXX_USE_WCHAR_T
 
+#ifndef __CORRECT_ISO_CPP_STDLIB_H_PROTO
   inline long
   abs(long __i) { return labs(__i); }
 
   inline ldiv_t
   div(long __i, long __j) { return ldiv(__i, __j); }
+#endif
 
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
diff --git a/libstdc++-v3/include/tr1/cmath b/libstdc++-v3/include/tr1/cmath
--- a/libstdc++-v3/include/tr1/cmath
+++ b/libstdc++-v3/include/tr1/cmath
@@ -569,6 +569,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // mode have a different return type.
   using ::fabs;
 
+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1
   inline float
   fabs(float __x)
   { return __builtin_fabsf(__x); }
@@ -582,6 +583,7 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
 					   double>::__type
     fabs(_Tp __x)
     { return __builtin_fabs(__x); }
+#endif
 
   inline float
   fdim(float __x, float __y)