2011-01-30 Benjamin Kosnik <bkoz@redhat.com>

	PR libstdc++/36104 part four
	* include/bits/c++config (_GLIBCXX_STD): Remove.
	(_GLIBCXX_STD_D, _GLIBCXX_PR): Now _GLIBCXX_STD_C.
	(_GLIBCXX_P): Now _GLIBCXX_STD_A.
	(_GLIBCXX_NAMESPACE_DEBUG, _GLIBCXX_NAMESPACE_PARALLEL,
	 _GLIBCXX_NAMESPACE_PROFILE, _GLIBCXX_NAMESPACE_VERSION): Remove.
	(_GLIBCXX_INLINE_DEBUG, _GLIBCXX_INLINE_PARALLEL,
	 _GLIBCXX_INLINE_PROFILE): Remove.
	(_GLIBCXX_BEGIN_NAMESPACE(X)): Remove.
	(_GLIBCXX_END_NAMESPACE): Remove.
	(_GLIBCXX_BEGIN_NESTED_NAMESPACE(X, Y)): Remove.
	(_GLIBCXX_END_NESTED_NAMESPACE): Remove.
	(_GLIBCXX_BEGIN_NAMESPACE_ALGO): Add.
	(_GLIBCXX_END_NAMESPACE_ALGO): Add.
	(_GLIBCXX_BEGIN_NAMESPACE_CONTAINER): Add.
	(_GLIBCXX_END_NAMESPACE_CONTAINER): Add.
	(_GLIBCXX_BEGIN_NAMESPACE_VERSION): Add.
	(_GLIBCXX_END_NAMESPACE_VERSION): Add.
	(_GLIBCXX_BEGIN_LDBL_NAMESPACE): To _GLIBCXX_BEGIN_NAMESPACE_LDBL.
	(_GLIBCXX_END_LDBL_NAMESPACE): To _GLIBCXX_END_NAMESPACE_LDBL.
	(_GLIBCXX_VISIBILITY_ATTR): Revert to _GLIBCXX_VISIBILITY.
	* include/*: Use new macros for namespace scope.
	* config/*: Same.
	* src/*: Same.

	* src/Makefile.am (sources): Remove debug_list.cc, add
	compatibility-debug_list-2.cc.
	(parallel_sources): Remove parallel_list.cc, add
	compatibility-parallel_list-2.cc.
	(compatibility-parallel_list-2.[o,lo]): New rule.
	* src/Makefile.in: Regenerate.
	* src/debug_list.cc: Remove.
	* src/parallel_list.cc: Remove.
	* src/compatibility-list-2.cc: New.
	* src/compatibility-debug_list-2.cc: New.
	* src/compatibility-parallel_list-2.cc: New.

	* doc/doxygen/user.cfg.in: Adjust macros.

	* testsuite/20_util/auto_ptr/assign_neg.cc: Adjust line numbers, macros.
	* testsuite/20_util/declval/requirements/1_neg.cc: Same.
	* testsuite/20_util/duration/requirements/typedefs_neg1.cc: Same.
	* testsuite/20_util/duration/requirements/typedefs_neg2.cc: Same.
	* testsuite/20_util/duration/requirements/typedefs_neg3.cc: Same.
	* testsuite/20_util/forward/c_neg.cc: Same.
	* testsuite/20_util/forward/f_neg.cc: Same.
	* testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Same.
	* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc: Same.
	* testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Same.
	* testsuite/20_util/ratio/operations/ops_overflow_neg.cc: Same.
	* testsuite/20_util/shared_ptr/cons/43820_neg.cc: Same.
	* testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Same.
	* testsuite/23_containers/deque/requirements/dr438/assign_neg.cc: Same.
	* testsuite/23_containers/deque/requirements/dr438/
	constructor_1_neg.cc: Same.
	* testsuite/23_containers/deque/requirements/dr438/
	constructor_2_neg.cc: Same.
	* testsuite/23_containers/deque/requirements/dr438/insert_neg.cc: Same.
	* testsuite/23_containers/forward_list/capacity/1.cc: Same.
	* testsuite/23_containers/forward_list/requirements/dr438/
	assign_neg.cc: Same.
	* testsuite/23_containers/forward_list/requirements/dr438/
	constructor_1_neg.cc: Same.
	* testsuite/23_containers/forward_list/requirements/dr438/
	constructor_2_neg.cc: Same.
	* testsuite/23_containers/forward_list/requirements/dr438/
	insert_neg.cc: Same.
	* testsuite/23_containers/list/capacity/29134.cc: Same.
	* testsuite/23_containers/list/requirements/dr438/assign_neg.cc: Same.
	* testsuite/23_containers/list/requirements/dr438/
	constructor_1_neg.cc: Same.
	* testsuite/23_containers/list/requirements/dr438/
	constructor_2_neg.cc: Same.
	* testsuite/23_containers/list/requirements/dr438/insert_neg.cc: Same.
	* testsuite/23_containers/vector/bool/capacity/29134.cc: Same.
	* testsuite/23_containers/vector/bool/modifiers/insert/31370.cc: Same.
	* testsuite/23_containers/vector/requirements/dr438/assign_neg.cc: Same.
	* testsuite/23_containers/vector/requirements/dr438/
	constructor_1_neg.cc: Same.
	* testsuite/23_containers/vector/requirements/dr438/
	constructor_2_neg.cc: Same.
	* testsuite/23_containers/vector/requirements/dr438/insert_neg.cc: Same.
	* testsuite/25_algorithms/sort/35588.cc: Same.
	* testsuite/27_io/ios_base/cons/assign_neg.cc: Same.
	* testsuite/27_io/ios_base/cons/copy_neg.cc: Same.
	* testsuite/ext/profile/mutex_extensions_neg.cc: Same.
	* testsuite/ext/profile/profiler_algos.cc: Same.
	* testsuite/ext/type_traits/add_unsigned_floating_neg.cc: Same.
	* testsuite/ext/type_traits/add_unsigned_integer_neg.cc: Same.
	* testsuite/ext/type_traits/remove_unsigned_floating_neg.cc: Same.
	* testsuite/ext/type_traits/remove_unsigned_integer_neg.cc: Same.
	* testsuite/tr1/2_general_utilities/shared_ptr/cons/43820_neg.cc: Same.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@169421 138bc75d-0d04-0410-961f-82ee72b054a4

6 files changed, 90 insertions, 90 deletions

diff --git a/libstdc++-v3/include/parallel/algo.h b/libstdc++-v3/include/parallel/algo.h
index a24e557ad90..89b7f6d827f 100644
--- a/libstdc++-v3/include/parallel/algo.h
+++ b/libstdc++-v3/include/parallel/algo.h
@@ -58,7 +58,7 @@
 #include <parallel/unique_copy.h>
 #include <parallel/set_operations.h>
 
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __parallel
 {
@@ -67,7 +67,7 @@ namespace __parallel
     inline _Function
     for_each(_IIter __begin, _IIter __end, _Function __f, 
              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::for_each(__begin, __end, __f); }
+    { return _GLIBCXX_STD_A::for_each(__begin, __end, __f); }
 
 
   // Sequential fallback for input iterator case
@@ -130,14 +130,14 @@ namespace __parallel
     inline _IIter
     find(_IIter __begin, _IIter __end, const _Tp& __val, 
          __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::find(__begin, __end, __val); }
+    { return _GLIBCXX_STD_A::find(__begin, __end, __val); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter, typename _Tp, typename _IteratorTag>
     inline _IIter
     __find_switch(_IIter __begin, _IIter __end, const _Tp& __val,
                 _IteratorTag)
-    { return _GLIBCXX_STD_P::find(__begin, __end, __val); }
+    { return _GLIBCXX_STD_A::find(__begin, __end, __val); }
 
   // Parallel find for random access iterators
   template<typename _RAIter, typename _Tp>
@@ -157,7 +157,7 @@ namespace __parallel
                    __gnu_parallel::__find_if_selector()).first;
         }
       else
-        return _GLIBCXX_STD_P::find(__begin, __end, __val);
+        return _GLIBCXX_STD_A::find(__begin, __end, __val);
     }
 
   // Public interface
@@ -175,14 +175,14 @@ namespace __parallel
     inline _IIter
     find_if(_IIter __begin, _IIter __end, _Predicate __pred, 
             __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); }
+    { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter, typename _Predicate, typename _IteratorTag>
     inline _IIter
     __find_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, 
                    _IteratorTag)
-    { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); }
+    { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); }
 
   // Parallel find_if for random access iterators
   template<typename _RAIter, typename _Predicate>
@@ -195,7 +195,7 @@ namespace __parallel
                                              __gnu_parallel::
                                              __find_if_selector()).first;
       else
-        return _GLIBCXX_STD_P::find_if(__begin, __end, __pred);
+        return _GLIBCXX_STD_A::find_if(__begin, __end, __pred);
     }
 
   // Public interface
@@ -214,7 +214,7 @@ namespace __parallel
     find_first_of(_IIter __begin1, _IIter __end1, 
                   _FIterator __begin2, _FIterator __end2, 
                   __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::find_first_of(__begin1, __end1, __begin2, __end2);
+    { return _GLIBCXX_STD_A::find_first_of(__begin1, __end1, __begin2, __end2);
       }
 
   // Sequential fallback
@@ -224,7 +224,7 @@ namespace __parallel
     find_first_of(_IIter __begin1, _IIter __end1,
                   _FIterator __begin2, _FIterator __end2,
                   _BinaryPredicate __comp, __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::find_first_of(
+  { return _GLIBCXX_STD_A::find_first_of(
              __begin1, __end1, __begin2, __end2, __comp); }
 
   // Sequential fallback for input iterator type
@@ -301,7 +301,7 @@ namespace __parallel
     inline _OutputIterator
     unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out); }
+    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out); }
 
   // Sequential fallback
   template<typename _IIter, typename _OutputIterator,
@@ -309,7 +309,7 @@ namespace __parallel
     inline _OutputIterator
     unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
                 _Predicate __pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out, __pred); }
+    { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out, __pred); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter, typename _OutputIterator,
@@ -318,7 +318,7 @@ namespace __parallel
     __unique_copy_switch(_IIter __begin, _IIter __last, 
                        _OutputIterator __out, _Predicate __pred, 
                        _IteratorTag1, _IteratorTag2)
-    { return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred); }
+    { return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred); }
 
   // Parallel unique_copy for random access iterators
   template<typename _RAIter, typename RandomAccessOutputIterator,
@@ -334,7 +334,7 @@ namespace __parallel
         return __gnu_parallel::__parallel_unique_copy(
                  __begin, __last, __out, __pred);
       else
-        return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred);
+        return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred);
     }
 
   // Public interface
@@ -376,7 +376,7 @@ namespace __parallel
     set_union(_IIter1 __begin1, _IIter1 __end1,
               _IIter2 __begin2, _IIter2 __end2,
               _OutputIterator __out, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_union(
+    { return _GLIBCXX_STD_A::set_union(
                __begin1, __end1, __begin2, __end2, __out); }
 
   // Sequential fallback
@@ -387,7 +387,7 @@ namespace __parallel
               _IIter2 __begin2, _IIter2 __end2,
               _OutputIterator __out, _Predicate __pred,
               __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+    { return _GLIBCXX_STD_A::set_union(__begin1, __end1,
                                        __begin2, __end2, __out, __pred); }
 
   // Sequential fallback for input iterator case
@@ -399,7 +399,7 @@ namespace __parallel
       _IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
       _OutputIterator __result, _Predicate __pred,
       _IteratorTag1, _IteratorTag2, _IteratorTag3)
-    { return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+    { return _GLIBCXX_STD_A::set_union(__begin1, __end1,
                                        __begin2, __end2, __result, __pred); }
 
   // Parallel set_union for random access iterators
@@ -420,7 +420,7 @@ namespace __parallel
         return __gnu_parallel::__parallel_set_union(
                  __begin1, __end1, __begin2, __end2, __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+        return _GLIBCXX_STD_A::set_union(__begin1, __end1,
                                          __begin2, __end2, __result, __pred);
     }
 
@@ -477,7 +477,7 @@ namespace __parallel
     set_intersection(_IIter1 __begin1, _IIter1 __end1,
                      _IIter2 __begin2, _IIter2 __end2,
                      _OutputIterator __out, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1,
+    { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1,
                                               __begin2, __end2, __out); }
 
   // Sequential fallback.
@@ -488,7 +488,7 @@ namespace __parallel
                      _IIter2 __begin2, _IIter2 __end2,
                      _OutputIterator __out, _Predicate __pred, 
                      __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_intersection(
+    { return _GLIBCXX_STD_A::set_intersection(
                __begin1, __end1, __begin2, __end2, __out, __pred); }
 
   // Sequential fallback for input iterator case
@@ -501,7 +501,7 @@ namespace __parallel
                               _IIter2 __begin2, _IIter2 __end2,
                               _OutputIterator __result, _Predicate __pred,
                               _IteratorTag1, _IteratorTag2, _IteratorTag3)
-    { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2,
+    { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1, __begin2,
                                               __end2, __result, __pred); }
 
   // Parallel set_intersection for random access iterators
@@ -526,7 +526,7 @@ namespace __parallel
         return __gnu_parallel::__parallel_set_intersection(
                  __begin1, __end1, __begin2, __end2, __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_intersection(
+        return _GLIBCXX_STD_A::set_intersection(
                  __begin1, __end1, __begin2, __end2, __result, __pred);
     }
 
@@ -584,7 +584,7 @@ namespace __parallel
                              _IIter2 __begin2, _IIter2 __end2,
                              _OutputIterator __out,
                              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_symmetric_difference(
+    { return _GLIBCXX_STD_A::set_symmetric_difference(
                __begin1, __end1, __begin2, __end2, __out); }
 
   // Sequential fallback
@@ -595,7 +595,7 @@ namespace __parallel
                              _IIter2 __begin2, _IIter2 __end2,
                              _OutputIterator __out, _Predicate __pred,
                              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_symmetric_difference(
+    { return _GLIBCXX_STD_A::set_symmetric_difference(
                __begin1, __end1, __begin2, __end2, __out, __pred); }
 
   // Sequential fallback for input iterator case
@@ -608,7 +608,7 @@ namespace __parallel
       _IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
       _OutputIterator __result, _Predicate __pred,
       _IteratorTag1, _IteratorTag2, _IteratorTag3)
-    { return _GLIBCXX_STD_P::set_symmetric_difference(
+    { return _GLIBCXX_STD_A::set_symmetric_difference(
                __begin1, __end1, __begin2, __end2, __result, __pred); }
 
   // Parallel set_symmetric_difference for random access iterators
@@ -633,7 +633,7 @@ namespace __parallel
   return __gnu_parallel::__parallel_set_symmetric_difference(
            __begin1, __end1, __begin2, __end2, __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_symmetric_difference(
+        return _GLIBCXX_STD_A::set_symmetric_difference(
                  __begin1, __end1, __begin2, __end2, __result, __pred);
     }
 
@@ -691,7 +691,7 @@ namespace __parallel
     set_difference(_IIter1 __begin1, _IIter1 __end1, 
                    _IIter2 __begin2, _IIter2 __end2, 
                    _OutputIterator __out, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_difference(
+    { return _GLIBCXX_STD_A::set_difference(
                __begin1,__end1, __begin2, __end2, __out); }
 
   // Sequential fallback.
@@ -702,7 +702,7 @@ namespace __parallel
                    _IIter2 __begin2, _IIter2 __end2, 
                    _OutputIterator __out, _Predicate __pred, 
                    __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_difference(__begin1, __end1,
+    { return _GLIBCXX_STD_A::set_difference(__begin1, __end1,
                                             __begin2, __end2, __out, __pred); }
 
   // Sequential fallback for input iterator case.
@@ -714,7 +714,7 @@ namespace __parallel
                           _IIter2 __begin2, _IIter2 __end2, 
                           _OutputIterator __result, _Predicate __pred, 
                           _IteratorTag1, _IteratorTag2, _IteratorTag3)
-    { return _GLIBCXX_STD_P::set_difference(
+    { return _GLIBCXX_STD_A::set_difference(
                __begin1, __end1, __begin2, __end2, __result, __pred); }
 
   // Parallel set_difference for random access iterators
@@ -738,7 +738,7 @@ namespace __parallel
         return __gnu_parallel::__parallel_set_difference(
                  __begin1, __end1, __begin2, __end2, __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_difference(
+        return _GLIBCXX_STD_A::set_difference(
                  __begin1, __end1, __begin2, __end2, __result, __pred);
     }
 
@@ -794,7 +794,7 @@ namespace __parallel
     inline _FIterator
     adjacent_find(_FIterator __begin, _FIterator __end, 
                   __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_find(__begin, __end); }
+    { return _GLIBCXX_STD_A::adjacent_find(__begin, __end); }
 
   // Sequential fallback
   template<typename _FIterator, typename _BinaryPredicate>
@@ -802,7 +802,7 @@ namespace __parallel
     adjacent_find(_FIterator __begin, _FIterator __end, 
                   _BinaryPredicate __binary_pred,
                   __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_find(__begin, __end, __binary_pred); }
+    { return _GLIBCXX_STD_A::adjacent_find(__begin, __end, __binary_pred); }
 
   // Parallel algorithm for random access iterators
   template<typename _RAIter>
@@ -887,7 +887,7 @@ namespace __parallel
     inline typename iterator_traits<_IIter>::difference_type
     count(_IIter __begin, _IIter __end, const _Tp& __value, 
           __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::count(__begin, __end, __value); }
+    { return _GLIBCXX_STD_A::count(__begin, __end, __value); }
 
   // Parallel code for random access iterators
   template<typename _RAIter, typename _Tp>
@@ -957,7 +957,7 @@ namespace __parallel
     inline typename iterator_traits<_IIter>::difference_type
     count_if(_IIter __begin, _IIter __end, _Predicate __pred, 
              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::count_if(__begin, __end, __pred); }
+    { return _GLIBCXX_STD_A::count_if(__begin, __end, __pred); }
 
   // Parallel count_if for random access iterators
   template<typename _RAIter, typename _Predicate>
@@ -1029,7 +1029,7 @@ namespace __parallel
     search(_FIterator1 __begin1, _FIterator1 __end1,
            _FIterator2 __begin2, _FIterator2 __end2,
            __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search(__begin1, __end1, __begin2, __end2); }
+    { return _GLIBCXX_STD_A::search(__begin1, __end1, __begin2, __end2); }
 
   // Parallel algorithm for random access iterator
   template<typename _RAIter1, typename _RAIter2>
@@ -1087,7 +1087,7 @@ namespace __parallel
     search(_FIterator1 __begin1, _FIterator1 __end1,
            _FIterator2 __begin2, _FIterator2 __end2,
            _BinaryPredicate __pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search(
+    { return _GLIBCXX_STD_A::search(
                                __begin1, __end1, __begin2, __end2, __pred); }
 
   // Parallel algorithm for random access iterator.
@@ -1141,7 +1141,7 @@ namespace __parallel
     inline _FIterator
     search_n(_FIterator __begin, _FIterator __end, _Integer __count,
              const _Tp& __val, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search_n(__begin, __end, __count, __val); }
+    { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val); }
 
   // Sequential fallback
   template<typename _FIterator, typename _Integer, typename _Tp,
@@ -1150,7 +1150,7 @@ namespace __parallel
     search_n(_FIterator __begin, _FIterator __end, _Integer __count,
              const _Tp& __val, _BinaryPredicate __binary_pred,
              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search_n(
+    { return _GLIBCXX_STD_A::search_n(
                __begin, __end, __count, __val, __binary_pred); }
 
   // Public interface.
@@ -1181,7 +1181,7 @@ namespace __parallel
                    __begin, __end, __ps.begin(), __ps.end(), __binary_pred);
         }
       else
-        return _GLIBCXX_STD_P::search_n(__begin, __end, __count, __val,
+        return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val,
                                         __binary_pred);
     }
 
@@ -1192,7 +1192,7 @@ namespace __parallel
     __search_n_switch(_FIterator __begin, _FIterator __end, _Integer __count,
                       const _Tp& __val, _BinaryPredicate __binary_pred,
                       _IteratorTag)
-    { return _GLIBCXX_STD_P::search_n(__begin, __end, __count, __val,
+    { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val,
                                       __binary_pred); }
 
   // Public interface.
@@ -1214,7 +1214,7 @@ namespace __parallel
     inline _OutputIterator
     transform(_IIter __begin, _IIter __end, _OutputIterator __result, 
               _UnaryOperation __unary_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::transform(__begin, __end, __result, __unary_op); }
+    { return _GLIBCXX_STD_A::transform(__begin, __end, __result, __unary_op); }
 
   // Parallel unary transform for random access iterators.
   template<typename _RAIter1, typename _RAIter2,
@@ -1301,7 +1301,7 @@ namespace __parallel
     transform(_IIter1 __begin1, _IIter1 __end1,
               _IIter2 __begin2, _OutputIterator __result,
               _BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::transform(__begin1, __end1,
+    { return _GLIBCXX_STD_A::transform(__begin1, __end1,
                                        __begin2, __result, __binary_op); }
 
   // Parallel binary transform for random access iterators.
@@ -1403,7 +1403,7 @@ namespace __parallel
     inline void
     replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value, 
             const _Tp& __new_value, __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::replace(__begin, __end, __old_value, __new_value); }
+    { _GLIBCXX_STD_A::replace(__begin, __end, __old_value, __new_value); }
 
   // Sequential fallback for input iterator case
   template<typename _FIterator, typename _Tp, typename _IteratorTag>
@@ -1459,7 +1459,7 @@ namespace __parallel
     inline void
     replace_if(_FIterator __begin, _FIterator __end, _Predicate __pred, 
                const _Tp& __new_value, __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::replace_if(__begin, __end, __pred, __new_value); }
+    { _GLIBCXX_STD_A::replace_if(__begin, __end, __pred, __new_value); }
 
   // Sequential fallback for input iterator case
   template<typename _FIterator, typename _Predicate, typename _Tp,
@@ -1528,7 +1528,7 @@ namespace __parallel
     inline void
     generate(_FIterator __begin, _FIterator __end, _Generator __gen, 
              __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::generate(__begin, __end, __gen); }
+    { _GLIBCXX_STD_A::generate(__begin, __end, __gen); }
 
   // Sequential fallback for input iterator case.
   template<typename _FIterator, typename _Generator, typename _IteratorTag>
@@ -1590,7 +1590,7 @@ namespace __parallel
     inline _OutputIterator
     generate_n(_OutputIterator __begin, _Size __n, _Generator __gen, 
                __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::generate_n(__begin, __n, __gen); }
+    { return _GLIBCXX_STD_A::generate_n(__begin, __n, __gen); }
 
   // Sequential fallback for input iterator case.
   template<typename _OutputIterator, typename _Size, typename _Generator,
@@ -1640,7 +1640,7 @@ namespace __parallel
     inline void
     random_shuffle(_RAIter __begin, _RAIter __end, 
                    __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::random_shuffle(__begin, __end); }
+    { _GLIBCXX_STD_A::random_shuffle(__begin, __end); }
 
   // Sequential fallback.
   template<typename _RAIter, typename _RandomNumberGenerator>
@@ -1648,7 +1648,7 @@ namespace __parallel
     random_shuffle(_RAIter __begin, _RAIter __end,
                    _RandomNumberGenerator& __rand,
                    __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::random_shuffle(__begin, __end, __rand); }
+    { _GLIBCXX_STD_A::random_shuffle(__begin, __end, __rand); }
 
 
   /** @brief Functor wrapper for std::rand(). */
