Function decorations for libsupc++

[Jan Hubicka]

Hi,
this patch adds decorations to libsupc++.  I primarily wanted to decorate
std::terminate. Adding the other decorations is not going to help aplications
since all the stuff is hidden in the libsupc++ itself.  Doing so however
saves 7KB from the library size and will hopefully let us to copmile these bits
with warnings about missing flags enabled to make stuff easier to maintain.

Tested od x86_64-linux, OK?
Honza

	* eh_type.cc (__cxa_current_exception_type) Mark throw().
	* unwind-cxx.h (__cxa_get_globals, __cxa_get_globals_fast): Mark const.
	(__cxa_get_exception_ptr): Mark pure.
	(__cxa_bad_cast, __cxa_bad_typeid): Mark noreturn
	(__terminate): Makr throw ().
	* exception (terminate): Mark throw().
	(uncaught_exception): Mark pure.
	* eh_ptr.cc (_M_safe_bool_dummy): Mark throw().
	* guard.cc (__cxa_guard_abort, __cxa_guard_release): Mark throw().
	* eh_terminate.cc (__terminate, terminate): Mark throw().
	* vec.cc (__cxa_vec_cleanup): Mark throw().
	* cxxabi.h (__cxa_vec_cleanup, __cxa_guard_release, __cxa_guard_abort): Mark throw ().
	(__cxa_pure_virtual): Mark noreturn.
	(__cxa_current_exception_type): Mark throw and pure.
	* exception_ptr.h (operator ==, !=, _M_get, !, ==,
	__cxa_exception_type): Mark pure.
	(_M_safe_bool_dummy): Mark pure and const.

Index: eh_type.cc
===================================================================
--- eh_type.cc	(revision 146188)
+++ eh_type.cc	(working copy)
@@ -33,7 +33,7 @@
 // Returns the type_info for the currently handled exception [15.3/8], or
 // null if there is none.
 extern "C"
-std::type_info *__cxa_current_exception_type ()
+std::type_info *__cxa_current_exception_type () throw()
 {
   __cxa_eh_globals *globals = __cxa_get_globals ();
   __cxa_exception *header = globals->caughtExceptions;
Index: unwind-cxx.h
===================================================================
--- unwind-cxx.h	(revision 146188)
+++ unwind-cxx.h	(working copy)
@@ -148,8 +148,8 @@
 // either of the following functions.  The "fast" version assumes at least
 // one prior call of __cxa_get_globals has been made from the current
 // thread, so no initialization is necessary.
-extern "C" __cxa_eh_globals *__cxa_get_globals () throw();
-extern "C" __cxa_eh_globals *__cxa_get_globals_fast () throw();
+extern "C" __cxa_eh_globals *__cxa_get_globals () throw() __attribute__ ((const));
+extern "C" __cxa_eh_globals *__cxa_get_globals_fast () throw() __attribute__ ((const));
 
 // Allocate memory for the primary exception plus the thrown object.
 extern "C" void *__cxa_allocate_exception(std::size_t thrown_size) throw();
@@ -172,14 +172,14 @@
      __attribute__((noreturn));
 
 // Used to implement exception handlers.
-extern "C" void *__cxa_get_exception_ptr (void *) throw();
+extern "C" void *__cxa_get_exception_ptr (void *) throw() __attribute__ ((pure));
 extern "C" void *__cxa_begin_catch (void *) throw();
 extern "C" void __cxa_end_catch ();
 extern "C" void __cxa_rethrow () __attribute__((noreturn));
 
 // These facilitate code generation for recurring situations.
-extern "C" void __cxa_bad_cast ();
-extern "C" void __cxa_bad_typeid ();
+extern "C" void __cxa_bad_cast () __attribute__((noreturn));
+extern "C" void __cxa_bad_typeid () __attribute__((noreturn));
 
 // @@@ These are not directly specified by the IA-64 C++ ABI.
 
@@ -204,7 +204,7 @@
 
 // Invokes given handler, dying appropriately if the user handler was
 // so inconsiderate as to return.
-extern void __terminate(std::terminate_handler) __attribute__((noreturn));
+extern void __terminate(std::terminate_handler) throw () __attribute__((noreturn));
 extern void __unexpected(std::unexpected_handler) __attribute__((noreturn));
 
 // The current installed user handlers.
Index: exception
===================================================================
--- exception	(revision 146188)
+++ exception	(working copy)
@@ -93,7 +93,7 @@
 
   /** The runtime will call this function if %exception handling must be
    *  abandoned for any reason.  It can also be called by the user.  */
-  void terminate() __attribute__ ((__noreturn__));
+  void terminate() throw() __attribute__ ((__noreturn__));
 
   /// Takes a new handler function as an argument, returns the old function.
   unexpected_handler set_unexpected(unexpected_handler) throw();
@@ -112,7 +112,7 @@
    *  2:  "When @c uncaught_exception() is true, throwing an %exception can
    *  result in a call of @c terminate() (15.5.1)."
    */
-  bool uncaught_exception() throw();
+  bool uncaught_exception() throw() __attribute__ ((__pure__));
 
   // @} group exceptions
 } // namespace std
