bitset: Tweak doxygen markup.

2009-11-17  Benjamin Kosnik  <bkoz@redhat.com>

	* include/profile/bitset: Tweak doxygen markup.
	* include/profile/deque: Same.
	* include/profile/list: Same.
	* include/profile/map.h: Same.
	* include/profile/multimap.h: Same.
	* include/profile/multiset.h: Same.
	* include/profile/set.h: Same.
	* include/profile/unordered_map: Same.
	* include/profile/vector: Same.

	* include/profile/impl/profiler_container_size.h: Use namespace
	__gnu_profile instead of __cxxprof_impl.
	* include/profile/impl/profiler.h: Same.
	(_GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD): To
	_GLIBCXX_PROFILE_REENTRANCE_GUARD.
	Remove namespace __cxxprof_guard.
	(__reentrance_guard): De-templatize.
	(__reentrance_guard::__inside_cxxprof_impl): To
	__reentrance_guard::_S_get_in.

	* include/profile/impl/profiler_hash_func.h: Use namespace
	__gnu_profile instead of __cxxprof_impl.
	* include/profile/impl/profiler_hashtable_size.h: Same.
	* include/profile/impl/profiler_map_to_unordered_map.h: Same.
	* include/profile/impl/profiler_node.h: Same.
	* include/profile/impl/profiler_state.h: Same.
	* include/profile/impl/profiler_trace.h: Same.
	* include/profile/impl/profiler_vector_size.h: Same.
	* include/profile/impl/profiler_vector_to_list.h: Same.
	* doc/xml/manual/profile_mode.xml: Update.

From-SVN: r154269

libstdc++-v3/ChangeLog

@@ -1,3 +1,36 @@
+2009-11-17  Benjamin Kosnik  <bkoz@redhat.com>
+
+	* include/profile/bitset: Tweak doxygen markup.
+	* include/profile/deque: Same.
+	* include/profile/list: Same.
+	* include/profile/map.h: Same.
+	* include/profile/multimap.h: Same.
+	* include/profile/multiset.h: Same.
+	* include/profile/set.h: Same.
+	* include/profile/unordered_map: Same.
+	* include/profile/vector: Same.
+
+	* include/profile/impl/profiler_container_size.h: Use namespace
+	__gnu_profile instead of __cxxprof_impl.
+	* include/profile/impl/profiler.h: Same.
+	(_GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD): To
+	_GLIBCXX_PROFILE_REENTRANCE_GUARD.
+	Remove namespace __cxxprof_guard.
+	(__reentrance_guard): De-templatize.
+	(__reentrance_guard::__inside_cxxprof_impl): To
+	__reentrance_guard::_S_get_in.
+
+	* include/profile/impl/profiler_hash_func.h: Use namespace
+	__gnu_profile instead of __cxxprof_impl.
+	* include/profile/impl/profiler_hashtable_size.h: Same.
+	* include/profile/impl/profiler_map_to_unordered_map.h: Same.
+	* include/profile/impl/profiler_node.h: Same.
+	* include/profile/impl/profiler_state.h: Same.
+	* include/profile/impl/profiler_trace.h: Same.
+	* include/profile/impl/profiler_vector_size.h: Same.
+	* include/profile/impl/profiler_vector_to_list.h: Same.
+	* doc/xml/manual/profile_mode.xml: Update.
+
 2009-11-17  Benjamin Kosnik  <bkoz@redhat.com>
 
 	* include/debug/bitset: Add doxygen markup.

libstdc++-v3/doc/xml/manual/profile_mode.xml

@@ -640,10 +640,10 @@ it helps the user focus on the key problems and ignore the uninteresting ones.
    Hook names must start with <code>__profcxx_</code>.
    Make sure they transform
    in no code with <code>-D_NO_GLBICXX_PROFILE_MAGIC</code>.