@@ -1695,7 +1695,7 @@ namespace __parallel
     inline _FIterator
     partition(_FIterator __begin, _FIterator __end,
               _Predicate __pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::partition(__begin, __end, __pred); }
+    { return _GLIBCXX_STD_A::partition(__begin, __end, __pred); }
 
   // Sequential fallback for input iterator case.
   template<typename _FIterator, typename _Predicate, typename _IteratorTag>
@@ -1744,14 +1744,14 @@ namespace __parallel
     inline void
     sort(_RAIter __begin, _RAIter __end, 
          __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::sort(__begin, __end); }
+    { _GLIBCXX_STD_A::sort(__begin, __end); }
 
   // Sequential fallback
   template<typename _RAIter, typename _Compare>
     inline void
     sort(_RAIter __begin, _RAIter __end, _Compare __comp,
          __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::sort<_RAIter, _Compare>(__begin, __end,
+    { _GLIBCXX_STD_A::sort<_RAIter, _Compare>(__begin, __end,
                                                              __comp); }
 
   // Public interface
@@ -1883,14 +1883,14 @@ namespace __parallel
   inline void
   stable_sort(_RAIter __begin, _RAIter __end,
        __gnu_parallel::sequential_tag)
-  { _GLIBCXX_STD_P::stable_sort(__begin, __end); }
+  { _GLIBCXX_STD_A::stable_sort(__begin, __end); }
 
   // Sequential fallback
   template<typename _RAIter, typename _Compare>
   inline void
   stable_sort(_RAIter __begin, _RAIter __end,
               _Compare __comp, __gnu_parallel::sequential_tag)
-  { _GLIBCXX_STD_P::stable_sort<_RAIter, _Compare>(
+  { _GLIBCXX_STD_A::stable_sort<_RAIter, _Compare>(
       __begin, __end, __comp); }
 
   // Public interface
@@ -2001,7 +2001,7 @@ namespace __parallel
     merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
           _IIter2 __end2, _OutputIterator __result,
           __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::merge(
+    { return _GLIBCXX_STD_A::merge(
                __begin1, __end1, __begin2, __end2, __result); }
 
   // Sequential fallback
@@ -2011,7 +2011,7 @@ namespace __parallel
     merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
           _IIter2 __end2, _OutputIterator __result, _Compare __comp,
           __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::merge(
+    { return _GLIBCXX_STD_A::merge(
                 __begin1, __end1, __begin2, __end2, __result, __comp); }
 
   // Sequential fallback for input iterator case
@@ -2023,7 +2023,7 @@ namespace __parallel
                  _IIter2 __begin2, _IIter2 __end2,
                  _OutputIterator __result, _Compare __comp,
                  _IteratorTag1, _IteratorTag2, _IteratorTag3)
-     { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2,
+     { return _GLIBCXX_STD_A::merge(__begin1, __end1, __begin2, __end2,
                                     __result, __comp); }
 
   // Parallel algorithm for random access iterators
@@ -2095,7 +2095,7 @@ namespace __parallel
     inline void
     nth_element(_RAIter __begin, _RAIter __nth, 
                 _RAIter __end, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end); }
+    { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end); }
 
   // Sequential fallback
   template<typename _RAIter, typename _Compare>
@@ -2103,7 +2103,7 @@ namespace __parallel
     nth_element(_RAIter __begin, _RAIter __nth, 
                 _RAIter __end, _Compare __comp, 
               __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end, __comp); }
+    { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end, __comp); }
 
   // Public interface
   template<typename _RAIter, typename _Compare>
@@ -2138,14 +2138,14 @@ namespace __parallel
     partial_sort(_RAIter __begin, _RAIter __middle, 
                  _RAIter __end, _Compare __comp,
                  __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end, __comp); }
+    { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end, __comp); }
 
   // Sequential fallback
   template<typename _RAIter>
     inline void
     partial_sort(_RAIter __begin, _RAIter __middle, 
                  _RAIter __end, __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end); }
