[v3] patch for Missing explicit instantiations in libstdc++

[Benjamin Kosnik <bkoz at redhat dot com>]

> I'll look at integrating your patch into what was done last night shortly.

Here's round two on this stuff. You should be down to two fails with this.



Index: include/bits/stl_threads.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_threads.h,v
retrieving revision 1.12
diff -c -p -r1.12 stl_threads.h
*** stl_threads.h	2001/12/03 19:11:00	1.12
--- stl_threads.h	2001/12/04 20:09:08
***************
*** 53,74 ****
  
  namespace std
  {
  
! // Class _Refcount_Base provides a type, _RC_t, a data member,
! // _M_ref_count, and member functions _M_incr and _M_decr, which perform
! // atomic preincrement/predecrement.  The constructor initializes 
! // _M_ref_count.
! struct _Refcount_Base
! {
!   // The type _RC_t
!   typedef size_t _RC_t;
!   
!   // The data member _M_ref_count
!    volatile _RC_t _M_ref_count;
! 
!   // Constructor
!   __gthread_mutex_t _M_ref_count_lock;
!   _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
      {
  #ifdef __GTHREAD_MUTEX_INIT
        __gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT;
--- 53,74 ----
  
  namespace std
  {
+   // Class _Refcount_Base provides a type, _RC_t, a data member,
+   // _M_ref_count, and member functions _M_incr and _M_decr, which perform
+   // atomic preincrement/predecrement.  The constructor initializes 
+   // _M_ref_count.
+   struct _Refcount_Base
+   {
+     // The type _RC_t
+     typedef size_t _RC_t;
+     
+     // The data member _M_ref_count
+     volatile _RC_t _M_ref_count;
+     
+     // Constructor
+     __gthread_mutex_t _M_ref_count_lock;
  
!     _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
      {
  #ifdef __GTHREAD_MUTEX_INIT
        __gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT;
*************** struct _Refcount_Base
*** 80,191 ****
  #endif
      }
  
!   void _M_incr() {
!     __gthread_mutex_lock(&_M_ref_count_lock);
!     ++_M_ref_count;
!     __gthread_mutex_unlock(&_M_ref_count_lock);
!   }
!   _RC_t _M_decr() {
!     __gthread_mutex_lock(&_M_ref_count_lock);
!     volatile _RC_t __tmp = --_M_ref_count;
!     __gthread_mutex_unlock(&_M_ref_count_lock);
!     return __tmp;
!   }
! };
  
! // Atomic swap on unsigned long
! // This is guaranteed to behave as though it were atomic only if all
! // possibly concurrent updates use _Atomic_swap.
! // In some cases the operation is emulated with a lock.
  #if defined (__GTHREAD_MUTEX_INIT)
! // This could be optimized to use the atomicity.h abstraction layer.
! // vyzo: simple _Atomic_swap implementation following the guidelines above
!        // We use a template here only to get a unique initialized instance.
!     template<int __dummy>
!     struct _Swap_lock_struct {
!         static __gthread_mutex_t _S_swap_lock;
!     };
  
!     template<int __dummy>
      __gthread_mutex_t
      _Swap_lock_struct<__dummy>::_S_swap_lock = __GTHREAD_MUTEX_INIT;
  
!     // This should be portable, but performance is expected
!     // to be quite awful.  This really needs platform specific
!     // code.
!     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned 
long __q) {
!         __gthread_mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
!         unsigned long __result = *__p;
!         *__p = __q;
!         __gthread_mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
!         return __result;
!     }
  #endif
  
! // Locking class.  Note that this class *does not have a constructor*.
! // It must be initialized either statically, with __STL_MUTEX_INITIALIZER,
! // or dynamically, by explicitly calling the _M_initialize member function.
! // (This is similar to the ways that a pthreads mutex can be initialized.)
! // There are explicit member functions for acquiring and releasing the 
lock.
! 
! // There is no constructor because static initialization is essential for
! // some uses, and only a class aggregate (see section 8.5.1 of the C++
! // standard) can be initialized that way.  That means we must have no
! // constructors, no base classes, no virtual functions, and no private or
! // protected members.
  
  #if !defined(__GTHREAD_MUTEX_INIT) && 
defined(__GTHREAD_MUTEX_INIT_FUNCTION)
! extern __gthread_mutex_t _GLIBCPP_mutex;
! extern __gthread_mutex_t *_GLIBCPP