profiler_list_to_slist.h: Fix formatting, other minor stylistic changes.

2010-06-22  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/profile/impl/profiler_list_to_slist.h: Fix formatting,
	other minor stylistic changes.
	* include/profile/impl/profiler_container_size.h: Likewise.
	* include/profile/impl/profiler_vector_size.h: Likewise.
	* include/profile/impl/profiler_hash_func.h: Likewise.
	* include/profile/impl/profiler_trace.h: Likewise.
	* include/profile/impl/profiler_list_to_vector.h: Likewise.
	* include/profile/impl/profiler_vector_to_list.h: Likewise.
	* include/profile/impl/profiler_state.h: Likewise.
	* include/profile/impl/profiler_map_to_unordered_map.h: Likewise.
	* include/profile/impl/profiler_hashtable_size.h: Likewise.
	* include/profile/impl/profiler_node.h: Likewise.

From-SVN: r161236

libstdc++-v3/ChangeLog

+2010-06-22  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	* include/profile/impl/profiler_list_to_slist.h: Fix formatting,
+	other minor stylistic changes.
+	* include/profile/impl/profiler_container_size.h: Likewise.
+	* include/profile/impl/profiler_vector_size.h: Likewise.
+	* include/profile/impl/profiler_hash_func.h: Likewise.
+	* include/profile/impl/profiler_trace.h: Likewise.
+	* include/profile/impl/profiler_list_to_vector.h: Likewise.
+	* include/profile/impl/profiler_vector_to_list.h: Likewise.
+	* include/profile/impl/profiler_state.h: Likewise.
+	* include/profile/impl/profiler_map_to_unordered_map.h: Likewise.
+	* include/profile/impl/profiler_hashtable_size.h: Likewise.
+	* include/profile/impl/profiler_node.h: Likewise.
+
 2010-06-22  Matthias Klose  <doko@ubuntu.com>
 
 	* python/libstdcxx/v6/printers.py: Don't use string exceptions.

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

@@ -55,166 +55,153 @@
 
 namespace __gnu_profile
 {
-
-/** @brief A container size instrumentation line in the object table.  */
-class __container_size_info: public __object_info_base 
-{
+  /** @brief A container size instrumentation line in the object table.  */
+  class __container_size_info 
+  : public __object_info_base 
+  {
   public:
-  __container_size_info();
-  __container_size_info(const __container_size_info& __o);
-  __container_size_info(__stack_t __stack, size_t __num);
-  virtual ~__container_size_info() {}
-
-  void __write(FILE* f) const;
-  float __magnitude() const { return static_cast<float>(_M_cost); }
-  const char* __advice() const;
+    __container_size_info()
+    : _M_init(0), _M_max(0), _M_min(0), _M_total(0), _M_item_min(0),
+      _M_item_max(0), _M_item_total(0), _M_count(0), _M_resize(0), _M_cost(0) 
+    { }
+
+    __container_size_info(const __container_size_info& __o)
+    : __object_info_base(__o), _M_init(__o._M_init), _M_max(__o._M_max),
+      _M_min(__o._M_min), _M_total(__o._M_total),
+      _M_item_min(__o._M_item_min), _M_item_max(__o._M_item_max),
+      _M_item_total(__o._M_item_total), _M_count(__o._M_count),
+      _M_resize(__o._M_resize), _M_cost(__o._M_cost)
+    { }
+
+    __container_size_info(__stack_t __stack, size_t __num)
+    : __object_info_base(__stack), _M_init(__num), _M_max(__num),
+      _M_min(0), _M_total(0), _M_item_min(0), _M_item_max(0),
+      _M_item_total(0), _M_count(0), _M_resize(0), _M_cost(0)
+    { }
+
+    virtual ~__container_size_info() { }
+
+    void
+    __write(FILE* __f) const
+    {
+      fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n", 
+	      _M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max, _M_total,
+	      _M_item_min, _M_item_max, _M_item_total);
+    }
 
-  void __merge(const __container_size_info& __o);
-  // Call if a container is destructed or cleaned.
-  void __destruct(size_t __num, size_t __inum);
-  // Estimate the cost of resize/rehash. 
-  float __resize_cost(size_t __from, size_t __to) { return __from; }
-  // Call if container is resized.
-  void __resize(size_t __from, size_t __to);
+    float
+    __magnitude() const
+    { return static_cast<float>(_M_cost); }
 
- private:
-  size_t _M_init;
-  size_t _M_max;  // range of # buckets
-  size_t _M_min;
-  size_t _M_total;
-  size_t _M_item_min;  // range of # items
-  size_t _M_item_max;
-  size_t _M_item_total;
-  size_t _M_count;
-  size_t _M_resize;
-  size_t _M_cost;
-};
-
-inline const char* __container_size_info::__advice() const
-{
+    const char*
+    __advice() const
+    {
       std::stringstream __message;
       if (_M_init < _M_item_max)
 	__message << "change initial container size from " << _M_init
 		  << " to " << _M_item_max;
-
       return strdup(__message.str().c_str());
-}
+    }
 
-inline void __container_size_info::__destruct(size_t __num, size_t __inum) 
-{
+    void
+    __merge(const __container_size_info& __o)
+    {
+      _M_init        = std::max(_M_init, __o._M_init);
+      _M_max         = std::max(_M_max, __o._M_max);
+      _M_item_max    = std::max(_M_item_max, __o._M_item_max);
+      _M_min         = std::min(_M_min, __o._M_min);
+      _M_item_min    = std::min(_M_item_min, __o._M_item_min);
+      _M_total      += __o._M_total;
+      _M_item_total += __o._M_item_total;
+      _M_count      += __o._M_count;
+      _M_cost       += __o._M_cost;
+      _M_resize     += __o._M_resize;
+    }
+
+    // Call if a container is destructed or cleaned.
+    void
+    __destruct(size_t __num, size_t __inum)
+    {
       _M_max = std::max(_M_max, __num);
       _M_item_max = std::max(_M_item_max, __inum);
-  if (_M_min == 0) {
+      if (_M_min == 0)
+	{
 	  _M_min = __num; 
 	  _M_item_min = __inum;
-  } else {
+	}
+      else
+	{
 	  _M_min = std::min(_M_min, __num);
 	  _M_item_min = std::min(_M_item_min, __inum);
 	}
       _M_total += __num;
       _M_item_total += __inum;
       _M_count += 1;
-}
+    }
 
-inline void __container_size_info::__resize(size_t __from, size_t __to) 
-{
+    // Estimate the cost of resize/rehash. 
+    float
+    __resize_cost(size_t __from, size_t)
+    { return __from; }
+
+    // Call if container is resized.
+    void
+    __resize(size_t __from, size_t __to)
+    {
       _M_cost += this->__resize_cost(__from, __to);
       _M_resize += 1;
       _M_max = std::max(_M_max, __to);
-}
+    }
 
-inline __container_size_info::__container_size_info(__stack_t __stack, 
-                                                    size_t __num)
-    : __object_info_base(__stack), _M_init(0), _M_max(0), _M_item_max(0), 
-      _M_min(0), _M_item_min(0), _M_total(0), _M_item_total(0), _M_cost(0), 
-      _M_count(0), _M_resize(0)
-{
-  _M_init = _M_max = __num;
-  _M_item_min = _M_item_max = _M_item_total = _M_total = 0;
-  _M_min = 0;
-  _M_count = 0;
-  _M_resize = 0;
-}
-
-inline void __container_size_info::__merge(const __container_size_info& __o)
-{
-  _M_init        = std::max(_M_init, __o._M_init);
-  _M_max         = std::max(_M_max, __o._M_max);
-  _M_item_max    = std::max(_M_item_max, __o._M_item_max);
-  _M_min         = std::min(_M_min, __o._M_min);
-  _M_item_min    = std::min(_M_item_min, __o._M_item_min);
-  _M_total      += __o._M_total;
-  _M_item_total += __o._M_item_total;
-  _M_count      += __o._M_count;
-  _M_cost       += __o._M_cost;
-  _M_resize     += __o._M_resize;
-}
+  private:
+    size_t _M_init;
+    size_t _M_max;  // range of # buckets
+    size_t _M_min;
+    size_t _M_total;
+    size_t _M_item_min;  // range of # items
+    size_t _M_item_max;
+    size_t _M_item_total;
+    size_t _M_count;
+    size_t _M_resize;
+    size_t _M_cost;
+  };
 
-inline __container_size_info::__container_size_info()
-    : _M_init(0), _M_max(0), _M_item_max(0), _M_min(0), _M_item_min(0),
-      _M_total(0), _M_item_total(0), _M_cost(0), _M_count(0), _M_resize(0)
-{
-}
 
-inline __container_size_info::__container_size_info(
-    const __container_size_info& __o)
-    : __object_info_base(__o)
-{
-  _M_init        = __o._M_init;
-  _M_max         = __o._M_max;
-  _M_item_max    = __o._M_item_max;
-  _M_min         = __o._M_min;
-  _M_item_min    = __o._M_item_min;
-  _M_total       = __o._M_total;
-  _M_item_total  = __o._M_item_total;
-  _M_cost        = __o._M_cost;
-  _M_count       = __o._M_count;
-  _M_resize      = __o._M_resize;
-}
-
-/** @brief A container size instrumentation line in the stack table.  */
-class __container_size_stack_info: public __container_size_info
-{
+  /** @brief A container size instrumentation line in the stack table.  */
+  class __container_size_stack_info
+  : public __container_size_info
+  {
   public:
     __container_size_stack_info(const __container_size_info& __o)
-      : __container_size_info(__o) {}
-};
+    : __container_size_info(__o) { }
+  };
 
-/** @brief Container size instrumentation trace producer.  */
-class __trace_container_size
+  
+  /** @brief Container size instrumentation trace producer.  */
+  class __trace_container_size
   : public __trace_base<__container_size_info, __container_size_stack_info> 
-{
+  {
   public:
-  ~__trace_container_size() {}
+    ~__trace_container_size() { }
+
     __trace_container_size()
-      : __trace_base<__container_size_info, __container_size_stack_info>() {};
+    : __trace_base<__container_size_info, __container_size_stack_info>() { };
 
     // Insert a new node at construct with object, callstack and initial size. 
-  void __insert(const __object_t __obj, __stack_t __stack, size_t __num);
-  // Call at destruction/clean to set container final size.
-  void __destruct(const void* __obj, size_t __num, size_t __inum);
-  void __construct(const void* __obj, size_t __inum);
-  // Call at resize to set resize/cost information.
-  void __resize(const void* __obj, int __from, int __to);
-};
+    void
+    __insert(const __object_t __obj, __stack_t __stack, size_t __num)
+    { __add_object(__obj, __container_size_info(__stack, __num)); }
 
-inline void __trace_container_size::__insert(const __object_t __obj,
-                                             __stack_t __stack, size_t __num)
-{
-  __add_object(__obj, __container_size_info(__stack, __num));
-}
-
-inline void __container_size_info::__write(FILE* __f) const
-{
-  fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n", 
-          _M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max, _M_total,
-          _M_item_min, _M_item_max, _M_item_total);
-}
+    // XXX Undefined?
+    void
+    __construct(const void* __obj, size_t __inum);
   
-inline void __trace_container_size::__destruct(const void* __obj, 
-                                               size_t __num, size_t __inum)
-{
-  if (!__is_on()) return;
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj, size_t __num, size_t __inum)
+    {
+      if (!__is_on())
+	return;
 
       __object_t __obj_handle = static_cast<__object_t>(__obj);
 
@@ -224,19 +211,22 @@ inline void __trace_container_size::__destruct(const void* __obj,
 
       __object_info->__destruct(__num, __inum);
       __retire_object(__obj_handle);
-}
+    }
 
-inline void __trace_container_size::__resize(const void* __obj, int __from, 
-                                             int __to)
-{
-  if (!__is_on()) return;
+    // Call at resize to set resize/cost information.
+    void
+    __resize(const void* __obj, int __from, int __to)
+    {
+      if (!__is_on())
+	return;
 
       __container_size_info* __object_info = __get_object_info(__obj);
       if (!__object_info)
 	return;
 
       __object_info->__resize(__from, __to);
-}
+    }
+  };
 
 } // namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H */

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