+    { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end); }
 
   // Public interface, parallel algorithm for random access iterators
   template<typename _RAIter, typename _Compare>
@@ -2180,14 +2180,14 @@ namespace __parallel
     inline _FIterator
     max_element(_FIterator __begin, _FIterator __end, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::max_element(__begin, __end); }
+    { return _GLIBCXX_STD_A::max_element(__begin, __end); }
 
   // Sequential fallback
   template<typename _FIterator, typename _Compare>
     inline _FIterator
     max_element(_FIterator __begin, _FIterator __end, _Compare __comp, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::max_element(__begin, __end, __comp); }
+    { return _GLIBCXX_STD_A::max_element(__begin, __end, __comp); }
 
   // Sequential fallback for input iterator case
   template<typename _FIterator, typename _Compare, typename _IteratorTag>
@@ -2272,14 +2272,14 @@ namespace __parallel
     inline _FIterator
     min_element(_FIterator __begin, _FIterator __end, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::min_element(__begin, __end); }
+    { return _GLIBCXX_STD_A::min_element(__begin, __end); }
 
   // Sequential fallback
   template<typename _FIterator, typename _Compare>
     inline _FIterator
     min_element(_FIterator __begin, _FIterator __end, _Compare __comp, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::min_element(__begin, __end, __comp); }