-   Make sure all calls to any method in namespace <code>__cxxprof_impl</code>
+   Make sure all calls to any method in namespace <code>__gnu_profile</code>
    is protected against reentrance using macro
-   <code>_GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD</code>.
+   <code>_GLIBCXX_PROFILE_REENTRANCE_GUARD</code>.
-   All names of methods in namespace <code>__cxxprof_impl</code> called from
+   All names of methods in namespace <code>__gnu_profile</code> called from
    <code>profiler.h</code> must start with <code>__trace_magic_</code>.
   </para>
 

libstdc++-v3/include/profile/bitset

@@ -35,7 +35,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Bitset wrapper with performance instrumentation.  */
+  /// Class std::bitset wrapper with performance instrumentation.
   template<size_t _Nb>
     class bitset
     : public _GLIBCXX_STD_D::bitset<_Nb>

libstdc++-v3/include/profile/deque

@@ -35,7 +35,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Deque wrapper with performance instrumentation.  */
+  /// Class std::deque wrapper with performance instrumentation.
   template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
     class deque
     : public _GLIBCXX_STD_D::deque<_Tp, _Allocator>

libstdc++-v3/include/profile/impl/profiler.h

@@ -44,90 +44,82 @@
 #endif
 
 /**
- * @namespace std::__cxxprof_guard
+ * @namespace std::__gnu_profile
- * @brief Mechanism to protect all __cxxprof_impl operations against
- * multithreaded and exception reentrance.
- */
-namespace __cxxprof_guard
-{
-
-/** @brief Reentrance guard.
- *
- * Mechanism to protect all __cxxprof_impl operations against recursion,
- * multithreaded and exception reentrance.
- */
-template <int _Unused=0>
-class __reentrance_guard
-{
- public:
-  static __thread bool __inside_cxxprof_impl;
-  static bool __get_in();
-  __reentrance_guard() {}
-  ~__reentrance_guard() { __inside_cxxprof_impl = false; }
-};
-
-template <int _Unused>
-__thread bool __reentrance_guard<_Unused>::__inside_cxxprof_impl = false;
-
-template <int _Unused>
-bool __reentrance_guard<_Unused>::__get_in()
-{
-  if (__inside_cxxprof_impl) {
-    return false;
-  } else {
-    __inside_cxxprof_impl = true;
-    return true;
-  }
-}
-
-} // namespace __cxxprof_guard
-
-#define _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__x...)             \
-  {                                                                \
-    if (__cxxprof_guard::__reentrance_guard<0>::__get_in())        \
-    {                                                              \
-      __cxxprof_guard::__reentrance_guard<0> __auto_get_out;       \
-      __x;                                                         \
-    }                                                              \
-  }
-
-/**
- * @namespace std::__cxxprof_impl
  * @brief Implementation of profile extension.
  */
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
-// Forward declarations of implementation functions.
+  /** @brief Reentrance guard.
-// Don't use any __cxxprof_impl:: in user code.
+   *
-// Instead, use the __profcxx... macros, which offer guarded access.
+   * Mechanism to protect all __gnu_profile operations against recursion,
-void __turn_on();
+   * multithreaded and exception reentrance.
-void __turn_off();
+   */
-bool __is_invalid();
+  struct __reentrance_guard
-bool __is_on();
+  {
-bool __is_off();
+    static bool
-void __report(void);
+    _S_set_in()
-void __trace_hashtable_size_resize(const void*, size_t, size_t);
+    {
-void __trace_hashtable_size_destruct(const void*, size_t, size_t);
+      if (_S_get_in())
-void __trace_hashtable_size_construct(const void*, size_t);
+	return false;
-void __trace_vector_size_resize(const void*, size_t, size_t);
+      else
-void __trace_vector_size_destruct(const void*, size_t, size_t);
+	{
-void __trace_vector_size_construct(const void*, size_t);
+	  _S_get_in() = true;
-void __trace_hash_func_destruct(const void*, size_t, size_t, size_t);
+	  return true;
-void __trace_hash_func_construct(const void*);
+	}
-void __trace_vector_to_list_destruct(const void*);
+    }
-void __trace_vector_to_list_construct(const void*);
+
-void __trace_vector_to_list_insert(const void*, size_t, size_t);
+    static bool&
-void __trace_vector_to_list_iterate(const void*, size_t);
+    _S_get_in()
-void __trace_vector_to_list_invalid_operator(const void*);
+    {
-void __trace_vector_to_list_resize(const void*, size_t, size_t);
+      static __thread bool _S_inside(false);
-void __trace_map_to_unordered_map_construct(const void*);
+      return _S_inside;
-void __trace_map_to_unordered_map_invalidate(const void*);
+    }
-void __trace_map_to_unordered_map_insert(const void*, size_t, size_t);
+
-void __trace_map_to_unordered_map_erase(const void*, size_t, size_t);
+    __reentrance_guard() { }
-void __trace_map_to_unordered_map_iterate(const void*, size_t);
+    ~__reentrance_guard() { _S_get_in() = false; }
-void __trace_map_to_unordered_map_find(const void*, size_t);
+  };
-void __trace_map_to_unordered_map_destruct(const void*);
+
-} // namespace __cxxprof_impl
+#define _GLIBCXX_PROFILE_REENTRANCE_GUARD(__x...)	      	\
+  {                                                             \
+    if (__gnu_profile::__reentrance_guard::_S_get_in())	 	\
+    {                                                           \
+      __gnu_profile::__reentrance_guard __get_out; 		\
+      __x;                                                      \
+    }                                                           \
+  }
+
+
+  // Forward declarations of implementation functions.
+  // Don't use any __gnu_profile:: in user code.
+  // Instead, use the __profcxx... macros, which offer guarded access.
+  void __turn_on();
+  void __turn_off();
+  bool __is_invalid();
+  bool __is_on();
+  bool __is_off();
+  void __report(void);
+  void __trace_hashtable_size_resize(const void*, size_t, size_t);
+  void __trace_hashtable_size_destruct(const void*, size_t, size_t);
+  void __trace_hashtable_size_construct(const void*, size_t);
+  void __trace_vector_size_resize(const void*, size_t, size_t);
+  void __trace_vector_size_destruct(const void*, size_t, size_t);
+  void __trace_vector_size_construct(const void*, size_t);
+  void __trace_hash_func_destruct(const void*, size_t, size_t, size_t);
+  void __trace_hash_func_construct(const void*);
+  void __trace_vector_to_list_destruct(const void*);
+  void __trace_vector_to_list_construct(const void*);
+  void __trace_vector_to_list_insert(const void*, size_t, size_t);
+  void __trace_vector_to_list_iterate(const void*, size_t);
+  void __trace_vector_to_list_invalid_operator(const void*);
+  void __trace_vector_to_list_resize(const void*, size_t, size_t);
+  void __trace_map_to_unordered_map_construct(const void*);
+  void __trace_map_to_unordered_map_invalidate(const void*);
+  void __trace_map_to_unordered_map_insert(const void*, size_t, size_t);
+  void __trace_map_to_unordered_map_erase(const void*, size_t, size_t);
+  void __trace_map_to_unordered_map_iterate(const void*, size_t);
+  void __trace_map_to_unordered_map_find(const void*, size_t);
+  void __trace_map_to_unordered_map_destruct(const void*);
+} // namespace __gnu_profile
 
 // Master switch turns on all diagnostics.
 #ifdef _GLIBCXX_PROFILE