@@ -52,95 +52,92 @@
 
 namespace __gnu_profile
 {
-
-/** @brief A hash performance instrumentation line in the object table.  */
-class __hashfunc_info: public __object_info_base
-{
+  /** @brief A hash performance instrumentation line in the object table.  */
+  class __hashfunc_info 
+  : public __object_info_base
+  {
   public:
     __hashfunc_info()
-      :_M_longest_chain(0), _M_accesses(0), _M_hops(0) {}
-  __hashfunc_info(const __hashfunc_info& o);
-  __hashfunc_info(__stack_t __stack)
-      : __object_info_base(__stack),
-        _M_longest_chain(0), _M_accesses(0), _M_hops(0){} 
-  virtual ~__hashfunc_info() {}
+    : _M_longest_chain(0), _M_accesses(0), _M_hops(0) { }
   
-  void __merge(const __hashfunc_info& __o);
-  void __destruct(size_t __chain, size_t __accesses, size_t __hops);
-  void __write(FILE* __f) const;
-  float __magnitude() const { return static_cast<float>(_M_hops); }
-  const char* __advice() const { return strdup("change hash function"); }
+    __hashfunc_info(const __hashfunc_info& __o)
+      : __object_info_base(__o), _M_longest_chain(__o._M_longest_chain),
+	_M_accesses(__o._M_accesses), _M_hops(__o._M_hops) { }
   
-private:
-  size_t _M_longest_chain;
-  size_t _M_accesses;
-  size_t _M_hops;
-};
+    __hashfunc_info(__stack_t __stack)
+    : __object_info_base(__stack),
+      _M_longest_chain(0), _M_accesses(0), _M_hops(0){ }
  
-inline __hashfunc_info::__hashfunc_info(const __hashfunc_info& __o)
-    : __object_info_base(__o)
-{
-  _M_longest_chain = __o._M_longest_chain;
-  _M_accesses      = __o._M_accesses;
-  _M_hops          = __o._M_hops;
-}
+    virtual ~__hashfunc_info() {}
 
-inline void __hashfunc_info::__merge(const __hashfunc_info& __o)
-{
+    void
+    __merge(const __hashfunc_info& __o)
+    {
       _M_longest_chain  = std::max(_M_longest_chain, __o._M_longest_chain);
       _M_accesses      += __o._M_accesses;
       _M_hops          += __o._M_hops;
-}
+    }
 
-inline void __hashfunc_info::__destruct(size_t __chain, size_t __accesses, 
-                                        size_t __hops)
-{ 
+    void
+    __destruct(size_t __chain, size_t __accesses, size_t __hops)
+    { 
       _M_longest_chain  = std::max(_M_longest_chain, __chain);
       _M_accesses      += __accesses;
       _M_hops          += __hops;
-}
+    }
 
-/** @brief A hash performance instrumentation line in the stack table.  */
-class __hashfunc_stack_info: public __hashfunc_info {
- public:
-  __hashfunc_stack_info(const __hashfunc_info& __o) : __hashfunc_info(__o) {}
-};
+    void
+    __write(FILE* __f) const
+    { fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, _M_accesses, _M_longest_chain); }
 
-/** @brief Hash performance instrumentation producer.  */
-class __trace_hash_func
-    : public __trace_base<__hashfunc_info, __hashfunc_stack_info> 
-{
+    float
+    __magnitude() const
+    { return static_cast<float>(_M_hops); }
+
+    const char*
+    __advice() const
+    { return strdup("change hash function"); }
+
+  private:
+    size_t _M_longest_chain;
+    size_t _M_accesses;
+    size_t _M_hops;
+  };
+
+
+  /** @brief A hash performance instrumentation line in the stack table.  */
+  class __hashfunc_stack_info 
+  : public __hashfunc_info
+  {
   public:
-  __trace_hash_func();
-  ~__trace_hash_func() {}
+    __hashfunc_stack_info(const __hashfunc_info& __o)
+    : __hashfunc_info(__o) { }
+  };
 
-  // Insert a new node at construct with object, callstack and initial size. 
-  void __insert(__object_t __obj, __stack_t __stack);
-  // Call at destruction/clean to set container final size.
-  void __destruct(const void* __obj, size_t __chain,
-                  size_t __accesses, size_t __hops);
-};
 
-inline __trace_hash_func::__trace_hash_func()
+  /** @brief Hash performance instrumentation producer.  */
+  class __trace_hash_func
+  : public __trace_base<__hashfunc_info, __hashfunc_stack_info> 
+  {
+  public:
+    __trace_hash_func()
     : __trace_base<__hashfunc_info, __hashfunc_stack_info>()
-{
-  __id = "hash-distr";
-}
+    { __id = "hash-distr"; }
 
-inline void __trace_hash_func::__insert(__object_t __obj, __stack_t __stack)
-{
-  __add_object(__obj, __hashfunc_info(__stack));
-}
+    ~__trace_hash_func() {}
     
-inline void __hashfunc_info::__write(FILE* __f) const
-{
-  fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, _M_accesses, _M_longest_chain);
-}
+    // Insert a new node at construct with object, callstack and initial size.
+    void
+    __insert(__object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __hashfunc_info(__stack)); }
 
-inline void __trace_hash_func::__destruct(const void* __obj, size_t __chain,
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj, size_t __chain,
 	       size_t __accesses, size_t __hops)
-{
-  if (!__is_on()) return;
+    {
+      if (!__is_on())
+	return;
 
       // First find the item from the live objects and update the informations.
       __hashfunc_info* __objs = __get_object_info(__obj);
@@ -149,37 +146,43 @@ inline void __trace_hash_func::__destruct(const void* __obj, size_t __chain,
 
       __objs->__destruct(__chain, __accesses, __hops);
       __retire_object(__obj);
-}
+    }
+  };
 
-inline void __trace_hash_func_init()
-{
-  _GLIBCXX_PROFILE_DATA(_S_hash_func) = new __trace_hash_func();
-}
 
-inline void __trace_hash_func_report(FILE* __f,
-                                     __warning_vector_t& __warnings)
-{
-  if (_GLIBCXX_PROFILE_DATA(_S_hash_func)) {
+  inline void
+  __trace_hash_func_init()
+  { _GLIBCXX_PROFILE_DATA(_S_hash_func) = new __trace_hash_func(); }
+
+  inline void
+  __trace_hash_func_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_hash_func))
+      {
 	_GLIBCXX_PROFILE_DATA(_S_hash_func)->__collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_hash_func)->__write(__f);
       }
-}
+  }
 
-inline void __trace_hash_func_construct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_hash_func_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_hash_func)->__insert(__obj, __get_stack());
-}
+  }
 
-inline void __trace_hash_func_destruct(const void* __obj, size_t __chain,
+  inline void
+  __trace_hash_func_destruct(const void* __obj, size_t __chain,
 			     size_t __accesses, size_t __hops)
-{
-  if (!__profcxx_init()) return;
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_hash_func)->__destruct(__obj, __chain, __accesses, 
 						    __hops);
-}
+  }
 
 } // namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H */

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

 // -*- C++ -*-
 //
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010 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
@@ -54,54 +54,60 @@
 
 namespace __gnu_profile
 {
-
-/** @brief Hashtable size instrumentation trace producer.  */
-class __trace_hashtable_size : public __trace_container_size
-{
- public:
-  __trace_hashtable_size() : __trace_container_size()
+  /** @brief Hashtable size instrumentation trace producer.  */
+  class __trace_hashtable_size
+  : public __trace_container_size
   {
-    __id = "hashtable-size";
-  }
-};
+  public:
+    __trace_hashtable_size()
+    : __trace_container_size()
+    { __id = "hashtable-size"; }
+  };
 
-inline void __trace_hashtable_size_init()
-{
-  _GLIBCXX_PROFILE_DATA(_S_hashtable_size) = new __trace_hashtable_size();
-}
+  inline void
+  __trace_hashtable_size_init()
+  { _GLIBCXX_PROFILE_DATA(_S_hashtable_size) = new __trace_hashtable_size(); }
 
-inline void __trace_hashtable_size_report(FILE* __f, 
-                                          __warning_vector_t& __warnings)
-{
-  if (_GLIBCXX_PROFILE_DATA(_S_hashtable_size)) {
-    _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__collect_warnings(__warnings);
+  inline void
+  __trace_hashtable_size_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_hashtable_size))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_hashtable_size)->
+	  __collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__write(__f);
       }
-}
+  }
 
-inline void __trace_hashtable_size_construct(const void* __obj, size_t __num)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_hashtable_size_construct(const void* __obj, size_t __num)
+  {
+    if (!__profcxx_init())
+      return;
   
     _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__insert(__obj, __get_stack(),
 						       __num);
-}
+  }
 
-inline void __trace_hashtable_size_destruct(const void* __obj, size_t __num, 
+  inline void
+  __trace_hashtable_size_destruct(const void* __obj, size_t __num, 
 				  size_t __inum)
-{
-  if (!__profcxx_init()) return;
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__destruct(__obj, __num, __inum);
-}
+  }
 
-inline void __trace_hashtable_size_resize(const void* __obj, size_t __from, 
+  inline void
+  __trace_hashtable_size_resize(const void* __obj, size_t __from, 
 				size_t __to)
-{
-  if (!__profcxx_init()) return;
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__resize(__obj, __from, __to);
-}
+  }
 
 } // namespace __gnu_profile
 

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

 // -*- C++ -*-
 //
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010 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
@@ -52,66 +52,111 @@
 
 namespace __gnu_profile
 {
-
-class __list2slist_info: public __object_info_base
-{
+  class __list2slist_info 
+  : public __object_info_base
+  {
   public:
-  __list2slist_info() : _M_rewind(false), _M_operations(0) {}
+    __list2slist_info()
+    : _M_rewind(false), _M_operations(0) { }
+  
     __list2slist_info(__stack_t __stack)
-      : _M_rewind(false), _M_operations(0),__object_info_base(__stack) {}
-  virtual ~__list2slist_info() {}
-  __list2slist_info(const __list2slist_info& __o) : __object_info_base(__o)
-  { _M_rewind = __o._M_rewind; _M_operations = __o._M_operations; }
+    : __object_info_base(__stack), _M_rewind(false), _M_operations(0) { }
+
+    virtual ~__list2slist_info() { }
+
+    __list2slist_info(const __list2slist_info& __o)
+    : __object_info_base(__o), _M_rewind(__o._M_rewind),
+      _M_operations(__o._M_operations) { }
+  
     // XXX: the magnitude should be multiplied with a constant factor F,
     // where F is 1 when the malloc size class of list nodes is different
     // from the malloc size class of slist nodes.  When they fall into the same
     // class, the only slist benefit is from having to set fewer links, so
     // the factor F should be much smaller, closer to 0 than to 1.
-  // This could be implemented by passing the size classes in the config file.
-  // For now, we always assume F to be 1.
-  float __magnitude() const
-  { if (!_M_rewind) return _M_operations; else return 0; }
-  void __merge(const __list2slist_info& __o) {};
-  void __write(FILE* __f) const;
-  const char* __advice() const
+    // This could be implemented by passing the size classes in the config 
+    // file.  For now, we always assume F to be 1.
+
+    float
+    __magnitude() const
+    {
+      if (!_M_rewind)
+	return _M_operations;
+      else
+	return 0;
+    }
+    
+    void
+    __merge(const __list2slist_info&) { };
+
+    void
+    __write(FILE* __f) const
+    { fprintf(__f, "%s\n", _M_rewind ? "invalid" : "valid"); }
+
+    const char*
+    __advice() const
     { return strdup("change std::list to std::forward_list"); }
-  void __opr_rewind() { _M_rewind = true; _M_valid = false;}
-  void __record_operation() { _M_operations++; }
-  bool __has_rewind() { return _M_rewind; }
 
-private:
+    void
+    __opr_rewind()
+    {
+      _M_rewind = true;
+      _M_valid = false;
+    }
+
+    void
+    __record_operation()
+    { _M_operations++; }
+
+    bool
+    __has_rewind()
+    { return _M_rewind; }
+
+  private:
     bool _M_rewind;
     size_t _M_operations;
-};
+  };
 
-class __list2slist_stack_info: public __list2slist_info {
+  class __list2slist_stack_info
+  : public __list2slist_info
+  {
   public:
     __list2slist_stack_info(const __list2slist_info& __o) 
-      : __list2slist_info(__o) {}
-};
+    : __list2slist_info(__o) { }
+  };
 
-class __trace_list_to_slist
+  class __trace_list_to_slist
   : public __trace_base<__list2slist_info, __list2slist_stack_info> 
-{
+  {
   public:
-  ~__trace_list_to_slist() {}
+    ~__trace_list_to_slist() { }
+
     __trace_list_to_slist()
     : __trace_base<__list2slist_info, __list2slist_stack_info>()
     { __id = "list-to-slist"; }
-  void __opr_rewind(const void* __obj);
-  void __record_operation(const void* __obj);
-  void __insert(const __object_t __obj, __stack_t __stack)
-  { __add_object(__obj, __list2slist_info(__stack)); }
-  void __destruct(const void* __obj);
-};
 
-inline void __list2slist_info::__write(FILE* __f) const
-{
-  fprintf(__f, "%s\n", _M_rewind ? "invalid" : "valid");
-}
+    void
+    __opr_rewind(const void* __obj)
+    {
+      __list2slist_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__opr_rewind();
+    }
 
-inline void __trace_list_to_slist::__destruct(const void* __obj)
-{
+    void
+    __record_operation(const void* __obj)
+    {
+      __list2slist_info* __res = __get_object_info(__obj);
+      if (__res)
+	__res->__record_operation();
+    }
+
+    void
+    __insert(const __object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __list2slist_info(__stack)); }
+  
+    void
+    __destruct(const void* __obj)
+    {
       if (!__is_on())
 	return;
 
@@ -120,63 +165,60 @@ inline void __trace_list_to_slist::__destruct(const void* __obj)
 	return;
 
       __retire_object(__obj);
-}
+    }
+  };
 