+    { return _GLIBCXX_STD_A::min_element(__begin, __end, __comp); }
 
   // Sequential fallback for input iterator case
   template<typename _FIterator, typename _Compare, typename _IteratorTag>
diff --git a/libstdc++-v3/include/parallel/algobase.h b/libstdc++-v3/include/parallel/algobase.h
index a6fd6cd4331..20456b57b2f 100644
--- a/libstdc++-v3/include/parallel/algobase.h
+++ b/libstdc++-v3/include/parallel/algobase.h
@@ -43,7 +43,7 @@
 #include <parallel/find.h>
 #include <parallel/find_selectors.h>
 
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __parallel
 {
@@ -54,14 +54,14 @@ namespace __parallel
     inline pair<_IIter1, _IIter2>
     mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2); }
+    { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2); }
 
   // Sequential fallback
   template<typename _IIter1, typename _IIter2, typename _Predicate>
     inline pair<_IIter1, _IIter2>
     mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
              _Predicate __pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); }
+    { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred); }
 
   // Sequential fallback for input iterator case
   template<typename _IIter1, typename _IIter2,
@@ -69,7 +69,7 @@ namespace __parallel
     inline pair<_IIter1, _IIter2>
     __mismatch_switch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
                       _Predicate __pred, _IteratorTag1, _IteratorTag2)