@@ -143,17 +135,17 @@ void __trace_map_to_unordered_map_destruct(const void*);
 // Expose global management routines to user code.
 #ifdef _GLIBCXX_PROFILE
 #define __profcxx_report() \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__report())
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__report())
 #define __profcxx_turn_on() \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__turn_on())
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__turn_on())
 #define __profcxx_turn_off() \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__turn_off())
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__turn_off())
 #define __profcxx_is_invalid() \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_invalid())
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_invalid())
 #define __profcxx_is_on() \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_on())
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_on())
 #define __profcxx__is_off() \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD(__cxxprof_impl::__is_off())
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD(__gnu_profile::__is_off())
 #else
 #define __profcxx_report()
 #define __profcxx_turn_on()
@@ -167,77 +159,77 @@ void __trace_map_to_unordered_map_destruct(const void*);
 #if ((defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \
       && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL)) \
      || (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE) \
-         && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE)))
+	 && !defined(_NO_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE)))
 #define __profcxx_hashtable_resize(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_hashtable_size_resize(__x))
+      __gnu_profile::__trace_hashtable_size_resize(__x))
 #define __profcxx_hashtable_destruct(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_hashtable_size_destruct(__x))
+      __gnu_profile::__trace_hashtable_size_destruct(__x))
 #define __profcxx_hashtable_construct(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_hashtable_size_construct(__x))