-inline void __trace_list_to_slist_init()
-{
-  _GLIBCXX_PROFILE_DATA(_S_list_to_slist) = new __trace_list_to_slist();
-}
 
-inline void __trace_list_to_slist_report(FILE* __f, 
-                                       __warning_vector_t& __warnings)
-{
-  if (_GLIBCXX_PROFILE_DATA(_S_list_to_slist)) {
-    _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__collect_warnings(__warnings);
+  inline void
+  __trace_list_to_slist_init()
+  { _GLIBCXX_PROFILE_DATA(_S_list_to_slist) = new __trace_list_to_slist(); }
+
+  inline void
+  __trace_list_to_slist_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_list_to_slist))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_list_to_slist)->
+	  __collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__write(__f);
       }
-}
-
-inline void __trace_list_to_slist::__opr_rewind(const void* __obj)
-{
-  __list2slist_info* __res = __get_object_info(__obj);
-  if (__res)
-    __res->__opr_rewind();
-}
-
-inline void __trace_list_to_slist::__record_operation(const void* __obj)
-{
-  __list2slist_info* __res = __get_object_info(__obj);
-  if (__res)
-    __res->__record_operation();
-}
+  }
 
-inline void __trace_list_to_slist_rewind(const void* __obj) 
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_slist_rewind(const void* __obj) 
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__opr_rewind(__obj);
-}
+  }
 
-inline void __trace_list_to_slist_operation(const void* __obj) 
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_slist_operation(const void* __obj) 
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__record_operation(__obj);
-}
+  }
 
-inline void __trace_list_to_slist_construct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_slist_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__insert(__obj, __get_stack());
-}
+  }
 
-inline void __trace_list_to_slist_destruct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_slist_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__destruct(__obj);
-}
+  }
 
 } // namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H */

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

@@ -54,70 +54,31 @@
 
 namespace __gnu_profile
 {
-
-/** @brief A list-to-vector instrumentation line in the object table.  */
-class __list2vector_info: public __object_info_base
-{
+  /** @brief A list-to-vector instrumentation line in the object table.  */
+  class __list2vector_info 
+  : public __object_info_base
+  {
   public:
     __list2vector_info()
-      :_M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0),
-       _M_vector_cost(0), _M_valid(true), _M_max_size(0) {}
+    : _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0),
+      _M_vector_cost(0), _M_valid(true), _M_max_size(0) { }
+
     __list2vector_info(__stack_t __stack)
     : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0),
       _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true),
-        _M_max_size(0) {}
-  virtual ~__list2vector_info() {}
-  __list2vector_info(const __list2vector_info& __o);
-  void __merge(const __list2vector_info& __o);
-  void __write(FILE* __f) const;
-  float __magnitude() const { return _M_list_cost - _M_vector_cost; }
-  const char* __advice() const;
-  size_t __shift_count() { return _M_shift_count; }
-  size_t __iterate()   { return _M_iterate; }
-  float __list_cost() { return _M_list_cost; }
-  size_t __resize() { return _M_resize; }
-  void __set_list_cost(float __lc) { _M_list_cost = __lc; }
-  void __set_vector_cost(float __vc) { _M_vector_cost = __vc; }
-  bool __is_valid() { return _M_valid; }
-  void __set_invalid() { _M_valid = false; }
-
-  void __opr_insert(size_t __shift, size_t __size);
-  void __opr_iterate(size_t __num) { _M_iterate += __num;}
-
-  void __resize(size_t __from, size_t __to);
-
-private:
-  size_t _M_shift_count;
-  size_t _M_iterate;
-  size_t _M_resize;
-  float _M_list_cost;
-  float _M_vector_cost;
-  bool  _M_valid;
-  size_t _M_max_size;
-};
+      _M_max_size(0) { }
 
-inline __list2vector_info::__list2vector_info(const __list2vector_info& __o)
-    : __object_info_base(__o)
-{
-  _M_shift_count  = __o._M_shift_count;
-  _M_iterate      = __o._M_iterate;
-  _M_vector_cost  = __o._M_vector_cost;
-  _M_list_cost    = __o._M_list_cost;
-  _M_valid        = __o._M_valid;
-  _M_resize       = __o._M_resize;
-  _M_max_size     = __o._M_max_size;
-}
-
-inline const char* __list2vector_info::__advice() const {
-  std::stringstream __sstream;
-  __sstream 
-      << "change std::list to std::vector and its initial size from 0 to "
-      << _M_max_size;
-  return strdup(__sstream.str().c_str());
-}
+    virtual ~__list2vector_info() { }
 
-inline void __list2vector_info::__merge(const __list2vector_info& __o)
-{
+    __list2vector_info(const __list2vector_info& __o)
+    : __object_info_base(__o), _M_shift_count(__o._M_shift_count),
+      _M_iterate(__o._M_iterate), _M_resize(__o._M_resize),
+      _M_list_cost(__o._M_list_cost), _M_vector_cost(__o._M_vector_cost),
+      _M_valid(__o._M_valid), _M_max_size(__o._M_max_size) { }
+
+    void
+    __merge(const __list2vector_info& __o)
+    {
       _M_shift_count  += __o._M_shift_count;
       _M_iterate      += __o._M_iterate;
       _M_vector_cost  += __o._M_vector_cost;
@@ -125,84 +86,113 @@ inline void __list2vector_info::__merge(const __list2vector_info& __o)
       _M_valid        &= __o._M_valid;
       _M_resize       += __o._M_resize;
       _M_max_size     = std::max( _M_max_size, __o._M_max_size);
-}
+    }
 
-inline void __list2vector_info::__opr_insert(size_t __shift, size_t __size) 
-{
+    void
+    __write(FILE* __f) const
+    {
+      fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count, _M_resize,
+	      _M_iterate, _M_vector_cost, _M_list_cost);
+    }
+
+    float
+    __magnitude() const
+    { return _M_list_cost - _M_vector_cost; }
+  
+    const char*
+    __advice() const
+    {
+      std::stringstream __sstream;
+      __sstream 
+	<< "change std::list to std::vector and its initial size from 0 to "
+	<< _M_max_size;
+      return strdup(__sstream.str().c_str());
+    }
+
+    size_t
+    __shift_count()
+    { return _M_shift_count; }
+  
+    size_t
+    __iterate()
+    { return _M_iterate; }
+  
+    float
+    __list_cost()
+    { return _M_list_cost; }
+  
+    size_t
+    __resize()
+    { return _M_resize; }
+  
+    void
+    __set_list_cost(float __lc)
+    { _M_list_cost = __lc; }
+    
+    void
+    __set_vector_cost(float __vc)
+    { _M_vector_cost = __vc; }
+    
+    bool
+    __is_valid()
+    { return _M_valid; }
+    
+    void
+    __set_invalid()
+    { _M_valid = false; }
+
+    void
+    __opr_insert(size_t __shift, size_t __size)
+    {
       _M_shift_count += __shift;
       _M_max_size = std::max(_M_max_size, __size);
-}
+    }
 
-inline void __list2vector_info::__resize(size_t __from, size_t __to)
-{
-  _M_resize += __from;
-}
+    void
+    __opr_iterate(size_t __num)
+    { _M_iterate += __num;}
+
+    void
+    __resize(size_t __from, size_t)
+    { _M_resize += __from; }
+
+  private:
+    size_t _M_shift_count;
+    size_t _M_iterate;
+    size_t _M_resize;
+    float _M_list_cost;
+    float _M_vector_cost;
+    bool  _M_valid;
+    size_t _M_max_size;
+  };
 
-class __list2vector_stack_info: public __list2vector_info {
+  class __list2vector_stack_info 
+  : public __list2vector_info
+  {
   public:
     __list2vector_stack_info(const __list2vector_info& __o) 
     : __list2vector_info(__o) {}
-};
+  };
 
-class __trace_list_to_vector
+  class __trace_list_to_vector
   : public __trace_base<__list2vector_info, __list2vector_stack_info> 
-{
+  {
   public:
-  __trace_list_to_vector();
-  ~__trace_list_to_vector() {}
-
-  // Insert a new node at construct with object, callstack and initial size. 
-  void __insert(__object_t __obj, __stack_t __stack);
-  // Call at destruction/clean to set container final size.
-  void __destruct(const void* __obj);
-
-  // Find the node in the live map.
-  __list2vector_info* __find(const void* __obj);
-
-  // Collect cost of operations.
-  void __opr_insert(const void* __obj, size_t __shift, size_t __size);
-  void __opr_iterate(const void* __obj, size_t __num);
-  void __invalid_operator(const void* __obj);
-  void __resize(const void* __obj, size_t __from, size_t __to);
-  float __vector_cost(size_t __shift, size_t __iterate);
-  float __list_cost(size_t __shift, size_t __iterate);
-};
-
-inline __trace_list_to_vector::__trace_list_to_vector()
+    __trace_list_to_vector()
     : __trace_base<__list2vector_info, __list2vector_stack_info>()
-{
-  __id = "list-to-vector";
-}
-
-inline void __trace_list_to_vector::__insert(__object_t __obj,
-                                             __stack_t __stack)
-{
-  __add_object(__obj, __list2vector_info(__stack));
-}
-
-inline void __list2vector_info::__write(FILE* __f) const
-{
-  fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n",
-          _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost);
-}
+    { __id = "list-to-vector"; }
 
-inline float __trace_list_to_vector::__vector_cost(size_t __shift, 
-                                                   size_t __iterate)
-{
-  // The resulting vector will use a 'reserve' method.
-  return __shift * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value + 
-      __iterate * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value; 
-}
+    ~__trace_list_to_vector() { }
 