-    { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); }
+    { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred); }
 
   // Parallel mismatch for random access iterators
   template<typename _RAIter1, typename _RAIter2, typename _Predicate>
@@ -87,7 +87,7 @@ namespace __parallel
           return make_pair(__res , __begin2 + (__res - __begin1));
         }
       else
-        return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred);
+        return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred);
     }
 
   // Public interface
@@ -128,14 +128,14 @@ namespace __parallel
     inline bool
     equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
           __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2); }
+    { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2); }
 
   // Sequential fallback
   template<typename _IIter1, typename _IIter2, typename _Predicate>
     inline bool
     equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
           _Predicate __pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2, __pred); }
+    { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2, __pred); }
 
   // Public interface
   template<typename _IIter1, typename _IIter2>
@@ -162,7 +162,7 @@ namespace __parallel
     lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
                             _IIter2 __begin2, _IIter2 __end2, 
                             __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1,
+    { return _GLIBCXX_STD_A::lexicographical_compare(__begin1, __end1,
                                                      __begin2, __end2); }
 
   // Sequential fallback
@@ -171,7 +171,7 @@ namespace __parallel
     lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
                             _IIter2 __begin2, _IIter2 __end2, 
                             _Predicate __pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::lexicographical_compare(
+    { return _GLIBCXX_STD_A::lexicographical_compare(
                __begin1, __end1, __begin2, __end2, __pred); }
 
   // Sequential fallback for input iterator case
@@ -182,7 +182,7 @@ namespace __parallel
                                      _IIter2 __begin2, _IIter2 __end2, 
                                      _Predicate __pred,
                                      _IteratorTag1, _IteratorTag2)