+      __gnu_profile::__trace_hashtable_size_construct(__x))
 #else
-#define __profcxx_hashtable_resize(__x...)  
+#define __profcxx_hashtable_resize(__x...)
-#define __profcxx_hashtable_destruct(__x...) 
+#define __profcxx_hashtable_destruct(__x...)
-#define __profcxx_hashtable_construct(__x...)  
+#define __profcxx_hashtable_construct(__x...)
 #endif
 
 // Turn on/off instrumentation for VECTOR_TOO_SMALL and VECTOR_TOO_LARGE.
 #if ((defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \
       && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_SMALL)) \
      || (defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE) \
-         && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_LARGE)))
+	 && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TOO_LARGE)))
 #define __profcxx_vector_resize(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_size_resize(__x))
+      __gnu_profile::__trace_vector_size_resize(__x))
 #define __profcxx_vector_destruct(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_size_destruct(__x))
+      __gnu_profile::__trace_vector_size_destruct(__x))
 #define __profcxx_vector_construct(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_size_construct(__x))
+      __gnu_profile::__trace_vector_size_construct(__x))
 #else
-#define __profcxx_vector_resize(__x...)  
+#define __profcxx_vector_resize(__x...)
-#define __profcxx_vector_destruct(__x...) 
+#define __profcxx_vector_destruct(__x...)
-#define __profcxx_vector_construct(__x...)  
+#define __profcxx_vector_construct(__x...)
-#endif 
+#endif
 
 // Turn on/off instrumentation for INEFFICIENT_HASH.
 #if (defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH) \
      && !defined(_NO_GLIBCXX_PROFILE_INEFFICIENT_HASH))
 #define __profcxx_hashtable_construct2(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_hash_func_construct(__x))
+      __gnu_profile::__trace_hash_func_construct(__x))
 #define __profcxx_hashtable_destruct2(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_hash_func_destruct(__x))
+      __gnu_profile::__trace_hash_func_destruct(__x))
 #else
-#define __profcxx_hashtable_destruct2(__x...) 
+#define __profcxx_hashtable_destruct2(__x...)
-#define __profcxx_hashtable_construct2(__x...)  
+#define __profcxx_hashtable_construct2(__x...)
 #endif
 
 // Turn on/off instrumentation for VECTOR_TO_LIST.
 #if (defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST) \
      && !defined(_NO_GLIBCXX_PROFILE_VECTOR_TO_LIST))
 #define __profcxx_vector_construct2(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_to_list_construct(__x))
+      __gnu_profile::__trace_vector_to_list_construct(__x))
 #define __profcxx_vector_destruct2(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_to_list_destruct(__x))
+      __gnu_profile::__trace_vector_to_list_destruct(__x))
 #define __profcxx_vector_insert(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_to_list_insert(__x))
+      __gnu_profile::__trace_vector_to_list_insert(__x))
 #define __profcxx_vector_iterate(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_to_list_iterate(__x))