-inline float __trace_list_to_vector::__list_cost(size_t __shift, 
-                                                 size_t __iterate)
-{
-  return __shift * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value + 
-      __iterate * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value; 
-}
+    // Insert a new node at construct with object, callstack and initial size.
+    void
+    __insert(__object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __list2vector_info(__stack)); }
 
-inline void __trace_list_to_vector::__destruct(const void* __obj)
-{
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj)
+    {
       if (!__is_on())
 	return;
 
@@ -215,99 +205,136 @@ inline void __trace_list_to_vector::__destruct(const void* __obj)
       __res->__set_vector_cost(__vc);
       __res->__set_list_cost(__lc);
       __retire_object(__obj);
-}
+    }
 
-inline void __trace_list_to_vector::__opr_insert(const void* __obj, 
-                                                 size_t __shift, size_t __size)
-{
+    // Find the node in the live map.
+    __list2vector_info* __find(const void* __obj);
+
+    // Collect cost of operations.
+    void
+    __opr_insert(const void* __obj, size_t __shift, size_t __size)
+    {
       __list2vector_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__opr_insert(__shift, __size);
-}
+    }
 
-inline void __trace_list_to_vector::__opr_iterate(const void* __obj,
-                                                  size_t __num)
-{
+    void
+    __opr_iterate(const void* __obj, size_t __num)
+    {
       __list2vector_info* __res = __get_object_info(__obj);
-  if (__res) {
+      if (__res)
 	__res->__opr_iterate(__num);
     }
-}
 
-inline void __trace_list_to_vector::__invalid_operator(const void* __obj)
-{
+    void
+    __invalid_operator(const void* __obj)
+    {
       __list2vector_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__set_invalid();
-}
+    }
 
-inline void __trace_list_to_vector::__resize(const void* __obj, size_t __from, 
-                                             size_t __to)
-{
+    void
+    __resize(const void* __obj, size_t __from, size_t __to)
+    {
       __list2vector_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__resize(__from, __to);
-}
+    }
 
-inline void __trace_list_to_vector_init()
-{
-  _GLIBCXX_PROFILE_DATA(_S_list_to_vector) = new __trace_list_to_vector();
-}
+    float
+    __vector_cost(size_t __shift, size_t __iterate)
+    {
+      // The resulting vector will use a 'reserve' method.
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value); 
+    }
 
-inline void __trace_list_to_vector_report(FILE* __f, 
-                                          __warning_vector_t& __warnings)
-{
-  if (_GLIBCXX_PROFILE_DATA(_S_list_to_vector)) {
-    _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__collect_warnings(__warnings);
+    float
+    __list_cost(size_t __shift, size_t __iterate)
+    {
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value); 
+    }
+  };
+
+
+  inline void
+  __trace_list_to_vector_init()
+  { _GLIBCXX_PROFILE_DATA(_S_list_to_vector) = new __trace_list_to_vector(); }
+
+  inline void
+  __trace_list_to_vector_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_list_to_vector))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_list_to_vector)->
+	  __collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__write(__f);
       }
-}
+  }
 
-inline void __trace_list_to_vector_construct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_vector_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__insert(__obj, __get_stack());
-}
+  }
 
-inline void __trace_list_to_vector_destruct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_vector_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__destruct(__obj);
-}
+  }
 
-inline void __trace_list_to_vector_insert(const void* __obj, 
+  inline void
+  __trace_list_to_vector_insert(const void* __obj, 
 				size_t __shift, size_t __size)
-{
-  if (!__profcxx_init()) return;
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_insert(__obj, __shift, 
 							   __size);
-}
-
+  }
 
-inline void __trace_list_to_vector_iterate(const void* __obj, size_t __num = 1)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_vector_iterate(const void* __obj, size_t __num = 1)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_iterate(__obj, __num);
-}
+  }
 
-inline void __trace_list_to_vector_invalid_operator(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_list_to_vector_invalid_operator(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__invalid_operator(__obj);
-}
+  }
 
-inline void __trace_list_to_vector_resize(const void* __obj, 
+  inline void
+  __trace_list_to_vector_resize(const void* __obj, 
 				size_t __from, size_t __to)
-{
-  if (!__profcxx_init()) return;
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__resize(__obj, __from, __to);
-}
+  }
 
 } // namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H__ */

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

 // -*- C++ -*-
 //
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010 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
@@ -52,241 +52,255 @@
 
 namespace __gnu_profile
 {
-
-inline int __log2(size_t __size)
-{
-  for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0; -- __bit_count) 
+  inline int
+  __log2(size_t __size)
   {
-    if ((2 << __bit_count) & __size) {
+    for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0;
+	 -- __bit_count) 
+      if ((2 << __bit_count) & __size)
 	return __bit_count;
-    }
-  }
     return 0;
-}
-
-inline float __map_insert_cost(size_t __size)
-{
-  return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value 
-          * static_cast<float>(__log2(__size)));
-}
-
-inline float __map_erase_cost(size_t __size)
-{
-  return (_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor).__value
-          * static_cast<float>(__log2(__size)));
-}
-
-inline float __map_find_cost(size_t __size)
-{
-  return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value
-          * static_cast<float>(__log2(__size)));
-}
+  }
 
-/** @brief A map-to-unordered_map instrumentation line in the object table.  */
-class __map2umap_info: public __object_info_base
-{
+  inline float
+  __map_insert_cost(size_t __size)
+  { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value 
+	    * static_cast<float>(__log2(__size))); }
+
+  inline float
+  __map_erase_cost(size_t __size)
+  { return (_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor).__value
+	    * static_cast<float>(__log2(__size))); }
+
+  inline float
+  __map_find_cost(size_t __size)
+  { return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value
+	    * static_cast<float>(__log2(__size))); }
+
+  /** @brief A map-to-unordered_map instrumentation line in the 
+      object table.  */
+  class __map2umap_info 
+  : public __object_info_base
+  {
   public:
     __map2umap_info()
     : _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0),
-        _M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) {}
+      _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
+    
     __map2umap_info(__stack_t __stack)
     : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), 
-        _M_iterate(0), _M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) {} 
-  virtual ~__map2umap_info() {}
-  __map2umap_info(const __map2umap_info& o);
-  void __merge(const __map2umap_info& o);
-  void __write(FILE* __f) const;
-  float __magnitude() const { return _M_map_cost - _M_umap_cost; }
-  const char* __advice() const;
-
-  void __record_insert(size_t __size, size_t __count);
-  void __record_erase(size_t __size, size_t __count);
-  void __record_find(size_t __size);
-  void __record_iterate(size_t __count);
-  void __record_invalidate();
+      _M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
 
- private:
-  size_t _M_insert;
-  size_t _M_erase;
-  size_t _M_find;
-  size_t _M_iterate;
-  float _M_umap_cost;
-  float _M_map_cost;
-  bool  _M_valid;
-};
+    virtual ~__map2umap_info() { }
 
-inline const char* __map2umap_info::__advice() const
-{
-  return strdup("change std::map to std::unordered_map");
-}
-
-inline __map2umap_info::__map2umap_info(const __map2umap_info& __o)
-    : __object_info_base(__o), 
-      _M_insert(__o._M_insert),
-      _M_erase(__o._M_erase),
-      _M_find(__o._M_find),
-      _M_iterate(__o._M_iterate),
-      _M_map_cost(__o._M_map_cost),
-      _M_umap_cost(__o._M_umap_cost),
-      _M_valid(__o._M_valid)
-{}
-
-inline void __map2umap_info::__merge(const __map2umap_info& __o)
-{
+    __map2umap_info(const __map2umap_info& __o)
+    : __object_info_base(__o), _M_insert(__o._M_insert),
+      _M_erase(__o._M_erase), _M_find(__o._M_find),
+      _M_iterate(__o._M_iterate), _M_umap_cost(__o._M_umap_cost),
+      _M_map_cost(__o._M_map_cost), _M_valid(__o._M_valid) { }
+
+    void
+    __merge(const __map2umap_info& __o)
+    {
       _M_insert    += __o._M_insert;
       _M_erase     += __o._M_erase;
       _M_find      += __o._M_find;
-  _M_map_cost  += __o._M_map_cost;
       _M_umap_cost += __o._M_umap_cost;
+      _M_map_cost  += __o._M_map_cost;
       _M_valid     &= __o._M_valid;
-}
+    }
 
-inline void __map2umap_info:: __record_insert(size_t __size, size_t __count)
-{
+    void
+    __write(FILE* __f) const
+    {
+      fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f %s\n",
+	      _M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost,
+	      _M_umap_cost, _M_valid ? "valid" : "invalid");
+    }
+    
+    float
+    __magnitude() const
+    { return _M_map_cost - _M_umap_cost; }
+
+    const char*
+    __advice() const
+    { return strdup("change std::map to std::unordered_map"); }
+
+    void
+    __record_insert(size_t __size, size_t __count)
+    {
       _M_insert += __count;
       _M_map_cost += __count * __map_insert_cost(__size);
-  _M_umap_cost += (__count
+      _M_umap_cost
+	+= (__count
 	    * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
-}
+    }
 
-inline void __map2umap_info:: __record_erase(size_t __size, size_t __count)
-{
+    void
+    __record_erase(size_t __size, size_t __count)
+    {
       _M_erase += __count;
       _M_map_cost += __count * __map_erase_cost(__size);
-  _M_umap_cost += (__count
+      _M_umap_cost
+	+= (__count
 	    * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
-}
+    }
 
-inline void __map2umap_info:: __record_find(size_t __size)
-{
+    void
+    __record_find(size_t __size)
+    {
       _M_find += 1;
       _M_map_cost += __map_find_cost(__size);
       _M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value;
-}
+    }
 
-inline void __map2umap_info:: __record_iterate(size_t __count)
-{
+    void
+    __record_iterate(size_t __count)
+    {
       _M_iterate += __count;
-  _M_map_cost += (__count
+      _M_map_cost
+	+= (__count
 	    * _GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor).__value);
-  _M_umap_cost += (
-      __count * _GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor).__value);
-}
+      _M_umap_cost
+	+= (__count
+	    * _GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor).__value);
+    }
 
-inline void __map2umap_info:: __record_invalidate()
-{
-  _M_valid = false;
-}
+    void
+    __record_invalidate()
+    { _M_valid = false; }
 
-inline void __map2umap_info::__write(FILE* __f) const
-{
-  fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f %s\n",
-          _M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost, _M_umap_cost,
-          _M_valid ? "valid" : "invalid");
-}
+  private:
+    size_t _M_insert;
+    size_t _M_erase;
+    size_t _M_find;
+    size_t _M_iterate;
+    float _M_umap_cost;
+    float _M_map_cost;
+    bool  _M_valid;
+  };
 
-/** @brief A map-to-unordered_map instrumentation line in the stack table.  */
-class __map2umap_stack_info: public __map2umap_info
-{
+
+  /** @brief A map-to-unordered_map instrumentation line in the 
+      stack table.  */
+  class __map2umap_stack_info 
+  : public __map2umap_info
+  {
   public:
-  __map2umap_stack_info(const __map2umap_info& o) : __map2umap_info(o) {}
-};
+    __map2umap_stack_info(const __map2umap_info& __o)
+    : __map2umap_info(__o) { }
+  };
 
-/** @brief Map-to-unordered_map instrumentation producer.  */
-class __trace_map2umap
+  /** @brief Map-to-unordered_map instrumentation producer.  */
+  class __trace_map2umap
   : public __trace_base<__map2umap_info, __map2umap_stack_info> 
-{
+  {
   public:
-  __trace_map2umap();
-};
-
-inline __trace_map2umap::__trace_map2umap()
+    __trace_map2umap()
     : __trace_base<__map2umap_info, __map2umap_stack_info>()
-{
-  __id = "map-to-unordered-map";
-}
+    { __id = "map-to-unordered-map"; }
+  };
 
-inline void __trace_map_to_unordered_map_init()
-{
-  _GLIBCXX_PROFILE_DATA(_S_map2umap) = new __trace_map2umap();
-}
+  inline void
+  __trace_map_to_unordered_map_init()
+  { _GLIBCXX_PROFILE_DATA(_S_map2umap) = new __trace_map2umap(); }
 