-    { return _GLIBCXX_STD_P::lexicographical_compare(
+    { return _GLIBCXX_STD_A::lexicographical_compare(
                __begin1, __end1, __begin2, __end2, __pred); }
 
   // Parallel lexicographical_compare for random access iterators
@@ -232,7 +232,7 @@ namespace __parallel
             }
         }
       else
-        return _GLIBCXX_STD_P::lexicographical_compare(
+        return _GLIBCXX_STD_A::lexicographical_compare(
                  __begin1, __end1, __begin2, __end2, __pred);
     }
 
diff --git a/libstdc++-v3/include/parallel/algorithmfwd.h b/libstdc++-v3/include/parallel/algorithmfwd.h
index f2749b89eb1..7d4a792cb59 100644
--- a/libstdc++-v3/include/parallel/algorithmfwd.h
+++ b/libstdc++-v3/include/parallel/algorithmfwd.h
@@ -34,7 +34,7 @@
 #include <parallel/tags.h>
 #include <parallel/settings.h>
 
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __parallel
 {
diff --git a/libstdc++-v3/include/parallel/base.h b/libstdc++-v3/include/parallel/base.h
index 3e3041d27df..86adea8161d 100644
--- a/libstdc++-v3/include/parallel/base.h
+++ b/libstdc++-v3/include/parallel/base.h
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010, 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 terms
@@ -45,7 +45,7 @@
  * @namespace std::__parallel
  * @brief GNU parallel code, replaces standard behavior with parallel behavior.
  */
-namespace std 
+namespace std _GLIBCXX_VISIBILITY(default) 
 { 
   namespace __parallel { } 
 }
@@ -68,7 +68,7 @@ namespace __gnu_sequential
 { 
   // Import whatever is the serial version.
 #ifdef _GLIBCXX_PARALLEL
-  using namespace std::__norm;
+  using namespace std::_GLIBCXX_STD_A;
 #else
   using namespace std;
 #endif   
diff --git a/libstdc++-v3/include/parallel/numeric b/libstdc++-v3/include/parallel/numeric
index b779aae8d6d..64624a742bd 100644
--- a/libstdc++-v3/include/parallel/numeric
+++ b/libstdc++-v3/include/parallel/numeric
@@ -46,7 +46,7 @@
 #include <parallel/for_each_selectors.h>
 #include <parallel/partial_sum.h>
 
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __parallel
 {
@@ -55,13 +55,13 @@ namespace __parallel
     inline _Tp
     accumulate(_IIter __begin, _IIter __end, _Tp __init, 
                __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init); }
+    { return _GLIBCXX_STD_A::accumulate(__begin, __end, __init); }
 
   template<typename _IIter, typename _Tp, typename _BinaryOperation>
     inline _Tp
     accumulate(_IIter __begin, _IIter __end, _Tp __init,
                _BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init, __binary_op); }
+    { return _GLIBCXX_STD_A::accumulate(__begin, __end, __init, __binary_op); }
 
   // Sequential fallback for input iterator case.
   template<typename _IIter, typename _Tp, typename _IteratorTag>
@@ -169,7 +169,7 @@ namespace __parallel
     inner_product(_IIter1 __first1, _IIter1 __last1, 
                   _IIter2 __first2, _Tp __init,
                   __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::inner_product(
+    { return _GLIBCXX_STD_A::inner_product(
                                __first1, __last1, __first2, __init); }
 
   template<typename _IIter1, typename _IIter2, typename _Tp,
@@ -179,7 +179,7 @@ namespace __parallel
                   _IIter2 __first2, _Tp __init, _BinaryFunction1 __binary_op1, 
                   _BinaryFunction2 __binary_op2,
                   __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::inner_product(__first1, __last1, __first2, __init,
+    { return _GLIBCXX_STD_A::inner_product(__first1, __last1, __first2, __init,
                                            __binary_op1, __binary_op2); }
 
   // Parallel algorithm for random access iterators.
@@ -314,7 +314,7 @@ namespace __parallel
     inline _OutputIterator
     partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result); }
+    { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result); }
 
   // Sequential fallback.
   template<typename _IIter, typename _OutputIterator,
@@ -322,7 +322,7 @@ namespace __parallel
     inline _OutputIterator
     partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
                 _BinaryOperation __bin_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); }