+      __gnu_profile::__trace_vector_to_list_iterate(__x))
 #define __profcxx_vector_invalid_operator(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_to_list_invalid_operator(__x))
+      __gnu_profile::__trace_vector_to_list_invalid_operator(__x))
 #define __profcxx_vector_resize2(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_vector_to_list_resize(__x))
+      __gnu_profile::__trace_vector_to_list_resize(__x))
 #else
 #define __profcxx_vector_destruct2(__x...)
 #define __profcxx_vector_construct2(__x...)
@@ -251,29 +243,29 @@ void __trace_map_to_unordered_map_destruct(const void*);
 #if (defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP) \
      && !defined(_NO_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP))
 #define __profcxx_map_to_unordered_map_construct(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_map_to_unordered_map_construct(__x))
+      __gnu_profile::__trace_map_to_unordered_map_construct(__x))
 #define __profcxx_map_to_unordered_map_destruct(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_map_to_unordered_map_destruct(__x))
+      __gnu_profile::__trace_map_to_unordered_map_destruct(__x))
 #define __profcxx_map_to_unordered_map_insert(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_map_to_unordered_map_insert(__x))
+      __gnu_profile::__trace_map_to_unordered_map_insert(__x))
 #define __profcxx_map_to_unordered_map_erase(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_map_to_unordered_map_erase(__x))
+      __gnu_profile::__trace_map_to_unordered_map_erase(__x))
 #define __profcxx_map_to_unordered_map_iterate(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_map_to_unordered_map_iterate(__x))
+      __gnu_profile::__trace_map_to_unordered_map_iterate(__x))
 #define __profcxx_map_to_unordered_map_invalidate(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_map_to_unordered_map_invalidate(__x))
+      __gnu_profile::__trace_map_to_unordered_map_invalidate(__x))
 #define __profcxx_map_to_unordered_map_find(__x...) \
-  _GLIBCXX_PROFILE_IMPL_REENTRANCE_GUARD( \
+  _GLIBCXX_PROFILE_REENTRANCE_GUARD( \
-      __cxxprof_impl::__trace_map_to_unordered_map_find(__x))
+      __gnu_profile::__trace_map_to_unordered_map_find(__x))
 #else
 #define __profcxx_map_to_unordered_map_construct(__x...) \
-  
+
 #define __profcxx_map_to_unordered_map_destruct(__x...)
 #define __profcxx_map_to_unordered_map_insert(__x...)
 #define __profcxx_map_to_unordered_map_erase(__x...)

libstdc++-v3/include/profile/impl/profiler_container_size.h

@@ -51,7 +51,7 @@
 #include "profile/impl/profiler_node.h"
 #include "profile/impl/profiler_trace.h"
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 /** @brief A container size instrumentation line in the object table.  */
@@ -246,5 +246,5 @@ inline void __trace_container_size::__resize(const void* __obj, int __from,
   __object_info->__resize(__from, __to);
 }
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 #endif /* PROFCXX_PROFILER_CONTAINER_SIZE_H__ */

libstdc++-v3/include/profile/impl/profiler_hash_func.h

@@ -50,7 +50,7 @@
 #include "profile/impl/profiler_node.h"
 #include "profile/impl/profiler_trace.h"
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 /** @brief A hash performance instrumentation line in the object table.  */
@@ -188,5 +188,5 @@ inline void __trace_hash_func_destruct(const void* __obj, size_t __chain,
   __tables<0>::_S_hash_func->__destruct(__obj, __chain, __accesses, __hops);
 }
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 #endif /* PROFCXX_PROFILER_HASH_FUNC_H__ */

libstdc++-v3/include/profile/impl/profiler_hashtable_size.h