-inline void __trace_map_to_unordered_map_report(
-    FILE* __f, __warning_vector_t& __warnings)
-{
-  if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) {
+  inline void
+  __trace_map_to_unordered_map_report(FILE* __f,
+				      __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) 
+      {
 	_GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f);
       }
-}
+  }
 
-inline void __trace_map_to_unordered_map_construct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_map_to_unordered_map_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
-  _GLIBCXX_PROFILE_DATA(_S_map2umap)->__add_object(
-      __obj, __map2umap_info(__get_stack()));
-}
+    _GLIBCXX_PROFILE_DATA(_S_map2umap)->
+      __add_object(__obj, __map2umap_info(__get_stack()));
+  }
 
-inline void __trace_map_to_unordered_map_destruct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_map_to_unordered_map_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_map2umap)->__retire_object(__obj);
-}
+  }
 
-inline void __trace_map_to_unordered_map_insert(const void* __obj, 
+  inline void
+  __trace_map_to_unordered_map_insert(const void* __obj, 
 				      size_t __size, size_t __count)
-{
-  if (!__profcxx_init()) return;
+  {
+    if (!__profcxx_init())
+      return;
 
-  __map2umap_info* __info =
-      _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
 
-  if (__info) __info->__record_insert(__size, __count);
-}
+    if (__info)
+      __info->__record_insert(__size, __count);
+  }
 
-inline void __trace_map_to_unordered_map_erase(const void* __obj, 
+  inline void
+  __trace_map_to_unordered_map_erase(const void* __obj, 
 				     size_t __size, size_t __count)
-{
-  if (!__profcxx_init()) return;
+  {
+    if (!__profcxx_init()) 
+      return;
 
-  __map2umap_info* __info =
-      _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+    __map2umap_info* __info 
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
 
-  if (__info) __info->__record_erase(__size, __count);
-}
+    if (__info)
+      __info->__record_erase(__size, __count);
+  }
 
-inline void __trace_map_to_unordered_map_find(const void* __obj, size_t __size)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_map_to_unordered_map_find(const void* __obj, size_t __size)
+  {
+    if (!__profcxx_init())
+      return;
 
-  __map2umap_info* __info =
-      _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
 
-  if (__info) __info->__record_find(__size);
-}
+    if (__info)
+      __info->__record_find(__size);
+  }
 
-inline void __trace_map_to_unordered_map_iterate(const void* __obj, 
-                                                 size_t __count)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_map_to_unordered_map_iterate(const void* __obj, size_t __count)
+  {
+    if (!__profcxx_init())
+      return;
 
-  __map2umap_info* __info =
-      _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
     
-  if (__info) __info->__record_iterate(__count);
-}
+    if (__info)
+      __info->__record_iterate(__count);
+  }
 
-inline void __trace_map_to_unordered_map_invalidate(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_map_to_unordered_map_invalidate(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
-  __map2umap_info* __info =
-      _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
+    __map2umap_info* __info
+      = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
 
-  if (__info) __info->__record_invalidate();
-}
+    if (__info)
+      __info->__record_invalidate();
+  }
 
 } // namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H */

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

@@ -53,15 +53,16 @@
 
 namespace __gnu_profile
 {
-typedef const void* __object_t;
-typedef void* __instruction_address_t;
-typedef std::_GLIBCXX_STD_PR::vector<__instruction_address_t> __stack_npt;
-typedef __stack_npt* __stack_t;
+  typedef const void* __object_t;
+  typedef void* __instruction_address_t;
+  typedef std::_GLIBCXX_STD_PR::vector<__instruction_address_t> __stack_npt;
+  typedef __stack_npt* __stack_t;
 
-size_t __stack_max_depth();
+  size_t __stack_max_depth();
 
-inline __stack_t __get_stack()
-{
+  inline __stack_t
+  __get_stack()
+  {
 #if defined _GLIBCXX_HAVE_EXECINFO_H
     size_t __max_depth = __stack_max_depth();
     if (__max_depth == 0)
@@ -74,99 +75,103 @@ inline __stack_t __get_stack()
 #else
     return 0;
 #endif
-}
+  }
 
-inline __size(const __stack_t& __stack)
-{
-  if (!__stack) {
+  inline size_t
+  __size(__stack_t __stack)
+  {
+    if (!__stack)
       return 0;
-  } else {
+    else
       return __stack->size();
   }
-}
 
-inline void __write(FILE* __f, const __stack_t __stack)
-{
-  if (!__stack) {
+  // XXX
+  inline void
+  __write(FILE* __f, __stack_t __stack)
+  {
+    if (!__stack)
       return;
-  }
   
     __stack_npt::const_iterator __it;
-  for (__it = __stack->begin(); __it != __stack->end(); ++__it) {
+    for (__it = __stack->begin(); __it != __stack->end(); ++__it)
       fprintf(__f, "%p ", *__it);
   }
-}
 
-/** @brief Hash function for summary trace using call stack as index.  */
-class __stack_hash 
-{
+  /** @brief Hash function for summary trace using call stack as index.  */
+  class __stack_hash 
+  {
   public:
-  size_t operator()(const __stack_t __s) const
+    size_t
+    operator()(__stack_t __s) const
     {
-    if (!__s) {
+      if (!__s) 
 	return 0;
-    }
 
       uintptr_t __index = 0;
       __stack_npt::const_iterator __it;
-    for (__it = __s->begin(); __it != __s->end(); ++__it) {
+      for (__it = __s->begin(); __it != __s->end(); ++__it)
 	__index += reinterpret_cast<uintptr_t>(*__it);
-    } 
       return __index;
     }
 
-  bool operator() (const __stack_t __stack1, const __stack_t __stack2) const
+    bool operator() (__stack_t __stack1, __stack_t __stack2) const
     {
-    if (!__stack1 && !__stack2) return true;
-    if (!__stack1 || !__stack2) return false;
-    if (__stack1->size() != __stack2->size()) return false;
+      if (!__stack1 && !__stack2)
+	return true;
+      if (!__stack1 || !__stack2)
+	return false;
+      if (__stack1->size() != __stack2->size())
+	return false;
 
       size_t __byte_size = __stack1->size() * sizeof(__stack_npt::value_type);
       return memcmp(&(*__stack1)[0], &(*__stack2)[0], __byte_size) == 0;
     }
-};
+  };
 
-/** @brief Base class for a line in the object table.  */
-class __object_info_base
-{
+
+  /** @brief Base class for a line in the object table.  */
+  class __object_info_base
+  {
   public:
-  __object_info_base() {}
-  __object_info_base(__stack_t __stack);
-  __object_info_base(const __object_info_base& o);
-  virtual ~__object_info_base() {}
-  bool __is_valid() const { return _M_valid; }
-  __stack_t __stack() const { return _M_stack; }
+    __object_info_base() { }
+
+    __object_info_base(__stack_t __stack)
+    : _M_stack(__stack), _M_valid(true) { }
+
+    __object_info_base(const __object_info_base& __o)
+    : _M_stack(__o._M_stack), _M_valid(__o._M_valid) { }
+
+    virtual ~__object_info_base() { }
+
+    bool
+    __is_valid() const 
+    { return _M_valid; }
+    
+    __stack_t
+    __stack() const
+    { return _M_stack; }
+    
     virtual void __write(FILE* f) const = 0;
 
   protected:
     __stack_t _M_stack;
     bool _M_valid;
-};
-
-inline __object_info_base::__object_info_base(__stack_t __stack)
-{
-  _M_stack = __stack;
-  _M_valid = true;
-}
+  };
 
-inline __object_info_base::__object_info_base(const __object_info_base& __o)
-{
-  _M_stack = __o._M_stack;
-  _M_valid = __o._M_valid;
-}
 
-/** @brief Base class for a line in the stack table.  */
-template<typename __object_info>
-class __stack_info_base
-{
+  /** @brief Base class for a line in the stack table.  */
+  template<typename __object_info>
+    class __stack_info_base
+    {
     public:
-  __stack_info_base() {}
+      __stack_info_base() { }
       __stack_info_base(const __object_info& __info) = 0;
       virtual ~__stack_info_base() {}
       void __merge(const __object_info& __info) = 0;
       virtual float __magnitude() const = 0;
       virtual const char* __get_id() const = 0;
-};
+    };
 
 } // namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_NODE_H */

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

 // -*- C++ -*-
 //
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010 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
@@ -39,32 +39,35 @@
 
 namespace __gnu_profile
 {
+  enum __state_type { __ON, __OFF, __INVALID };
 
-enum __state_type { __ON, __OFF, __INVALID };
+  _GLIBCXX_PROFILE_DEFINE_DATA(__state_type, __state, __INVALID);
 
-_GLIBCXX_PROFILE_DEFINE_DATA(__state_type, __state, __INVALID);
-
-inline bool __turn(__state_type __s)
-{
-  return (_GLIBCXX_PROFILE_DATA(__state)
+  inline bool
+  __turn(__state_type __s)
+  { return (_GLIBCXX_PROFILE_DATA(__state)
 	    == __sync_val_compare_and_swap(&_GLIBCXX_PROFILE_DATA(__state),
-                                         __INVALID, __s));
-}
+					   __INVALID, __s)); }
 
-inline bool __turn_on()
-{ return __turn(__ON); }
+  inline bool
+  __turn_on()
+  { return __turn(__ON); }
 
-inline bool __turn_off()
-{ return __turn(__OFF); }
+  inline bool
+  __turn_off()
+  { return __turn(__OFF); }
 
-inline bool __is_on()
-{ return _GLIBCXX_PROFILE_DATA(__state) == __ON; }
+  inline bool
+  __is_on()
+  { return _GLIBCXX_PROFILE_DATA(__state) == __ON; }
 
-inline bool __is_off()
-{ return _GLIBCXX_PROFILE_DATA(__state) == __OFF; }
+  inline bool
+  __is_off()
+  { return _GLIBCXX_PROFILE_DATA(__state) == __OFF; }
 
-inline bool __is_invalid()
-{ return _GLIBCXX_PROFILE_DATA(__state) == __INVALID; }
+  inline bool
+  __is_invalid()
+  { return _GLIBCXX_PROFILE_DATA(__state) == __INVALID; }
 
 } // end namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_STATE_H */

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

@@ -65,7 +65,7 @@
 
 namespace __gnu_profile
 {
-/** @brief Internal environment.  Values can be set one of two ways:
+  /** @brief Internal environment.  Values can be set one of two ways:
       1. In config file "var = value".  The default config file path is 
          libstdcxx-profile.conf.
       2. By setting process environment variables.  For instance, in a Bash
@@ -73,124 +73,126 @@ namespace __gnu_profile
          export __map_iterate_cost_factor=5.0.
 	 If a value is set both in the input file and through an environment
 	 variable, the environment value takes precedence.  */
-typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t;
-_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env);
+  typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t;
 
-/** @brief Master lock.  */
-_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock);
+  _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env);
 