+    { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result, __bin_op); }
 
   // Sequential fallback for input iterator case.
   template<typename _IIter, typename _OutputIterator,
@@ -332,7 +332,7 @@ namespace __parallel
     __partial_sum_switch(_IIter __begin, _IIter __end,
 			 _OutputIterator __result, _BinaryOperation __bin_op,
 			 _IteratorTag1, _IteratorTag2)
-    { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); }
+    { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result, __bin_op); }
 
   // Parallel algorithm for random access iterators.
   template<typename _IIter, typename _OutputIterator,
@@ -385,7 +385,7 @@ namespace __parallel
     inline _OutputIterator
     adjacent_difference(_IIter __begin, _IIter __end, _OutputIterator __result,
                         __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end, __result); }
+    { return _GLIBCXX_STD_A::adjacent_difference(__begin, __end, __result); }
 
   // Sequential fallback.
   template<typename _IIter, typename _OutputIterator,
@@ -394,7 +394,7 @@ namespace __parallel
     adjacent_difference(_IIter __begin, _IIter __end,
                         _OutputIterator __result, _BinaryOperation __bin_op,
                         __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end,
+    { return _GLIBCXX_STD_A::adjacent_difference(__begin, __end,
 						 __result, __bin_op); }
 
   // Sequential fallback for input iterator case.
diff --git a/libstdc++-v3/include/parallel/numericfwd.h b/libstdc++-v3/include/parallel/numericfwd.h
index bb6a9bd0612..5ee3d6d4fa7 100644
--- a/libstdc++-v3/include/parallel/numericfwd.h
+++ b/libstdc++-v3/include/parallel/numericfwd.h
@@ -34,7 +34,7 @@
 #include <parallel/tags.h>
 #include <parallel/settings.h>
 
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __parallel
 {