@@ -52,7 +52,7 @@
 #include "profile/impl/profiler_state.h"
 #include "profile/impl/profiler_container_size.h"
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 /** @brief Hashtable size instrumentation trace producer.  */
@@ -110,6 +110,6 @@ inline void __trace_hashtable_size_resize(const void* __obj, size_t __from,
   __tables<0>::_S_hashtable_size->__resize(__obj, __from, __to);
 }
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 
 #endif /* PROFCXX_PROFILER_HASHTABLE_SIZE_H__ */

libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h

@@ -50,7 +50,7 @@
 #include "profile/impl/profiler_node.h"
 #include "profile/impl/profiler_trace.h"
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 // Cost model. XXX: this must be taken from the machine model instead.
@@ -301,5 +301,5 @@ inline void __trace_map_to_unordered_map_invalidate(const void* __obj)
   if (__info) __info->__record_invalidate();
 }
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 #endif /* PROFCXX_PROFILER_MAP_TO_UNORDERED_MAP_H__ */

libstdc++-v3/include/profile/impl/profiler_node.h

@@ -51,7 +51,7 @@
 #include <execinfo.h>
 #endif
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 typedef const void* __object_t;
 typedef void* __instruction_address_t;
@@ -168,5 +168,5 @@ class __stack_info_base
   virtual const char* __get_id() const = 0;
 };
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 #endif /* PROFCXX_PROFILER_NODE_H__ */

libstdc++-v3/include/profile/impl/profiler_state.h

@@ -43,7 +43,7 @@
 #include <stdio.h>
 #endif
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 /** @brief Profiling mode on/off state.  */
@@ -103,5 +103,5 @@ inline void __turn_off()
   __state<0>::_S_diag_state->__turn_off();
 }
 
-} // end namespace __cxxprof_impl
+} // end namespace __gnu_profile
 #endif /* PROFCXX_PROFILER_STATE_H__ */

libstdc++-v3/include/profile/impl/profiler_trace.h

@@ -63,7 +63,7 @@
 #include "profile/impl/profiler_state.h"
 #include "profile/impl/profiler_node.h"
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 #if defined _GLIBCXX_PROFILE_THREADS && defined HAVE_TLS
@@ -367,7 +367,7 @@ void __trace_base<__object_info, __stack_info>::__write(FILE* __f)
     if (__it->second.__is_valid()) {
       fprintf(__f, __id);
       fprintf(__f, "|");
-      __cxxprof_impl::__write(__f, __it->first);
+      __gnu_profile::__write(__f, __it->first);
       fprintf(__f, "|");
       __it->second.__write(__f);
     }
@@ -428,7 +428,7 @@ struct __warn
     fprintf(__file,  __info.__warning_id);
     fprintf(__file, ": improvement = %d", __log_magnitude(__info.__magnitude));
     fprintf(__file, ": call stack = ");
-    __cxxprof_impl::__write(__file, __info.__context);
+    __gnu_profile::__write(__file, __info.__context);
     fprintf(__file, ": advice = %s\n", __info.__warning_message);
   }
 };
@@ -457,7 +457,7 @@ inline FILE* __open_output_file(const char* extension)
  * This can also be called directly by user code, including signal handlers.
  * It is protected against deadlocks by the reentrance guard in profiler.h.
  * However, when called from a signal handler that triggers while within
- * __cxxprof_impl (under the guarded zone), no output will be produced.
+ * __gnu_profile (under the guarded zone), no output will be produced.
  */
 inline void __report(void)
 {
@@ -559,6 +559,6 @@ inline bool __profcxx_init(void)
   return __is_on();
 }
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 
 #endif /* PROFCXX_PROFILER_TRACE_H__ */

libstdc++-v3/include/profile/impl/profiler_vector_size.h

@@ -52,7 +52,7 @@
 #include "profile/impl/profiler_state.h"
 #include "profile/impl/profiler_container_size.h"
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 /** @brief Hashtable size instrumentation trace producer.  */
@@ -107,6 +107,6 @@ inline void __trace_vector_size_resize(const void* __obj, size_t __from,
   __tables<0>::_S_vector_size->__resize(__obj, __from, __to);
 }
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 
 #endif /* PROFCXX_PROFILER_VECTOR_SIZE_H__ */