-/** @brief Representation of a warning.  */
-struct __warning_data
-{
+  /** @brief Master lock.  */
+  _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock);
+
+  /** @brief Representation of a warning.  */
+  struct __warning_data
+  {
     float __magnitude;
     __stack_t __context;
     const char* __warning_id;
     const char* __warning_message;
     __warning_data()
     : __magnitude(0.0), __context(0), __warning_id(0),
+    
     __warning_message(0) { }
     __warning_data(float __m, __stack_t __c, const char* __id, 
 		   const char* __msg)
     : __magnitude(__m), __context(__c), __warning_id(__id), 
       __warning_message(__msg) { }
-  bool operator<(const struct __warning_data& __other) const
+    
+    bool
+    operator<(const struct __warning_data& __other) const
     { return __magnitude < __other.__magnitude; }
-};
-
-typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t;
-
-// Defined in profiler_<diagnostic name>.h.
-class __trace_hash_func;
-class __trace_hashtable_size;
-class __trace_map2umap;
-class __trace_vector_size;
-class __trace_vector_to_list;
-class __trace_list_to_slist; 
-class __trace_list_to_vector; 
-void __trace_vector_size_init();
-void __trace_hashtable_size_init();
-void __trace_hash_func_init();
-void __trace_vector_to_list_init();
-void __trace_list_to_slist_init();  
-void __trace_list_to_vector_init();  
-void __trace_map_to_unordered_map_init();
-void __trace_vector_size_report(FILE*, __warning_vector_t&);
-void __trace_hashtable_size_report(FILE*, __warning_vector_t&);
-void __trace_hash_func_report(FILE*, __warning_vector_t&);
-void __trace_vector_to_list_report(FILE*, __warning_vector_t&);
-void __trace_list_to_slist_report(FILE*, __warning_vector_t&); 
-void __trace_list_to_vector_report(FILE*, __warning_vector_t&);
-void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&);
-
-struct __cost_factor
-{
+  };
+
+  typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t;
+
+  // Defined in profiler_<diagnostic name>.h.
+  class __trace_hash_func;
+  class __trace_hashtable_size;
+  class __trace_map2umap;
+  class __trace_vector_size;
+  class __trace_vector_to_list;
+  class __trace_list_to_slist; 
+  class __trace_list_to_vector; 
+  void __trace_vector_size_init();
+  void __trace_hashtable_size_init();
+  void __trace_hash_func_init();
+  void __trace_vector_to_list_init();
+  void __trace_list_to_slist_init();  
+  void __trace_list_to_vector_init();  
+  void __trace_map_to_unordered_map_init();
+  void __trace_vector_size_report(FILE*, __warning_vector_t&);
+  void __trace_hashtable_size_report(FILE*, __warning_vector_t&);
+  void __trace_hash_func_report(FILE*, __warning_vector_t&);
+  void __trace_vector_to_list_report(FILE*, __warning_vector_t&);
+  void __trace_list_to_slist_report(FILE*, __warning_vector_t&); 
+  void __trace_list_to_vector_report(FILE*, __warning_vector_t&);
+  void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&);
+
+  struct __cost_factor
+  {
     const char* __env_var;
     float __value;
-};
+  };
 
-typedef std::_GLIBCXX_STD_PR::vector<__cost_factor*> __cost_factor_vector;
+  typedef std::_GLIBCXX_STD_PR::vector<__cost_factor*> __cost_factor_vector;
 
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0);
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); 
-_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); 
+  _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0);
 
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, 
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, 
 			       {"__vector_shift_cost_factor", 1.0});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor,
 			       {"__vector_iterate_cost_factor", 1.0});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor,
 			       {"__vector_resize_cost_factor", 1.0}); 
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor,
 			       {"__list_shift_cost_factor", 0.0});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor,
 			       {"__list_iterate_cost_factor", 10.0}); 
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor,
 			       {"__list_resize_cost_factor", 0.0}); 
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor,
 			       {"__map_insert_cost_factor", 1.5});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor,
 			       {"__map_erase_cost_factor", 1.5});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor,
 			       {"__map_find_cost_factor", 1});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor,
 			       {"__map_iterate_cost_factor", 2.3});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor,
 			       {"__umap_insert_cost_factor", 12.0});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor,
 			       {"__umap_erase_cost_factor", 12.0});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor,
 			       {"__umap_find_cost_factor", 10.0});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor,
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor,
 			       {"__umap_iterate_cost_factor", 1.7});
-_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0);
+  _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0);
 
-_GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name,
+  _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name,
 			       _GLIBCXX_PROFILE_TRACE_PATH_ROOT);
-_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_warn_count,
+  _GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_warn_count,
 			       _GLIBCXX_PROFILE_MAX_WARN_COUNT);
-_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_stack_depth,
+  _GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_stack_depth,
 			       _GLIBCXX_PROFILE_MAX_STACK_DEPTH);
-_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_mem,
+  _GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_mem,
 			       _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC);
 
-inline size_t __stack_max_depth()
-{
-  return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth);
-}
+  inline size_t
+  __stack_max_depth()
+  { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); }
 
-inline size_t __max_mem()
-{
-  return _GLIBCXX_PROFILE_DATA(_S_max_mem);
-}
+  inline size_t
+  __max_mem()
+  { return _GLIBCXX_PROFILE_DATA(_S_max_mem); }
 
-/** @brief Base class for all trace producers.  */
-template <typename __object_info, typename __stack_info>
-class __trace_base
-{
+  /** @brief Base class for all trace producers.  */
+  template<typename __object_info, typename __stack_info>
+    class __trace_base
+    {
     public:
       __trace_base();
       virtual ~__trace_base() {}
@@ -206,7 +208,8 @@ class __trace_base
       __gnu_cxx::__mutex __stack_table_lock;
       typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t, 
 					  __object_info> __object_table_t;
-  typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, __stack_hash, 
+      typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info,
+					  __stack_hash, 
 					  __stack_hash> __stack_table_t;
       __object_table_t __object_table;
       __stack_table_t __stack_table;
@@ -214,104 +217,125 @@ class __trace_base
 
     protected:
       const char* __id;
-};
+    };
 
-template <typename __object_info, typename __stack_info>
-void __trace_base<__object_info, __stack_info>::__collect_warnings(
-    __warning_vector_t& __warnings)
-{
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __collect_warnings(__warning_vector_t& __warnings)
+    {
       typename __stack_table_t::iterator __i = __stack_table.begin();
       for (; __i != __stack_table.end(); ++__i)
-  {
 	__warnings.push_back(__warning_data((*__i).second.__magnitude(), 
 					    (*__i).first, 
 					    __id,
 					    (*__i).second.__advice()));
     }
-}
 
-template <typename __object_info, typename __stack_info>
-__trace_base<__object_info, __stack_info>::__trace_base()
-{
-  // Do not pick the initial size too large, as we don't know which diagnostics
-  // are more active.
+  template<typename __object_info, typename __stack_info>
+    __trace_base<__object_info, __stack_info>::
+    __trace_base()
+    {
+      // Do not pick the initial size too large, as we don't know which
+      // diagnostics are more active.
       __object_table.rehash(10000);
       __stack_table.rehash(10000);
       __stack_table_byte_size = 0;
       __id = 0;
-}
+    }
 
-template <typename __object_info, typename __stack_info>
-void __trace_base<__object_info, __stack_info>::__add_object(
-    __object_t __object, __object_info __info)
-{
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __add_object(__object_t __object, __object_info __info)
+    {
       if (__max_mem() == 0 
-      || __object_table.size() * sizeof(__object_info) <= __max_mem()) {
+	  || __object_table.size() * sizeof(__object_info) <= __max_mem())
+	{
 	  this->__object_table_lock.lock();
-    __object_table.insert(
-        typename __object_table_t::value_type(__object, __info));
+	  __object_table.insert(typename __object_table_t::
+				value_type(__object, __info));
 	  this->__object_table_lock.unlock();
 	}
-}
+    }
 
-template <typename __object_info, typename __stack_info>
-__object_info* __trace_base<__object_info, __stack_info>::__get_object_info(
-    __object_t __object)
-{
+  template<typename __object_info, typename __stack_info>
+    __object_info*
+    __trace_base<__object_info, __stack_info>::
+    __get_object_info(__object_t __object)
+    {
       // XXX: Revisit this to see if we can decrease mutex spans.
       // Without this mutex, the object table could be rehashed during an
       // insertion on another thread, which could result in a segfault.
       this->__object_table_lock.lock();
-  typename __object_table_t::iterator __object_it = 
-      __object_table.find(__object);
-  if (__object_it == __object_table.end()){
+      typename __object_table_t::iterator __object_it
+	=  __object_table.find(__object);
+
+      if (__object_it == __object_table.end())
+	{
 	  this->__object_table_lock.unlock();
 	  return 0;
-  } else {
+	}
+      else
+	{
 	  this->__object_table_lock.unlock();
 	  return &__object_it->second;
 	}
-}
+    }
 
-template <typename __object_info, typename __stack_info>
-void __trace_base<__object_info, __stack_info>::__retire_object(
-    __object_t __object)
-{
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __retire_object(__object_t __object)
+    {
       this->__object_table_lock.lock();
       this->__stack_table_lock.lock();
-  typename __object_table_t::iterator __object_it =
-      __object_table.find(__object);
-  if (__object_it != __object_table.end()){
+      typename __object_table_t::iterator __object_it
+	= __object_table.find(__object);
+  
+      if (__object_it != __object_table.end())
+	{
 	  const __object_info& __info = __object_it->second;
 	  const __stack_t& __stack = __info.__stack();
-    typename __stack_table_t::iterator __stack_it = 
-        __stack_table.find(__stack);
-    if (__stack_it == __stack_table.end()) {
+	  typename __stack_table_t::iterator __stack_it
+	    = __stack_table.find(__stack);
+    
+	  if (__stack_it == __stack_table.end())
+	    {
 	      // First occurence of this call context.
-      if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) {
-        __stack_table_byte_size += 
-            (sizeof(__instruction_address_t) * __size(__stack)
+	      if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) 
+		{
+		  __stack_table_byte_size 
+		    += (sizeof(__instruction_address_t) * __size(__stack)
 			+ sizeof(__stack) + sizeof(__stack_info));
-        __stack_table.insert(make_pair(__stack, __stack_info(__info)));
+		  __stack_table.insert(make_pair(__stack,
+						 __stack_info(__info)));
+		}
 	    }
-    } else {
+	  else
+	    {
 	      // Merge object info into info summary for this call context.
 	      __stack_it->second.__merge(__info);
 	      delete __stack;
 	    }
 	  __object_table.erase(__object);
 	}
+
       this->__object_table_lock.unlock();
       this->__stack_table_lock.unlock();
-}
+    }
 
-template <typename __object_info, typename __stack_info>
-void __trace_base<__object_info, __stack_info>::__write(FILE* __f)
-{
+  template<typename __object_info, typename __stack_info>
+    void
+    __trace_base<__object_info, __stack_info>::
+    __write(FILE* __f)
+    {
       typename __stack_table_t::iterator __it;
 
-  for (__it = __stack_table.begin(); __it != __stack_table.end(); __it++) {
-    if (__it->second.__is_valid()) {
+      for (__it = __stack_table.begin(); __it != __stack_table.end(); ++__it)
+	{
+	  if (__it->second.__is_valid())
+	    {
 	      fprintf(__f, __id);
 	      fprintf(__f, "|");
 	      __gnu_profile::__write(__f, __it->first);
@@ -319,56 +343,68 @@ void __trace_base<__object_info, __stack_info>::__write(FILE* __f)
 	      __it->second.__write(__f);
 	    }
 	}
-}
+    }
 
-inline size_t __env_to_size_t(const char* __env_var, size_t __default_value)
-{
+  inline size_t
+  __env_to_size_t(const char* __env_var, size_t __default_value)
+  {
     char* __env_value = getenv(__env_var);
-  if (__env_value) {
-    long int __converted_value = strtol(__env_value, 0, 10);
-    if (errno || __converted_value < 0) {
-      fprintf(stderr, "Bad value for environment variable '%s'.\n", __env_var);
+    if (__env_value)
+      {
+	long __converted_value = strtol(__env_value, 0, 10);
+	if (errno || __converted_value < 0)
+	  {
+	    fprintf(stderr, "Bad value for environment variable '%s'.\n",
+		    __env_var);
 	    abort();
-    } else {
+	  }
+	else
 	  return static_cast<size_t>(__converted_value);
       }
-  } else {
+    else
       return __default_value;
   }
-}
 
-inline void __set_max_stack_trace_depth()
-{
-  _GLIBCXX_PROFILE_DATA(_S_max_stack_depth) = __env_to_size_t(
-      _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR,
+  inline void
+  __set_max_stack_trace_depth()
+  {
+    _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)
+      = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR,
 			_GLIBCXX_PROFILE_DATA(_S_max_stack_depth));
-}
+  }
 
-inline void __set_max_mem()
-{
-  _GLIBCXX_PROFILE_DATA(_S_max_mem) = __env_to_size_t(
-      _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR,
+  inline void
+  __set_max_mem()
+  {
+    _GLIBCXX_PROFILE_DATA(_S_max_mem) 
+      = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR,
 			_GLIBCXX_PROFILE_DATA(_S_max_mem));
-}
+  }
 
-inline int __log_magnitude(float __f)
-{
+  inline int
+  __log_magnitude(float __f)
+  {
     const float __log_base = 10.0;
     int __result = 0;
     int __sign = 1;
-  if (__f < 0) {
+
+    if (__f < 0) 
+      {
 	__f = -__f;
 	__sign = -1;
       }
-  while (__f > __log_base) {
+
+    while (__f > __log_base) 
+      {
 	++__result;
 	__f /= 10.0;
       }
     return __sign * __result;
-}
+  }
 
-inline FILE* __open_output_file(const char* __extension)
-{
+  inline FILE* 
+  __open_output_file(const char* __extension)
+  {
     // The path is made of _S_trace_file_name + "." + extension.
     size_t __root_len = strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));
     size_t __ext_len = strlen(__extension);
@@ -378,20 +414,22 @@ inline FILE* __open_output_file(const char* __extension)
     *(__file_name + __root_len) = '.';
     memcpy(__file_name + __root_len + 1, __extension, __ext_len + 1);
     FILE* __out_file = fopen(__file_name, "w");
-  if (__out_file) {
+    if (__out_file) 
       return __out_file;
-  } else {
+    else
+      {
 	fprintf(stderr, "Could not open trace file '%s'.\n", __file_name);
 	abort();
       }
-}
+  }
 
-struct __warn
-{
+  struct __warn
+  {
     FILE* __file;
     __warn(FILE* __f) { __file = __f; }
 
-  void operator() (const __warning_data& __info)
+    void
+    operator() (const __warning_data& __info)
     {
       fprintf(__file,  __info.__warning_id);
       fprintf(__file, ": improvement = %d",
@@ -402,17 +440,18 @@ struct __warn
       free(const_cast<void*>
 	   (reinterpret_cast<const void*>(__info.__warning_message)));
     }
-};
+  };
 
-/** @brief Final report method, registered with @b atexit.
+  /** @brief Final report method, registered with @b atexit.
    *
    * 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
    * __gnu_profile (under the guarded zone), no output will be produced.
    */
-inline void __report(void)
-{
+  inline void
+  __report(void)
+  {
     _GLIBCXX_PROFILE_DATA(__global_lock).lock();
 
     __warning_vector_t __warnings, __top_warnings;
@@ -438,34 +477,34 @@ inline void __report(void)
     fclose(__warn_file);
 
     _GLIBCXX_PROFILE_DATA(__global_lock).unlock();
-}
+  }
 
-inline void __set_trace_path()
-{
+  inline void
+  __set_trace_path()
+  {
     char* __env_trace_file_name = getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR);
 
-  if (__env_trace_file_name) { 
+    if (__env_trace_file_name)
       _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name;
-  }
 
     // Make sure early that we can create the trace file.
     fclose(__open_output_file("txt"));
-}
+  }
 
-inline void __set_max_warn_count()
-{
-  char* __env_max_warn_count_str = getenv(
-      _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR);
+  inline void
+  __set_max_warn_count()
+  {
+    char* __env_max_warn_count_str
+      = getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR);
 
-  if (__env_max_warn_count_str) {
-    _GLIBCXX_PROFILE_DATA(_S_max_warn_count) = static_cast<size_t>(
-        atoi(__env_max_warn_count_str));
+    if (__env_max_warn_count_str)
+      _GLIBCXX_PROFILE_DATA(_S_max_warn_count)
+	= static_cast<size_t>(atoi(__env_max_warn_count_str));
   }
-}
 
-inline void
-__read_cost_factors()
-{
+  inline void
+  __read_cost_factors()
+  {
     std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name));
     __conf_file_name += ".conf";
 
@@ -485,7 +524,8 @@ __read_cost_factors()
 	  }
 
 	// Trim.
-      __line.erase(__remove(__line.begin(), __line.end(), ' '), __line.end());
+	__line.erase(__remove(__line.begin(), __line.end(), ' '),
+		     __line.end());
 	std::string::size_type __pos = __line.find("=");
 	std::string __factor_name = __line.substr(0, __pos);
 	std::string::size_type __end = __line.find_first_of(";\n");
@@ -493,30 +533,32 @@ __read_cost_factors()
 
 	_GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value;
       }
-}
+  }
 
-struct __cost_factor_writer
-{
+  struct __cost_factor_writer
+  {
     FILE* __file;
-  __cost_factor_writer(FILE* __f) : __file(__f) {}
+    __cost_factor_writer(FILE* __f) : __file(__f) { }
+  
     void
     operator() (const __cost_factor* __factor)
     { fprintf(__file, "%s = %f\n", __factor->__env_var, __factor->__value); }
-};
+  };
 
-inline void
-__write_cost_factors()
-{
+  inline void
+  __write_cost_factors()
+  {
     FILE* __file = __open_output_file("conf.out");
     __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(),
 	       _GLIBCXX_PROFILE_DATA(__cost_factors)->end(),
 	       __cost_factor_writer(__file));
     fclose(__file);
-}
+  }
 
-struct __cost_factor_setter
-{
-  void operator() (__cost_factor* __factor)
+  struct __cost_factor_setter
+  {
+    void
+    operator() (__cost_factor* __factor)
     {
       // Look it up in the process environment first.
       const char* __env_value = getenv(__factor->__env_var);
@@ -524,8 +566,8 @@ struct __cost_factor_setter
       if (!__env_value)
         {
           // Look it up in the config file.
-          __env_t::iterator it = _GLIBCXX_PROFILE_DATA(__env).find(
-              __factor->__env_var);
+          __env_t::iterator it 
+	    = _GLIBCXX_PROFILE_DATA(__env).find(__factor->__env_var);
           if (it != _GLIBCXX_PROFILE_DATA(__env).end())
             __env_value = (*it).second.c_str();
         }
@@ -533,58 +575,58 @@ struct __cost_factor_setter
       if (__env_value)
         __factor->__value = atof(__env_value);
     }
-};
+  };
 
-inline void __set_cost_factors()
-{
+  inline void
+  __set_cost_factors()
+  {
     _GLIBCXX_PROFILE_DATA(__cost_factors) = new __cost_factor_vector;
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__map_find_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor));
-  _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back(
-      &_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor));
+    _GLIBCXX_PROFILE_DATA(__cost_factors)->
+      push_back(&_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__map_find_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor));
+  _GLIBCXX_PROFILE_DATA(__cost_factors)->
+    push_back(&_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor));
   __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(),
              _GLIBCXX_PROFILE_DATA(__cost_factors)->end(),
              __cost_factor_setter());