Index: eh_ptr.cc
===================================================================
--- eh_ptr.cc	(revision 146188)
+++ eh_ptr.cc	(working copy)
@@ -113,7 +113,7 @@
 
 
 void
-std::__exception_ptr::exception_ptr::_M_safe_bool_dummy()
+std::__exception_ptr::exception_ptr::_M_safe_bool_dummy() throw ()
 {
 }
 
Index: guard.cc
===================================================================
--- guard.cc	(revision 146188)
+++ guard.cc	(working copy)
@@ -330,7 +330,7 @@
   }
 
   extern "C"
-  void __cxa_guard_abort (__guard *g)
+  void __cxa_guard_abort (__guard *g) throw ()
   {
 #ifdef _GLIBCXX_USE_FUTEX
     // If __sync_* and futex syscall are supported, don't use any global
@@ -369,7 +369,7 @@
   }
 
   extern "C"
-  void __cxa_guard_release (__guard *g)
+  void __cxa_guard_release (__guard *g) throw ()
   {
 #ifdef _GLIBCXX_USE_FUTEX
     // If __sync_* and futex syscall are supported, don't use any global
Index: eh_terminate.cc
===================================================================
--- eh_terminate.cc	(revision 146188)
+++ eh_terminate.cc	(working copy)
@@ -32,7 +32,7 @@
 using namespace __cxxabiv1;
 
 void
-__cxxabiv1::__terminate (std::terminate_handler handler)
+__cxxabiv1::__terminate (std::terminate_handler handler) throw ()
 {
   try {
     handler ();
@@ -43,7 +43,7 @@
 }
 
 void
-std::terminate ()
+std::terminate () throw()
 {
   __terminate (__terminate_handler);
 }
Index: vec.cc
===================================================================
--- vec.cc	(revision 146188)
+++ vec.cc	(working copy)
@@ -248,7 +248,7 @@
   __cxa_vec_cleanup(void *array_address,
 		    std::size_t element_count,
 		    std::size_t element_size,
-		    __cxa_cdtor_type destructor)
+		    __cxa_cdtor_type destructor) throw()
   {
     if (destructor)
       {
Index: cxxabi.h
===================================================================
--- cxxabi.h	(revision 146188)
+++ cxxabi.h	(working copy)
@@ -100,7 +100,7 @@
   
   void 
   __cxa_vec_cleanup(void* __array_address, size_t __element_count,
-		    size_t __element_size, __cxa_cdtor_type destructor);
+		    size_t __element_size, __cxa_cdtor_type destructor) throw ();
   
   // Destruct and release array.
   void 
@@ -121,14 +121,14 @@
   __cxa_guard_acquire(__guard*);
 
   void 
-  __cxa_guard_release(__guard*);
+  __cxa_guard_release(__guard*) throw ();
 
   void 
-  __cxa_guard_abort(__guard*);
+  __cxa_guard_abort(__guard*) throw ();
 
   // Pure virtual functions.
   void
-  __cxa_pure_virtual(void);
+  __cxa_pure_virtual(void) __attribute__ ((noreturn));
 
   // Exception handling.
   void
@@ -567,7 +567,7 @@
   // Returns the type_info for the currently handled exception [15.3/8], or
   // null if there is none.
   extern "C" std::type_info*
-  __cxa_current_exception_type();
+  __cxa_current_exception_type() throw() __attribute__ ((__pure__));
 
   // A magic placeholder class that can be caught by reference
   // to recognize foreign exceptions.
Index: exception_ptr.h
===================================================================
--- exception_ptr.h	(revision 146188)
+++ exception_ptr.h	(working copy)
@@ -77,10 +77,10 @@
   namespace __exception_ptr
   {
     bool 
-    operator==(const exception_ptr&, const exception_ptr&) throw();
+    operator==(const exception_ptr&, const exception_ptr&) throw() __attribute__ ((__pure__));
 
     bool 
-    operator!=(const exception_ptr&, const exception_ptr&) throw();
+    operator!=(const exception_ptr&, const exception_ptr&) throw() __attribute__ ((__pure__));
 
     class exception_ptr
     {
@@ -91,9 +91,9 @@
       void _M_addref() throw();
       void _M_release() throw();
 
-      void *_M_get() const throw();
+      void *_M_get() const throw() __attribute__ ((__pure__));
 
-      void _M_safe_bool_dummy();
+      void _M_safe_bool_dummy() throw() __attribute__ ((__const__));
 
       friend exception_ptr std::current_exception() throw();
       friend void std::rethrow_exception(exception_ptr);
@@ -141,14 +141,14 @@
       }
 #endif
 
-      bool operator!() const throw();
+      bool operator!() const throw() __attribute__ ((__pure__));
       operator __safe_bool() const throw();
 
       friend bool 
-      operator==(const exception_ptr&, const exception_ptr&) throw();
+      operator==(const exception_ptr&, const exception_ptr&) throw() __attribute__ ((__pure__));
 
       const type_info*
-      __cxa_exception_type() const throw();
+      __cxa_exception_type() const throw() __attribute__ ((__pure__));
     };
 
   } // namespace __exception_ptr