libstdc++-v3/include/profile/impl/profiler_vector_to_list.h

@@ -50,7 +50,7 @@
 #include "profile/impl/profiler_node.h"
 #include "profile/impl/profiler_trace.h"
 
-namespace __cxxprof_impl
+namespace __gnu_profile
 {
 
 /** @brief A vector-to-list instrumentation line in the object table.  */
@@ -314,5 +314,5 @@ inline void __trace_vector_to_list_resize(const void* __obj,
   __tables<0>::_S_vector_to_list->__resize(__obj, __from, __to);
 }
 
-} // namespace __cxxprof_impl
+} // namespace __gnu_profile
 #endif /* PROFCXX_PROFILER_VECTOR_TO_LIST_H__ */

libstdc++-v3/include/profile/list

@@ -35,7 +35,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief List wrapper with performance instrumentation.  */
+  /// Class std::list wrapper with performance instrumentation.
   template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
     class list
     : public _GLIBCXX_STD_D::list<_Tp, _Allocator>

libstdc++-v3/include/profile/map.h

@@ -41,7 +41,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Map wrapper with performance instrumentation.  */
+  /// Class std::map wrapper with performance instrumentation.
   template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
     class map

libstdc++-v3/include/profile/multimap.h

@@ -35,7 +35,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Multimap wrapper with performance instrumentation.  */
+  /// Class std::multimap wrapper with performance instrumentation.
   template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
     class multimap

libstdc++-v3/include/profile/multiset.h

@@ -35,7 +35,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Multiset wrapper with performance instrumentation.  */
+  /// Class std::multiset wrapper with performance instrumentation.
   template<typename _Key, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<_Key> >
     class multiset

libstdc++-v3/include/profile/set.h

@@ -35,7 +35,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Set wrapper with performance instrumentation.  */
+  /// Class std::set wrapper with performance instrumentation.
   template<typename _Key, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<_Key> >
     class set

libstdc++-v3/include/profile/unordered_map

@@ -51,7 +51,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Unordered_map wrapper with performance instrumentation.  */
+  /// Class std::unordered_map wrapper with performance instrumentation.
   template<typename _Key, typename _Tp,
 	   typename _Hash  = std::hash<_Key>,
 	   typename _Pred = std::equal_to<_Key>,
@@ -275,12 +275,13 @@ namespace __profile
      unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     { __x.swap(__y); }
 
+
 #undef _GLIBCXX_BASE
 #undef _GLIBCXX_STD_BASE
 #define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE
 
-  /** @brief Unordered_multimap wrapper with performance instrumentation.  */
+  /// Class std::unordered_multimap wrapper with performance instrumentation.
   template<typename _Key, typename _Tp,
 	   typename _Hash  = std::hash<_Key>,
 	   typename _Pred = std::equal_to<_Key>,
@@ -371,7 +372,8 @@ namespace __profile
 
       ~unordered_multimap()
       {
-        __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size());
+        __profcxx_hashtable_destruct(this, _Base::bucket_count(), 
+				     _Base::size());
         _M_profile_destruct();
       }
 
@@ -385,7 +387,8 @@ namespace __profile
       void
       clear()
       {
-        __profcxx_hashtable_destruct(this, _Base::bucket_count(), _Base::size());
+        __profcxx_hashtable_destruct(this, _Base::bucket_count(), 
+				     _Base::size());
         _M_profile_destruct();
         _Base::clear();
       }

libstdc++-v3/include/profile/vector

@@ -42,7 +42,7 @@ namespace std
 {
 namespace __profile
 {
-  /** @brief Vector wrapper with performance instrumentation.  */
+  /// Class std::vector wrapper with performance instrumentation.
   template<typename _Tp,
 	   typename _Allocator = std::allocator<_Tp> >
     class vector