-}
+  }
 
-inline void __profcxx_init_unconditional()
-{
+  inline void
+  __profcxx_init_unconditional()
+  {
     _GLIBCXX_PROFILE_DATA(__global_lock).lock();
 
-  if (__is_invalid()) {
-
+    if (__is_invalid())
+      {
 	__set_max_warn_count();
 
-    if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0) {
-
+	if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0)
 	  __turn_off();
-
-    } else {
-
+	else
+	  {
 	    __set_max_stack_trace_depth();
 	    __set_max_mem();
 	    __set_trace_path();
@@ -603,25 +645,24 @@ inline void __profcxx_init_unconditional()
 	    atexit(__report);
 
 	    __turn_on();
-
 	  }
       }
 
     _GLIBCXX_PROFILE_DATA(__global_lock).unlock();
-}
+  }
 
-/** @brief This function must be called by each instrumentation point.
+  /** @brief This function must be called by each instrumentation point.
    *
    * The common path is inlined fully.
    */
-inline bool __profcxx_init(void)
-{
-  if (__is_invalid()) {
+  inline bool
+  __profcxx_init(void)
+  {
+    if (__is_invalid())
       __profcxx_init_unconditional();
-  }
 
     return __is_on();
-}
+  }
 
 } // namespace __gnu_profile
 

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

 // -*- C++ -*-
 //
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010 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
@@ -54,50 +54,57 @@
 
 namespace __gnu_profile
 {
-
-/** @brief Hashtable size instrumentation trace producer.  */
-class __trace_vector_size : public __trace_container_size
-{
+  /** @brief Hashtable size instrumentation trace producer.  */
+  class __trace_vector_size
+  : public __trace_container_size
+  {
   public:
-  __trace_vector_size() : __trace_container_size() { __id = "vector-size"; }
-};
-
-inline void __trace_vector_size_init()
-{
-  _GLIBCXX_PROFILE_DATA(_S_vector_size) = new __trace_vector_size();
-}
-
-inline void __trace_vector_size_report(FILE* __f, 
-                                       __warning_vector_t& __warnings)
-{
-  if (_GLIBCXX_PROFILE_DATA(_S_vector_size)) {
+    __trace_vector_size()
+    : __trace_container_size()
+    { __id = "vector-size"; }
+  };
+
+  inline void
+  __trace_vector_size_init()
+  { _GLIBCXX_PROFILE_DATA(_S_vector_size) = new __trace_vector_size(); }
+
+  inline void
+  __trace_vector_size_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_vector_size))
+      {
 	_GLIBCXX_PROFILE_DATA(_S_vector_size)->__collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_vector_size)->__write(__f);
       }
-}
+  }
 
-inline void __trace_vector_size_construct(const void* __obj, size_t __num)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_size_construct(const void* __obj, size_t __num)
+  {
+    if (!__profcxx_init())
+      return;
 
-  _GLIBCXX_PROFILE_DATA(_S_vector_size)->__insert(__obj, __get_stack(), __num);
-}
+    _GLIBCXX_PROFILE_DATA(_S_vector_size)->__insert(__obj, __get_stack(),
+						    __num);
+  }
 
-inline void __trace_vector_size_destruct(const void* __obj, size_t __num,
-                                         size_t __inum)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_size_destruct(const void* __obj, size_t __num, size_t __inum)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_size)->__destruct(__obj, __num, __inum);
-}
+  }
 
-inline void __trace_vector_size_resize(const void* __obj, size_t __from,
-                                       size_t __to)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_size_resize(const void* __obj, size_t __from, size_t __to)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_size)->__resize(__obj, __from, __to);
-}
+  }
 
 } // namespace __gnu_profile
 

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

 // -*- C++ -*-
 //
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010 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
@@ -52,164 +52,141 @@
 
 namespace __gnu_profile
 {
-
-/** @brief A vector-to-list instrumentation line in the object table.  */
-class __vector2list_info: public __object_info_base
-{
+  /** @brief A vector-to-list instrumentation line in the object table.  */
+  class __vector2list_info 
+  : public __object_info_base
+  {
   public:
     __vector2list_info()
-      :_M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0),
-       _M_vector_cost(0), _M_valid(true) {}
+    : _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0),
+      _M_vector_cost(0), _M_valid(true) { }
+
     __vector2list_info(__stack_t __stack)
     : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0),
-        _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true) {} 
-  virtual ~__vector2list_info() {}
-  __vector2list_info(const __vector2list_info& __o);
-  void __merge(const __vector2list_info& __o);
-  void __write(FILE* __f) const;
-  float __magnitude() const { return _M_vector_cost - _M_list_cost; }
-  const char* __advice() const 
-  { return strdup("change std::vector to std::list"); }
+      _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true) { }
 
-  size_t __shift_count() { return _M_shift_count; }
-  size_t __iterate()   { return _M_iterate; }
-  float __list_cost() { return _M_list_cost; }
-  size_t __resize() { return _M_resize; }
-  void __set_list_cost(float __lc) { _M_list_cost = __lc; }
-  void __set_vector_cost(float __vc) { _M_vector_cost = __vc; }
-  bool __is_valid() { return _M_valid; }
-  void __set_invalid() { _M_valid = false; }
-
-  void __opr_insert(size_t __pos, size_t __num);
-  void __opr_iterate(size_t __num);
-  void __resize(size_t __from, size_t __to);
-  void __opr_find(size_t __size);
-
-private:
-  size_t _M_shift_count;
-  size_t _M_iterate;
-  size_t _M_resize;
-  float _M_list_cost;
-  float _M_vector_cost;
-  bool  _M_valid;
-};
+    virtual ~__vector2list_info() { }
 
-inline __vector2list_info::__vector2list_info(const __vector2list_info& __o)
-    : __object_info_base(__o)
-{
-  _M_shift_count  = __o._M_shift_count;
-  _M_iterate      = __o._M_iterate;
-  _M_vector_cost  = __o._M_vector_cost;
-  _M_list_cost    = __o._M_list_cost;
-  _M_valid        = __o._M_valid;
-  _M_resize       = __o._M_resize;
-}
-
-inline void __vector2list_info::__merge(const __vector2list_info& __o)
-{
+    __vector2list_info(const __vector2list_info& __o)
+    : __object_info_base(__o), _M_shift_count(__o._M_shift_count),
+      _M_iterate(__o._M_iterate), _M_resize(__o._M_resize),
+      _M_list_cost(__o._M_list_cost), _M_vector_cost(__o._M_vector_cost),
+      _M_valid(__o._M_valid) { }
+
+    void
+    __merge(const __vector2list_info& __o)
+    {
       _M_shift_count  += __o._M_shift_count;
       _M_iterate      += __o._M_iterate;
       _M_vector_cost  += __o._M_vector_cost;
       _M_list_cost    += __o._M_list_cost;
       _M_valid        &= __o._M_valid;
       _M_resize       += __o._M_resize;
-}
+    }
 
-inline void __vector2list_info::__opr_insert(size_t __pos, size_t __num)
-{
-  _M_shift_count += __num - __pos;
-}
+    void
+    __write(FILE* __f) const
+    {
+      fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count, _M_resize,
+	      _M_iterate, _M_vector_cost, _M_list_cost);
+    }
 
-inline void __vector2list_info::__resize(size_t __from, size_t __to)
-{
-  _M_resize += __from;
-}
+    float
+    __magnitude() const
+    { return _M_vector_cost - _M_list_cost; }
 
-inline void __vector2list_info::__opr_iterate(size_t __num)
-{ 
-  _M_iterate += __num; 
-}
+    const char* __advice() const 
+    { return strdup("change std::vector to std::list"); }
 
-inline void __vector2list_info::__opr_find(size_t __size)
-{
+    size_t
+    __shift_count()
+    { return _M_shift_count; }
+
+    size_t
+    __iterate()
+    { return _M_iterate; }
+
+    float __list_cost()
+    { return _M_list_cost; }
+
+    size_t
+    __resize()
+    { return _M_resize; }
+
+    void
+    __set_list_cost(float __lc)
+    { _M_list_cost = __lc; }
+    
+    void
+    __set_vector_cost(float __vc)
+    { _M_vector_cost = __vc; }
+    
+    bool
+    __is_valid()
+    { return _M_valid; }
+    
+    void
+    __set_invalid()
+    { _M_valid = false; }
+
+    void
+    __opr_insert(size_t __pos, size_t __num)
+    { _M_shift_count += __num - __pos; }
+
+    void
+    __opr_iterate(size_t __num)
+    { _M_iterate += __num; }
+
+    void
+    __resize(size_t __from, size_t)
+    { _M_resize += __from; }
+
+    void __opr_find(size_t __size)
+    {
       // Use average case complexity.
       _M_iterate += 3.0 / 4.0 * __size;
-}
+    }
+
+  private:
+    size_t _M_shift_count;
+    size_t _M_iterate;
+    size_t _M_resize;
+    float _M_list_cost;
+    float _M_vector_cost;
+    bool  _M_valid;
+  };
+
 
-/** @brief A vector-to-list instrumentation line in the stack table.  */
-class __vector2list_stack_info: public __vector2list_info {
+  /** @brief A vector-to-list instrumentation line in the stack table.  */
+  class __vector2list_stack_info
+  : public __vector2list_info
+  {
   public:
     __vector2list_stack_info(const __vector2list_info& __o) 
-      : __vector2list_info(__o) {}
-};
+    : __vector2list_info(__o) { }
+  };
 
-/** @brief Vector-to-list instrumentation producer.  */
-class __trace_vector_to_list
+
+  /** @brief Vector-to-list instrumentation producer.  */
+  class __trace_vector_to_list
   : public __trace_base<__vector2list_info, __vector2list_stack_info> 
-{
+  {
   public:
-  __trace_vector_to_list();
-  ~__trace_vector_to_list() {}
-
-  // Insert a new node at construct with object, callstack and initial size. 
-  void __insert(__object_t __obj, __stack_t __stack);
-  // Call at destruction/clean to set container final size.
-  void __destruct(const void* __obj);
-
-  // Find the node in the live map.
-  __vector2list_info* __find(const void* __obj);
-
-  // Collect cost of operations.
-  void __opr_insert(const void* __obj, size_t __pos, size_t __num);
-  void __opr_iterate(const void* __obj, size_t __num);
-  void __invalid_operator(const void* __obj);
-  void __resize(const void* __obj, size_t __from, size_t __to);
-  float __vector_cost(size_t __shift, size_t __iterate, size_t __resize);
-  float __list_cost(size_t __shift, size_t __iterate, size_t __resize);
-  void __opr_find(const void* __obj, size_t __size);
-};
-
-inline __trace_vector_to_list::__trace_vector_to_list()
+    __trace_vector_to_list()
     : __trace_base<__vector2list_info, __vector2list_stack_info>()
-{
-  __id = "vector-to-list";
-}
+    { __id = "vector-to-list"; }
 
-inline void __trace_vector_to_list::__insert(__object_t __obj,
-                                             __stack_t __stack)
-{
-  __add_object(__obj, __vector2list_info(__stack));
-}
-
-inline void __vector2list_info::__write(FILE* __f) const
-{
-  fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n",
-          _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost);
-}
+    ~__trace_vector_to_list() { }
 
-inline float __trace_vector_to_list::__vector_cost(size_t __shift, 
-                                                   size_t __iterate,
-                                                   size_t __resize)
-{
-  return (
-      __shift * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value
-      + __iterate * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value
-      + __resize * _GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor).__value
-      );
-}
-
-inline float __trace_vector_to_list::__list_cost(size_t __shift, 
-                                                 size_t __iterate,
-                                                 size_t __resize)
-{
-  return (
-      __shift * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value
-      + __iterate * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value
-      + __resize * _GLIBCXX_PROFILE_DATA(__list_resize_cost_factor).__value);
-}
+    // Insert a new node at construct with object, callstack and initial size. 
+    void
+    __insert(__object_t __obj, __stack_t __stack)
+    { __add_object(__obj, __vector2list_info(__stack)); }
 
-inline void __trace_vector_to_list::__destruct(const void* __obj)
-{
+    // Call at destruction/clean to set container final size.
+    void
+    __destruct(const void* __obj)
+    {
       if (!__is_on())
 	return;
 
@@ -225,112 +202,155 @@ inline void __trace_vector_to_list::__destruct(const void* __obj)
       __res->__set_list_cost(__lc);
 
       __retire_object(__obj);
-}
+    }
 
-inline void __trace_vector_to_list::__opr_insert(const void* __obj, 
-                                                 size_t __pos, size_t __num)
-{
+    // Find the node in the live map.
+    // XXX Undefined?!?
+    __vector2list_info* __find(const void* __obj);
+
+    // Collect cost of operations.
+    void
+    __opr_insert(const void* __obj, size_t __pos, size_t __num)
+    {
       __vector2list_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__opr_insert(__pos, __num);
-}
+    }
 
-inline void __trace_vector_to_list::__opr_iterate(const void* __obj,
-                                                  size_t __num)
-{
+    void
+    __opr_iterate(const void* __obj, size_t __num)
+    {
       __vector2list_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__opr_iterate(__num);
-}
+    }
 
-inline void __trace_vector_to_list::__invalid_operator(const void* __obj)
-{
+    void
+    __invalid_operator(const void* __obj)
+    {
       __vector2list_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__set_invalid();
-}
+    }
 
-inline void __trace_vector_to_list::__resize(const void* __obj, size_t __from, 
-                                             size_t __to)
-{
+    void
+    __resize(const void* __obj, size_t __from, size_t __to)
+    {
       __vector2list_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__resize(__from, __to);
-}
+    }
 
-inline void __trace_vector_to_list::__opr_find(const void* __obj,
-                                               size_t __size)
-{
+    float
+    __vector_cost(size_t __shift, size_t __iterate, size_t __resize)
+    {
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value
+	      + __resize
+	      * _GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor).__value);
+    }
+
+    float
+    __list_cost(size_t __shift, size_t __iterate, size_t __resize)
+    {
+      return (__shift
+	      * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value
+	      + __iterate
+	      * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value
+	      + __resize
+	      * _GLIBCXX_PROFILE_DATA(__list_resize_cost_factor).__value);
+    }
+
+    void
+    __opr_find(const void* __obj, size_t __size)
+    {
       __vector2list_info* __res = __get_object_info(__obj);
       if (__res)
 	__res->__opr_find(__size);
-}
+    }
+  };
 
-inline void __trace_vector_to_list_init()
-{
-  _GLIBCXX_PROFILE_DATA(_S_vector_to_list) = new __trace_vector_to_list();
-}
 
-inline void __trace_vector_to_list_report(FILE* __f, 
-                                          __warning_vector_t& __warnings)
-{
-  if (_GLIBCXX_PROFILE_DATA(_S_vector_to_list)) {
-    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__collect_warnings(__warnings);
+  inline void
+  __trace_vector_to_list_init()
+  { _GLIBCXX_PROFILE_DATA(_S_vector_to_list) = new __trace_vector_to_list(); }
+
+  inline void
+  __trace_vector_to_list_report(FILE* __f, __warning_vector_t& __warnings)
+  {
+    if (_GLIBCXX_PROFILE_DATA(_S_vector_to_list))
+      {
+	_GLIBCXX_PROFILE_DATA(_S_vector_to_list)->
+	  __collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__write(__f);
       }
-}
+  }
 
-inline void __trace_vector_to_list_construct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_to_list_construct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__insert(__obj, __get_stack());
-}
+  }
 
-inline void __trace_vector_to_list_destruct(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_to_list_destruct(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__destruct(__obj);
-}
-
-inline void __trace_vector_to_list_insert(const void* __obj, 
-                                          size_t __pos, size_t __num)
-{
-  if (!__profcxx_init()) return;
+  }
 
-  _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_insert(__obj, __pos, __num);
-}
+  inline void
+  __trace_vector_to_list_insert(const void* __obj, size_t __pos, size_t __num)
+  {
+    if (!__profcxx_init())
+      return;
 
+    _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_insert(__obj, __pos,
+							   __num);
+  }
 
-inline void __trace_vector_to_list_iterate(const void* __obj, size_t __num = 1)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_to_list_iterate(const void* __obj, size_t __num = 1)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_iterate(__obj, __num);
-}
+  }
 
-inline void __trace_vector_to_list_invalid_operator(const void* __obj)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_to_list_invalid_operator(const void* __obj)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__invalid_operator(__obj);
-}
+  }
 
-inline void __trace_vector_to_list_resize(const void* __obj, 
-                                          size_t __from, size_t __to)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_to_list_resize(const void* __obj, size_t __from, size_t __to)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__resize(__obj, __from, __to);
-}
+  }
 
-inline void __trace_vector_to_list_find(const void* __obj, size_t __size)
-{
-  if (!__profcxx_init()) return;
+  inline void
+  __trace_vector_to_list_find(const void* __obj, size_t __size)
+  {
+    if (!__profcxx_init())
+      return;
 
     _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_find(__obj, __size);
-}
+  }
 
 } // namespace __gnu_profile
 #endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H */