array: Clean useless white chars.

2014-05-24  François Dumont  <fdumont@gcc.gnu.org>

	* include/profile/array: Clean useless white chars.
	* include/profile/base.h: Likewise.
	* include/profile/iterator_tracker.h: Likewise.
	* include/profile/bitset: Code cleanup and remove not instrumented code.
	* include/profile/deque: Likewise.
	* include/profile/forward_list: Likewise.
	* include/profile/list (std::__profile::_List_profile<>): New.
	(std::__profile::list<>): Inherit from latter and adapt.
	* include/profile/impl/profiler_map_to_unordered_map.h: Generalize
	advise to match any ordered to unordered container conversion.
	* include/profile/ordered_base.h (std::__profile::_Ordered_profile<>):
	New.
	* include/Makefile.am: Add latter.
	* include/Makefile.in: Regenerate.
	* include/profile/map.h (std::__profile::map<>): Inherit from latter,
	remove not instrumented code.
	* include/profile/multimap.h (std::__profile::multimap<>): Likewise.
	* include/profile/set.h (std::__profile::set<>): Likewise.
	* include/profile/multiset.h (std::__profile::multiset<>): Likewise.
	* include/profile/unordered_base.h: Add some line feed.
	* include/profile/unordered_map: Clean useless white chars and replace
	spaces with tabs.
	* include/profile/unordered_set: Likewise.
	* include/profile/vector (std::__profile::_Vector_profile_pre<>): New.
	(std::__profile::_Vector_profile_post<>): New.
	(std::__profile::vector<>): Inherit from latter and adapt.

From-SVN: r210900

libstdc++-v3/ChangeLog

+2014-05-24  François Dumont  <fdumont@gcc.gnu.org>
+
+	* include/profile/array: Clean useless white chars.
+	* include/profile/base.h: Likewise.
+	* include/profile/iterator_tracker.h: Likewise.
+	* include/profile/bitset: Code cleanup and remove not instrumented code.
+	* include/profile/deque: Likewise.
+	* include/profile/forward_list: Likewise.
+	* include/profile/list (std::__profile::_List_profile<>): New.
+	(std::__profile::list<>): Inherit from latter and adapt.
+	* include/profile/impl/profiler_map_to_unordered_map.h: Generalize
+	advise to match any ordered to unordered container conversion.
+	* include/profile/ordered_base.h (std::__profile::_Ordered_profile<>):
+	New.
+	* include/Makefile.am: Add latter.
+	* include/Makefile.in: Regenerate.
+	* include/profile/map.h (std::__profile::map<>): Inherit from latter,
+	remove not instrumented code.
+	* include/profile/multimap.h (std::__profile::multimap<>): Likewise.
+	* include/profile/set.h (std::__profile::set<>): Likewise.
+	* include/profile/multiset.h (std::__profile::multiset<>): Likewise.
+	* include/profile/unordered_base.h: Add some line feed.
+	* include/profile/unordered_map: Clean useless white chars and replace
+	spaces with tabs.
+	* include/profile/unordered_set: Likewise.
+	* include/profile/vector (std::__profile::_Vector_profile_pre<>): New.
+	(std::__profile::_Vector_profile_post<>): New.
+	(std::__profile::vector<>): Inherit from latter and adapt.
+
 2014-05-23  Jonathan Wakely  <jwakely@redhat.com>
 
 	PR libstdc++/60793

libstdc++-v3/include/Makefile.am

@@ -816,6 +816,7 @@ profile_headers = \
 	${profile_srcdir}/map.h \
 	${profile_srcdir}/multimap.h \
 	${profile_srcdir}/multiset.h \
+	${profile_srcdir}/ordered_base.h \
 	${profile_srcdir}/set \
 	${profile_srcdir}/set.h \
 	${profile_srcdir}/iterator_tracker.h

libstdc++-v3/include/Makefile.in

@@ -1079,6 +1079,7 @@ profile_headers = \
 	${profile_srcdir}/map.h \
 	${profile_srcdir}/multimap.h \
 	${profile_srcdir}/multiset.h \
+	${profile_srcdir}/ordered_base.h \
 	${profile_srcdir}/set \
 	${profile_srcdir}/set.h \
 	${profile_srcdir}/iterator_tracker.h

libstdc++-v3/include/profile/array

@@ -83,19 +83,19 @@ namespace __profile
       end() const noexcept
       { return const_iterator(data() + _Nm); }
 
-      reverse_iterator 
+      reverse_iterator
       rbegin() noexcept
       { return reverse_iterator(end()); }
 
-      const_reverse_iterator 
+      const_reverse_iterator
       rbegin() const noexcept
       { return const_reverse_iterator(end()); }
 
-      reverse_iterator 
+      reverse_iterator
       rend() noexcept
       { return reverse_iterator(begin()); }
 
-      const_reverse_iterator 
+      const_reverse_iterator
       rend() const noexcept
       { return const_reverse_iterator(begin()); }
 
@@ -107,22 +107,22 @@ namespace __profile
       cend() const noexcept
       { return const_iterator(data() + _Nm); }
 
-      const_reverse_iterator 
+      const_reverse_iterator
       crbegin() const noexcept
       { return const_reverse_iterator(end()); }
 
-      const_reverse_iterator 
+      const_reverse_iterator
       crend() const noexcept
       { return const_reverse_iterator(begin()); }
 
       // Capacity.
-      constexpr size_type 
+      constexpr size_type
       size() const noexcept { return _Nm; }
 
-      constexpr size_type 
+      constexpr size_type
       max_size() const noexcept { return _Nm; }
 
-      constexpr bool 
+      constexpr bool
       empty() const noexcept { return size() == 0; }
 
       // Element access.
@@ -157,23 +157,23 @@ namespace __profile
 	     _AT_Type::_S_ref(_M_elems, 0));
       }
 
-      reference 
+      reference
       front() noexcept
       { return *begin(); }
 
-      constexpr const_reference 
+      constexpr const_reference
       front() const noexcept
       { return _AT_Type::_S_ref(_M_elems, 0); }
 
-      reference 
+      reference
       back() noexcept
       { return _Nm ? *(end() - 1) : *end(); }
 
-      constexpr const_reference 
+      constexpr const_reference
       back() const noexcept
       {
 	return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
- 	           : _AT_Type::_S_ref(_M_elems, 0);	  
+		   : _AT_Type::_S_ref(_M_elems, 0);
       }
 
       pointer
@@ -187,7 +187,7 @@ namespace __profile
 
   // Array comparisons.
   template<typename _Tp, std::size_t _Nm>
-    inline bool 
+    inline bool
     operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
     { return std::equal(__one.begin(), __one.end(), __two.begin()); }
 
@@ -199,9 +199,9 @@ namespace __profile
   template<typename _Tp, std::size_t _Nm>
     inline bool
     operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
-    { 
+    {
       return std::lexicographical_compare(__a.begin(), __a.end(),
-					  __b.begin(), __b.end()); 
+					  __b.begin(), __b.end());
     }
 
   template<typename _Tp, std::size_t _Nm>

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

@@ -40,9 +40,9 @@
  * @namespace std::__profile
  * @brief GNU profile code, replaces standard behavior with profile behavior.
  */
-namespace std _GLIBCXX_VISIBILITY(default) 
-{ 
-  namespace __profile { } 
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+  namespace __profile { }
 }
 
 /**

libstdc++-v3/include/profile/bitset

@@ -35,7 +35,8 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __profile
 {
-  /// Class std::bitset wrapper with performance instrumentation.
+  /// Class std::bitset wrapper with performance instrumentation, none at the
+  /// moment.
   template<size_t _Nb>
     class bitset
     : public _GLIBCXX_STD_C::bitset<_Nb>
@@ -43,60 +44,13 @@ namespace __profile
       typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
 
     public:
-      // bit reference:
-      class reference
-      : private _Base::reference
-      {
-	typedef typename _Base::reference _Base_ref;
-
-	friend class bitset;
-	reference();
-
-	reference(const _Base_ref& __base, bitset* __seq) _GLIBCXX_NOEXCEPT
-	: _Base_ref(__base)
-	{ }
-
-      public:
-	reference(const reference& __x) _GLIBCXX_NOEXCEPT
-	: _Base_ref(__x)
-	{ }
-
-	reference&
-	operator=(bool __x) _GLIBCXX_NOEXCEPT
-	{
-	  *static_cast<_Base_ref*>(this) = __x;
-	  return *this;
-	}
-
-	reference&
-	operator=(const reference& __x) _GLIBCXX_NOEXCEPT
-	{
-	  *static_cast<_Base_ref*>(this) = __x;
-	  return *this;
-	}
-
-	bool
-	operator~() const _GLIBCXX_NOEXCEPT
-	{
-	  return ~(*static_cast<const _Base_ref*>(this));
-	}
-
-	operator bool() const _GLIBCXX_NOEXCEPT
-	{
-	  return *static_cast<const _Base_ref*>(this);
-	}
-
-	reference&
-	flip() _GLIBCXX_NOEXCEPT
-	{
-	  _Base_ref::flip();
-	  return *this;
-	}
-      };
-
       // 23.3.5.1 constructors:
-      _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
+#if __cplusplus < 201103L
+      bitset()
       : _Base() { }
+#else
+      constexpr bitset() = default;
+#endif
 
 #if __cplusplus >= 201103L
       constexpr bitset(unsigned long long __val) noexcept
@@ -106,8 +60,8 @@ namespace __profile
       : _Base(__val) { }
 
       template<typename _CharT, typename _Traits, typename _Alloc>
-        explicit
-        bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
+	explicit
+	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
 	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
 	       __pos = 0,
 	       typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
@@ -129,8 +83,8 @@ namespace __profile
 
 #if __cplusplus >= 201103L
       template<typename _CharT>
-        explicit
-        bitset(const _CharT* __str,
+	explicit
+	bitset(const _CharT* __str,
 	       typename std::basic_string<_CharT>::size_type __n
 	       = std::basic_string<_CharT>::npos,
 	       _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
@@ -221,92 +175,6 @@ namespace __profile
 	return *this;
       }
 
-      // element access:
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // 11. Bitset minor problems
-      reference
-      operator[](size_t __pos)
-      {
-	return reference(_M_base()[__pos], this);
-      }
-
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // 11. Bitset minor problems
-      _GLIBCXX_CONSTEXPR bool
-      operator[](size_t __pos) const
-      {
-	return _Base::operator[](__pos);
-      }
-
-      using _Base::to_ulong;
-#if __cplusplus >= 201103L
-      using _Base::to_ullong;
-#endif
-
-      template <typename _CharT, typename _Traits, typename _Alloc>
-        std::basic_string<_CharT, _Traits, _Alloc>
-        to_string() const
-        { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
-
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // 396. what are characters zero and one.
-      template<class _CharT, class _Traits, class _Alloc>
-	std::basic_string<_CharT, _Traits, _Alloc>
-	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
-	{
-	  return _M_base().template
-	    to_string<_CharT, _Traits, _Alloc>(__zero, __one);
-	}
-
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // 434. bitset::to_string() hard to use.
-      template<typename _CharT, typename _Traits>
-        std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
-        to_string() const
-        { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
-
-      // _GLIBCXX_RESOLVE_LIB_DEFECTS
-      // 853. to_string needs updating with zero and one.
-      template<class _CharT, class _Traits>
-	std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
-	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
-	{ return to_string<_CharT, _Traits,
-	                   std::allocator<_CharT> >(__zero, __one); }
-
-      template<typename _CharT>
-        std::basic_string<_CharT, std::char_traits<_CharT>,
-                          std::allocator<_CharT> >
-        to_string() const
-        {
-          return to_string<_CharT, std::char_traits<_CharT>,
-                           std::allocator<_CharT> >();
-        }
-
-      template<class _CharT>
-	std::basic_string<_CharT, std::char_traits<_CharT>,
-	                  std::allocator<_CharT> >
-	to_string(_CharT __zero, _CharT __one = _CharT('1')) const
-	{
-	  return to_string<_CharT, std::char_traits<_CharT>,
-	                   std::allocator<_CharT> >(__zero, __one);
-	}
-
-      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
-      to_string() const
-      {
-	return to_string<char,std::char_traits<char>,std::allocator<char> >();
-      }
-
-      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
-      to_string(char __zero, char __one = '1') const
-      {
-	return to_string<char, std::char_traits<char>,
-	                 std::allocator<char> >(__zero, __one);
-      }
-
-      using _Base::count;
-      using _Base::size;
-
       bool
       operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
       { return _M_base() == __rhs; }
@@ -315,11 +183,6 @@ namespace __profile
       operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
       { return _M_base() != __rhs; }
 
-      using _Base::test;
-      using _Base::all;
-      using _Base::any;
-      using _Base::none;
-
       bitset<_Nb>
       operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT
       { return bitset<_Nb>(_M_base() << __pos); }

libstdc++-v3/include/profile/deque

@@ -43,26 +43,29 @@ namespace __profile
       typedef  _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
 
     public:
-      typedef typename _Base::reference             reference;
-      typedef typename _Base::const_reference       const_reference;
-
-      typedef typename _Base::iterator             iterator;
-      typedef typename _Base::const_iterator       const_iterator;
-      typedef typename _Base::reverse_iterator     reverse_iterator;
-      typedef typename _Base::const_reverse_iterator const_reverse_iterator;
-
-      typedef typename _Base::size_type             size_type;
-      typedef typename _Base::difference_type       difference_type;
-
-      typedef _Tp				    value_type;
-      typedef _Allocator			    allocator_type;
-      typedef typename _Base::pointer               pointer;
-      typedef typename _Base::const_pointer         const_pointer;
+      typedef typename _Base::size_type			size_type;
+      typedef typename _Base::value_type		value_type;
 
       // 23.2.1.1 construct/copy/destroy:
 
+#if __cplusplus < 201103L
       deque()
       : _Base() { }
+      deque(const deque& __x)
+      : _Base(__x) { }
+
+      ~deque() { }
+#else
+      deque() = default;
+      deque(const deque&) = default;
+      deque(deque&&) = default;
+
+      ~deque() = default;
+
+      deque(initializer_list<value_type> __l,
+	    const _Allocator& __a = _Allocator())
+      : _Base(__l, __a) { }
+#endif
 
       explicit
       deque(const _Allocator& __a)
@@ -89,346 +92,48 @@ namespace __profile
 #else
       template<typename _InputIterator>
 #endif
-        deque(_InputIterator __first, _InputIterator __last,
+	deque(_InputIterator __first, _InputIterator __last,
 	      const _Allocator& __a = _Allocator())
 	: _Base(__first, __last, __a)
-        { }
-
-      deque(const deque& __x)
-      : _Base(__x) { }
+	{ }
 
       deque(const _Base& __x)
       : _Base(__x) { }
 
-#if __cplusplus >= 201103L
-      deque(deque&& __x)
-      : _Base(std::move(__x))
-      { }
-
-      deque(initializer_list<value_type> __l,
-	    const allocator_type& __a = allocator_type())
-      : _Base(__l, __a) { }
-#endif
-
-      ~deque() _GLIBCXX_NOEXCEPT { }
-
+#if __cplusplus < 201103L
       deque&
       operator=(const deque& __x)
       {
-	*static_cast<_Base*>(this) = __x;
+	_M_base() = __x;
 	return *this;
       }
+#else
+      deque&
+      operator=(const deque&) = default;
 
-#if __cplusplus >= 201103L
       deque&
-      operator=(deque&& __x) noexcept
-      {
-	// NB: DR 1204.
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x);
-	return *this;
-      }
+      operator=(deque&&) = default;
 
       deque&
       operator=(initializer_list<value_type> __l)
       {
-	*static_cast<_Base*>(this) = __l;
+	_M_base() = __l;
 	return *this;
       }
 #endif
 
-#if __cplusplus >= 201103L
-      template<typename _InputIterator,
-	       typename = std::_RequireInputIter<_InputIterator>>
-#else
-      template<typename _InputIterator>
-#endif
-        void
-        assign(_InputIterator __first, _InputIterator __last)
-        {
-	  _Base::assign(__first, __last);
-	}
-
-      void
-      assign(size_type __n, const _Tp& __t)
-      {
-	_Base::assign(__n, __t);
-      }
-
-#if __cplusplus >= 201103L
-      void
-      assign(initializer_list<value_type> __l)
-      {
-	_Base::assign(__l);
-      }
-#endif
-
-      using _Base::get_allocator;
-
-      // iterators:
-      iterator
-      begin() _GLIBCXX_NOEXCEPT
-      { return iterator(_Base::begin()); }
-
-      const_iterator
-      begin() const _GLIBCXX_NOEXCEPT
-      { return const_iterator(_Base::begin()); }
-
-      iterator
-      end() _GLIBCXX_NOEXCEPT
-      { return iterator(_Base::end()); }
-
-      const_iterator
-      end() const _GLIBCXX_NOEXCEPT
-      { return const_iterator(_Base::end()); }
-
-      reverse_iterator
-      rbegin() _GLIBCXX_NOEXCEPT
-      { return reverse_iterator(end()); }
-
-      const_reverse_iterator
-      rbegin() const _GLIBCXX_NOEXCEPT
-      { return const_reverse_iterator(end()); }
-
-      reverse_iterator
-      rend() _GLIBCXX_NOEXCEPT
-      { return reverse_iterator(begin()); }
-
-      const_reverse_iterator
-      rend() const _GLIBCXX_NOEXCEPT
-      { return const_reverse_iterator(begin()); }
-
-#if __cplusplus >= 201103L
-      const_iterator
-      cbegin() const noexcept
-      { return const_iterator(_Base::begin()); }
-
-      const_iterator
-      cend() const noexcept
-      { return const_iterator(_Base::end()); }
-
-      const_reverse_iterator
-      crbegin() const noexcept
-      { return const_reverse_iterator(end()); }
-
-      const_reverse_iterator
-      crend() const noexcept
-      { return const_reverse_iterator(begin()); }
-#endif
-
-      // 23.2.1.2 capacity:
-      using _Base::size;
-      using _Base::max_size;
-
-#if __cplusplus >= 201103L
-      void
-      resize(size_type __sz)
-      {
-	_Base::resize(__sz);
-      }
-
-      void
-      resize(size_type __sz, const _Tp& __c)
-      {
-	_Base::resize(__sz, __c);
-      }
-#else
       void
-      resize(size_type __sz, _Tp __c = _Tp())
-      {
-	_Base::resize(__sz, __c);
-      }
-#endif
-
+      swap(deque& __x)
 #if __cplusplus >= 201103L
-      using _Base::shrink_to_fit;
+	noexcept( noexcept(declval<_Base>().swap(__x)) )
 #endif
-
-      using _Base::empty;
-
-      // element access:
-      reference
-      operator[](size_type __n) _GLIBCXX_NOEXCEPT
-      {
-	return _M_base()[__n];
-      }
-
-      const_reference
-      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
-      {
-	return _M_base()[__n];
-      }
-
-      using _Base::at;
-
-      reference
-      front() _GLIBCXX_NOEXCEPT
-      {
-	return _Base::front();
-      }
-
-      const_reference
-      front() const _GLIBCXX_NOEXCEPT
-      {
-	return _Base::front();
-      }
-
-      reference
-      back() _GLIBCXX_NOEXCEPT
-      {
-	return _Base::back();
-      }
-
-      const_reference
-      back() const _GLIBCXX_NOEXCEPT
-      {
-	return _Base::back();
-      }
-
-      // 23.2.1.3 modifiers:
-      void
-      push_front(const _Tp& __x)
-      {
-	_Base::push_front(__x);
-      }
-
-      void
-      push_back(const _Tp& __x)
-      {
-	_Base::push_back(__x);
-      }
-
-#if __cplusplus >= 201103L
-      void
-      push_front(_Tp&& __x)
-      { emplace_front(std::move(__x)); }
-
-      void
-      push_back(_Tp&& __x)
-      { emplace_back(std::move(__x)); }
-
-      template<typename... _Args>
-        void
-        emplace_front(_Args&&... __args)
-	{
-	  _Base::emplace_front(std::forward<_Args>(__args)...);
-	}
-
-      template<typename... _Args>
-        void
-        emplace_back(_Args&&... __args)
-	{
-	  _Base::emplace_back(std::forward<_Args>(__args)...);
-	}
-
-      template<typename... _Args>
-        iterator
-        emplace(const_iterator __position, _Args&&... __args)
-	{
-	  typename _Base::iterator __res = _Base::emplace(__position,
-					    std::forward<_Args>(__args)...);
-	  return iterator(__res);
-	}
-#endif
-
-      iterator
-#if __cplusplus >= 201103L
-      insert(const_iterator __position, const _Tp& __x)
-#else
-      insert(iterator __position, const _Tp& __x)
-#endif
-      {
-	typename _Base::iterator __res = _Base::insert(__position, __x);
-	return iterator(__res);
-      }
-
-#if __cplusplus >= 201103L
-      iterator
-      insert(const_iterator __position, _Tp&& __x)
-      { return emplace(__position, std::move(__x)); }
-
-      iterator
-      insert(const_iterator __p, initializer_list<value_type> __l)
-      { return _Base::insert(__p, __l); }
-#endif
-
-#if __cplusplus >= 201103L
-      iterator
-      insert(const_iterator __position, size_type __n, const _Tp& __x)
-      { return _Base::insert(__position, __n, __x); }
-#else
-      void
-      insert(iterator __position, size_type __n, const _Tp& __x)
-      { _Base::insert(__position, __n, __x); }
-#endif
-
-#if __cplusplus >= 201103L
-      template<typename _InputIterator,
-	       typename = std::_RequireInputIter<_InputIterator>>
-        iterator
-        insert(const_iterator __position,
-	       _InputIterator __first, _InputIterator __last)
-        { return _Base::insert(__position, __first, __last); }
-#else
-      template<typename _InputIterator>
-        void
-        insert(iterator __position,
-	       _InputIterator __first, _InputIterator __last)
-        { _Base::insert(__position, __first, __last); }
-#endif
-
-      void
-      pop_front() _GLIBCXX_NOEXCEPT
-      {
-	_Base::pop_front();
-      }
-
-      void
-      pop_back() _GLIBCXX_NOEXCEPT
-      {
-	_Base::pop_back();
-      }
-
-      iterator
-#if __cplusplus >= 201103L
-      erase(const_iterator __position)
-#else
-      erase(iterator __position)	
-#endif
-      {
-	return _Base::erase(__position);
-      }
-
-      iterator
-#if __cplusplus >= 201103L
-      erase(const_iterator __first, const_iterator __last)
-#else
-      erase(iterator __first, iterator __last)
-#endif
-      {
-	// _GLIBCXX_RESOLVE_LIB_DEFECTS
-	// 151. can't currently clear() empty container
-        return _Base::erase(__first, __last);
-      }
-
-      void
-      swap(deque& __x) _GLIBCXX_NOEXCEPT
-      {
-	_Base::swap(__x);
-      }
-
-      void
-      clear() _GLIBCXX_NOEXCEPT
-      {
-	_Base::clear();
-      }
+      { _Base::swap(__x); }
 
       _Base&
-      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
+      _M_base() _GLIBCXX_NOEXCEPT	{ return *this; }
 
       const _Base&
-      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
+      _M_base() const _GLIBCXX_NOEXCEPT	{ return *this; }
     };
 
   template<typename _Tp, typename _Alloc>

libstdc++-v3/include/profile/forward_list

@@ -46,13 +46,9 @@ namespace __profile
     {
       typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
 
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
-        rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type;
-
-      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
-
     public:
-      typedef typename _Base::size_type             size_type;
+      typedef typename _Base::size_type		size_type;
+      typedef typename _Base::const_iterator	const_iterator;
 
       // 23.2.3.1 construct/copy/destroy:
       explicit
@@ -73,98 +69,135 @@ namespace __profile
       { }
 
       forward_list(size_type __n, const _Tp& __value,
-                   const _Alloc& __al = _Alloc())
+		   const _Alloc& __al = _Alloc())
       : _Base(__n, __value, __al)
       { }
 
       template<typename _InputIterator,
 	       typename = std::_RequireInputIter<_InputIterator>>
-        forward_list(_InputIterator __first, _InputIterator __last,
-                     const _Alloc& __al = _Alloc())
-        : _Base(__first, __last, __al)
-        { }
-
-      forward_list(const forward_list& __list)
-      : _Base(__list)
-      { }
+	forward_list(_InputIterator __first, _InputIterator __last,
+		     const _Alloc& __al = _Alloc())
+	: _Base(__first, __last, __al)
+	{ }
 
-      forward_list(forward_list&& __list) noexcept
-      : _Base(std::move(__list)) { }
+      forward_list(const forward_list&) = default;
+      forward_list(forward_list&&) = default;
 
       forward_list(std::initializer_list<_Tp> __il,
-                   const _Alloc& __al = _Alloc())
+		   const _Alloc& __al = _Alloc())
       : _Base(__il, __al)
       { }
 
-      ~forward_list() noexcept
-      { }
+      ~forward_list() = default;
 
       forward_list&
-      operator=(const forward_list& __list)
-      {
-	static_cast<_Base&>(*this) = __list;
-	return *this;
-      }
+      operator=(const forward_list&) = default;
 
       forward_list&
-      operator=(forward_list&& __list)
-      noexcept(_Node_alloc_traits::_S_nothrow_move())
-      {
-	static_cast<_Base&>(*this) = std::move(__list);
-	return *this;
-      }
+      operator=(forward_list&&) = default;
 
       forward_list&
       operator=(std::initializer_list<_Tp> __il)
       {
-	static_cast<_Base&>(*this) = __il;
-        return *this;
+	_M_base() = __il;
+	return *this;
       }
 
+      void
+      swap(forward_list& __fl)
+	noexcept( noexcept(declval<_Base>().swap(__fl)) )
+      { _Base::swap(__fl); }
+
+      void
+      splice_after(const_iterator __pos, forward_list&& __fl)
+      { _Base::splice_after(__pos, std::move(__fl)); }
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list)
+      { _Base::splice_after(__pos, __list); }
+
+      void
+      splice_after(const_iterator __pos, forward_list&& __list,
+		   const_iterator __i)
+      { _Base::splice_after(__pos, std::move(__list), __i); }
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list,
+		   const_iterator __i)
+      { _Base::splice_after(__pos, __list, __i); }
+
+      void
+      splice_after(const_iterator __pos, forward_list&& __list,
+		   const_iterator __before, const_iterator __last)
+      { _Base::splice_after(__pos, std::move(__list), __before, __last); }
+
+      void
+      splice_after(const_iterator __pos, forward_list& __list,
+		   const_iterator __before, const_iterator __last)
+      { _Base::splice_after(__pos, __list, __before, __last); }
+
+      void
+      merge(forward_list&& __list)
+      { _Base::merge(std::move(__list)); }
+
+      void
+      merge(forward_list& __list)
+      { _Base::merge(__list); }
+
+      template<typename _Comp>
+	void
+	merge(forward_list&& __list, _Comp __comp)
+	{ _Base::merge(std::move(__list), __comp); }
+
+      template<typename _Comp>
+	void
+	merge(forward_list& __list, _Comp __comp)
+	{ _Base::merge(__list, __comp); }
+
       _Base&
-      _M_base() noexcept       { return *this; }
+      _M_base() noexcept	{ return *this; }
 
       const _Base&
-      _M_base() const noexcept { return *this; }
+      _M_base() const noexcept	{ return *this; }
     };
 
   template<typename _Tp, typename _Alloc>
     inline bool
     operator==(const forward_list<_Tp, _Alloc>& __lx,
-               const forward_list<_Tp, _Alloc>& __ly)
+	       const forward_list<_Tp, _Alloc>& __ly)
     { return __lx._M_base() == __ly._M_base(); }
 
   template<typename _Tp, typename _Alloc>
     inline bool
     operator<(const forward_list<_Tp, _Alloc>& __lx,
-              const forward_list<_Tp, _Alloc>& __ly)
+	      const forward_list<_Tp, _Alloc>& __ly)
     { return __lx._M_base() < __ly._M_base(); }
 
   template<typename _Tp, typename _Alloc>
     inline bool
     operator!=(const forward_list<_Tp, _Alloc>& __lx,
-               const forward_list<_Tp, _Alloc>& __ly)
+	       const forward_list<_Tp, _Alloc>& __ly)
     { return !(__lx == __ly); }
 
   /// Based on operator<
   template<typename _Tp, typename _Alloc>
     inline bool
     operator>(const forward_list<_Tp, _Alloc>& __lx,
-              const forward_list<_Tp, _Alloc>& __ly)
+	      const forward_list<_Tp, _Alloc>& __ly)
     { return (__ly < __lx); }
 
   /// Based on operator<
   template<typename _Tp, typename _Alloc>
     inline bool
     operator>=(const forward_list<_Tp, _Alloc>& __lx,
-               const forward_list<_Tp, _Alloc>& __ly)
+	       const forward_list<_Tp, _Alloc>& __ly)
     { return !(__lx < __ly); }
 
   /// Based on operator<
   template<typename _Tp, typename _Alloc>
     inline bool
     operator<=(const forward_list<_Tp, _Alloc>& __lx,
-               const forward_list<_Tp, _Alloc>& __ly)
+	       const forward_list<_Tp, _Alloc>& __ly)
     { return !(__ly < __lx); }
 
   /// See std::forward_list::swap().

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

@@ -40,7 +40,7 @@ namespace __gnu_profile
   __log2(std::size_t __size)
   {
     for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0;
-	 -- __bit_count) 
+	 -- __bit_count)
       if ((2 << __bit_count) & __size)
 	return __bit_count;
     return 0;
@@ -48,7 +48,7 @@ namespace __gnu_profile
 
   inline float
   __map_insert_cost(std::size_t __size)
-  { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value 
+  { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value
 	    * static_cast<float>(__log2(__size))); }
 
   inline float
@@ -61,7 +61,7 @@ namespace __gnu_profile
   { return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value
 	    * static_cast<float>(__log2(__size))); }
 
-  /** @brief A map-to-unordered_map instrumentation line in the 
+  /** @brief A map-to-unordered_map instrumentation line in the
       object table.  */
   class __map2umap_info
   : public __object_info_base
@@ -70,9 +70,9 @@ namespace __gnu_profile
     __map2umap_info()
     : _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0),
       _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), 
+    : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0),
       _M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { }
 
     virtual ~__map2umap_info() { }
@@ -108,32 +108,38 @@ namespace __gnu_profile
 
     std::string
     __advice() const
-    { return "change std::map to std::unordered_map"; }
+    { return "prefer an unordered container"; }
 
     void
     __record_insert(std::size_t __size, std::size_t __count)
     {
-      _M_insert += __count;
-      _M_map_cost += __count * __map_insert_cost(__size);
-      _M_umap_cost
-	+= (__count
-	    * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
+      ++_M_insert;
+      if (__count)
+	{
+	  _M_map_cost += __count * __map_insert_cost(__size);
+	  _M_umap_cost
+	    += (__count
+		* _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value);
+	}
     }
 
     void
     __record_erase(std::size_t __size, std::size_t __count)
     {
-      _M_erase += __count;
-      _M_map_cost += __count * __map_erase_cost(__size);
-      _M_umap_cost
-	+= (__count
-	    * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
+      ++_M_erase;
+      if (__count)
+	{
+	  _M_map_cost += __count * __map_erase_cost(__size);
+	  _M_umap_cost
+	    += (__count
+		* _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value);
+	}
     }
 
     void
     __record_find(std::size_t __size)
     {
-      _M_find += 1;
+      ++_M_find;
       _M_map_cost += __map_find_cost(__size);
       _M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value;
     }
@@ -165,9 +171,9 @@ namespace __gnu_profile
   };
 
 
-  /** @brief A map-to-unordered_map instrumentation line in the 
+  /** @brief A map-to-unordered_map instrumentation line in the
       stack table.  */
-  class __map2umap_stack_info 
+  class __map2umap_stack_info
   : public __map2umap_info
   {
   public:
@@ -177,12 +183,12 @@ namespace __gnu_profile
 
   /** @brief Map-to-unordered_map instrumentation producer.  */
   class __trace_map2umap
-  : public __trace_base<__map2umap_info, __map2umap_stack_info> 
+  : public __trace_base<__map2umap_info, __map2umap_stack_info>
   {
   public:
     __trace_map2umap()
     : __trace_base<__map2umap_info, __map2umap_stack_info>()
-    { __id = "map-to-unordered-map"; }
+    { __id = "ordered-to-unordered"; }
   };
 
   inline void
@@ -193,7 +199,7 @@ namespace __gnu_profile
   __trace_map_to_unordered_map_report(FILE* __f,
 				      __warning_vector_t& __warnings)
   {
-    if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) 
+    if (_GLIBCXX_PROFILE_DATA(_S_map2umap))
       {
 	_GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings);
 	_GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f);
@@ -220,7 +226,7 @@ namespace __gnu_profile
   }
 
   inline void
-  __trace_map_to_unordered_map_insert(const void* __obj, 
+  __trace_map_to_unordered_map_insert(const void* __obj,
 				      std::size_t __size, std::size_t __count)
   {
     if (!__profcxx_init())
@@ -234,13 +240,13 @@ namespace __gnu_profile
   }
 
   inline void
-  __trace_map_to_unordered_map_erase(const void* __obj, 
+  __trace_map_to_unordered_map_erase(const void* __obj,
 				     std::size_t __size, std::size_t __count)
   {
-    if (!__profcxx_init()) 
+    if (!__profcxx_init())
       return;
 
-    __map2umap_info* __info 
+    __map2umap_info* __info
       = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
 
     if (__info)
@@ -268,7 +274,7 @@ namespace __gnu_profile
 
     __map2umap_info* __info
       = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj);
-    
+
     if (__info)
       __info->__record_iterate(__count);
   }

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

@@ -35,9 +35,8 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 namespace __profile
 {
-
   template<typename _Iterator, typename _Sequence>
-    class __iterator_tracker 
+    class __iterator_tracker
     {
       typedef __iterator_tracker _Self;
 
@@ -49,12 +48,12 @@ namespace __profile
       typedef std::iterator_traits<_Iterator> _Traits;
 
     public:
-      typedef _Iterator		              _Base_iterator;
-      typedef typename _Traits::iterator_category iterator_category; 
-      typedef typename _Traits::value_type        value_type;
-      typedef typename _Traits::difference_type   difference_type;
-      typedef typename _Traits::reference         reference;
-      typedef typename _Traits::pointer           pointer;
+      typedef _Iterator					_Base_iterator;
+      typedef typename _Traits::iterator_category	iterator_category;
+      typedef typename _Traits::value_type		value_type;
+      typedef typename _Traits::difference_type		difference_type;
+      typedef typename _Traits::reference		reference;
+      typedef typename _Traits::pointer			pointer;
 
       __iterator_tracker() _GLIBCXX_NOEXCEPT
       : _M_current(), _M_ds(0) { }
@@ -67,7 +66,7 @@ namespace __profile
       : _M_current(__x._M_current), _M_ds(__x._M_ds) { }
 
       template<typename _MutableIterator>
-        __iterator_tracker(const __iterator_tracker<_MutableIterator,
+	__iterator_tracker(const __iterator_tracker<_MutableIterator,
 			   typename __gnu_cxx::__enable_if
 			   <(std::__are_same<_MutableIterator, typename
 			     _Sequence::iterator::_Base_iterator>::__value),
@@ -76,7 +75,7 @@ namespace __profile
 
       _Iterator
       base() const _GLIBCXX_NOEXCEPT { return _M_current; }
-  
+
       /**
        * @brief Conversion to underlying non-debug iterator to allow
        * better interaction with non-profile containers.
@@ -199,7 +198,7 @@ namespace __profile
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
-               const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)
     _GLIBCXX_NOEXCEPT
     { return __lhs.base() != __rhs.base(); }
 

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

+// Profiling unordered containers implementation details -*- C++ -*-
+
+// Copyright (C) 2014 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 of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+/** @file profile/ordered_base.h
+ *  This file is a GNU profile extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_PROFILE_ORDERED
+#define _GLIBCXX_PROFILE_ORDERED 1
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace __profile
+{
+  template<typename _Cont>
+    class _Ordered_profile
+    {
+      _Cont&
+      _M_conjure()
+      { return *static_cast<_Cont*>(this); }
+
+    public:
+      _Ordered_profile() _GLIBCXX_NOEXCEPT
+      { __profcxx_map_to_unordered_map_construct(&_M_conjure()); }
+
+#if __cplusplus >= 201103L
+      _Ordered_profile(const _Ordered_profile&) noexcept
+      : _Ordered_profile() { }
+      _Ordered_profile(_Ordered_profile&&) noexcept
+      : _Ordered_profile() { }
+
+      _Ordered_profile&
+      operator=(const _Ordered_profile&) = default;
+      _Ordered_profile&
+      operator=(_Ordered_profile&&) = default;
+#endif
+
+      ~_Ordered_profile()
+      { __profcxx_map_to_unordered_map_destruct(&_M_conjure()); }
+    };
+
+} // namespace __profile
+} // namespace std
+
+#endif

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

@@ -157,7 +157,7 @@ namespace __profile
       _Unordered_profile()
       {
 	auto& __uc = _M_conjure();
-        __profcxx_hashtable_construct(&__uc, __uc.bucket_count());
+	__profcxx_hashtable_construct(&__uc, __uc.bucket_count());
 	__profcxx_hashtable_construct2(&__uc);
       }
       _Unordered_profile(const _Unordered_profile&)
@@ -168,8 +168,8 @@ namespace __profile
       ~_Unordered_profile() noexcept
       {
 	auto& __uc = _M_conjure();
-        __profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size());
-        _M_profile_destruct();
+	__profcxx_hashtable_destruct(&__uc, __uc.bucket_count(), __uc.size());
+	_M_profile_destruct();
       }
 
       _Unordered_profile&
@@ -210,6 +210,7 @@ namespace __profile
 	  auto __lend = __uc.end(__bkt);
 	  for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit)
 	    ++__chain;
+
 	  if (__chain)
 	    {
 	      ++__chain;
@@ -245,6 +246,7 @@ namespace __profile
 		  __pit = __it;
 		}
 	    }
+
 	  if (__chain)
 	    {
 	      ++__chain;

libstdc++-v3/include/profile/unordered_set

@@ -44,7 +44,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
 namespace __profile
 {
   /** @brief Unordered_set wrapper with performance instrumentation.  */
-  template<typename _Key, 
+  template<typename _Key,
 	   typename _Hash = std::hash<_Key>,
 	   typename _Pred = std::equal_to<_Key>,
 	   typename _Alloc =  std::allocator<_Key> >
@@ -62,18 +62,18 @@ namespace __profile
       _M_base() const noexcept { return *this; }
 
     public:
-      typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
-      typedef typename _Base::key_equal       key_equal;
-      typedef typename _Base::allocator_type  allocator_type;
-      typedef typename _Base::key_type        key_type;
-      typedef typename _Base::value_type      value_type;
-      typedef typename _Base::difference_type difference_type;
-      typedef typename _Base::reference       reference;
-      typedef typename _Base::const_reference const_reference;
-
-      typedef typename _Base::iterator iterator;
-      typedef typename _Base::const_iterator const_iterator;
+      typedef typename _Base::size_type		size_type;
+      typedef typename _Base::hasher		hasher;
+      typedef typename _Base::key_equal		key_equal;
+      typedef typename _Base::allocator_type	allocator_type;
+      typedef typename _Base::key_type		key_type;
+      typedef typename _Base::value_type	value_type;
+      typedef typename _Base::difference_type	difference_type;
+      typedef typename _Base::reference		reference;
+      typedef typename _Base::const_reference	const_reference;
+
+      typedef typename _Base::iterator		iterator;
+      typedef typename _Base::const_iterator	const_iterator;
 
       explicit
       unordered_set(size_type __n = 10,
@@ -84,7 +84,7 @@ namespace __profile
       { }
 
       template<typename _InputIterator>
-        unordered_set(_InputIterator __f, _InputIterator __l,
+	unordered_set(_InputIterator __f, _InputIterator __l,
 		      size_type __n = 0,
 		      const hasher& __hf = hasher(),
 		      const key_equal& __eql = key_equal(),
@@ -144,10 +144,10 @@ namespace __profile
       void
       clear() noexcept
       {
-        __profcxx_hashtable_destruct(this, _Base::bucket_count(), 
-                                     _Base::size());
-        this->_M_profile_destruct();
-        _Base::clear();
+	__profcxx_hashtable_destruct(this, _Base::bucket_count(),
+				     _Base::size());
+	this->_M_profile_destruct();
+	_Base::clear();
       }
 
       template<typename... _Args>
@@ -174,63 +174,63 @@ namespace __profile
 
       void
       insert(std::initializer_list<value_type> __l)
-      { 
-        size_type __old_size = _Base::bucket_count();
-        _Base::insert(__l); 
-        _M_profile_resize(__old_size); 
+      {
+	size_type __old_size = _Base::bucket_count();
+	_Base::insert(__l);
+	_M_profile_resize(__old_size);
       }
 
       std::pair<iterator, bool>
       insert(const value_type& __obj)
       {
-        size_type __old_size = _Base::bucket_count();
-        std::pair<iterator, bool> __res = _Base::insert(__obj);
-        _M_profile_resize(__old_size); 
-        return __res;
+	size_type __old_size = _Base::bucket_count();
+	std::pair<iterator, bool> __res = _Base::insert(__obj);
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       iterator
       insert(const_iterator __iter, const value_type& __v)
-      { 
-        size_type __old_size = _Base::bucket_count(); 
-        iterator __res = _Base::insert(__iter, __v);
-        _M_profile_resize(__old_size); 
-        return __res;
+      {
+	size_type __old_size = _Base::bucket_count();
+	iterator __res = _Base::insert(__iter, __v);
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       std::pair<iterator, bool>
       insert(value_type&& __obj)
       {
-        size_type __old_size = _Base::bucket_count();
-        std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
-        _M_profile_resize(__old_size); 
-        return __res;
+	size_type __old_size = _Base::bucket_count();
+	std::pair<iterator, bool> __res = _Base::insert(std::move(__obj));
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       iterator
       insert(const_iterator __iter, value_type&& __v)
-      { 
-        size_type __old_size = _Base::bucket_count();
-        iterator __res = _Base::insert(__iter, std::move(__v));
-        _M_profile_resize(__old_size); 
-        return __res;
+      {
+	size_type __old_size = _Base::bucket_count();
+	iterator __res = _Base::insert(__iter, std::move(__v));
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       template<typename _InputIter>
-        void
-        insert(_InputIter __first, _InputIter __last)
-        {
-	  size_type __old_size = _Base::bucket_count(); 
+	void
+	insert(_InputIter __first, _InputIter __last)
+	{
+	  size_type __old_size = _Base::bucket_count();
 	  _Base::insert(__first, __last);
-	  _M_profile_resize(__old_size); 
+	  _M_profile_resize(__old_size);
 	}
 
       void
       rehash(size_type __n)
       {
-        size_type __old_size = _Base::bucket_count();
-        _Base::rehash(__n);
-        _M_profile_resize(__old_size); 
+	size_type __old_size = _Base::bucket_count();
+	_Base::rehash(__n);
+	_M_profile_resize(__old_size);
       }
 
     private:
@@ -287,10 +287,10 @@ namespace __profile
 
     public:
       typedef typename _Base::size_type       size_type;
-      typedef typename _Base::hasher          hasher;
+      typedef typename _Base::hasher	  hasher;
       typedef typename _Base::key_equal       key_equal;
       typedef typename _Base::allocator_type  allocator_type;
-      typedef typename _Base::key_type        key_type;
+      typedef typename _Base::key_type	key_type;
       typedef typename _Base::value_type      value_type;
       typedef typename _Base::difference_type difference_type;
       typedef typename _Base::reference       reference;
@@ -308,7 +308,7 @@ namespace __profile
       { }
 
       template<typename _InputIterator>
-        unordered_multiset(_InputIterator __f, _InputIterator __l,
+	unordered_multiset(_InputIterator __f, _InputIterator __l,
 			   size_type __n = 0,
 			   const hasher& __hf = hasher(),
 			   const key_equal& __eql = key_equal(),
@@ -368,10 +368,10 @@ namespace __profile
       void
       clear() noexcept
       {
-        __profcxx_hashtable_destruct(this, _Base::bucket_count(), 
-                                     _Base::size());
-        this->_M_profile_destruct();
-        _Base::clear();
+	__profcxx_hashtable_destruct(this, _Base::bucket_count(),
+				     _Base::size());
+	this->_M_profile_destruct();
+	_Base::clear();
       }
 
       template<typename... _Args>
@@ -397,63 +397,63 @@ namespace __profile
 
       void
       insert(std::initializer_list<value_type> __l)
-      { 
-        size_type __old_size = _Base::bucket_count();
-        _Base::insert(__l); 
-        _M_profile_resize(__old_size); 
+      {
+	size_type __old_size = _Base::bucket_count();
+	_Base::insert(__l);
+	_M_profile_resize(__old_size);
       }
 
       iterator
       insert(const value_type& __obj)
       {
-        size_type __old_size = _Base::bucket_count();
-        iterator __res = _Base::insert(__obj);
-        _M_profile_resize(__old_size); 
-        return __res;
+	size_type __old_size = _Base::bucket_count();
+	iterator __res = _Base::insert(__obj);
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       iterator
       insert(const_iterator __iter, const value_type& __v)
       {
-        size_type __old_size = _Base::bucket_count(); 
-        iterator __res = _Base::insert(__iter, __v);
-        _M_profile_resize(__old_size); 
-        return __res;
+	size_type __old_size = _Base::bucket_count();
+	iterator __res = _Base::insert(__iter, __v);
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       iterator
       insert(value_type&& __obj)
       {
 	size_type __old_size = _Base::bucket_count();
-        iterator __res = _Base::insert(std::move(__obj));
-        _M_profile_resize(__old_size); 
-        return __res;
+	iterator __res = _Base::insert(std::move(__obj));
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       iterator
       insert(const_iterator __iter, value_type&& __v)
       {
-        size_type __old_size = _Base::bucket_count(); 
-        iterator __res = _Base::insert(__iter, std::move(__v));
-        _M_profile_resize(__old_size); 
-        return __res;
+	size_type __old_size = _Base::bucket_count();
+	iterator __res = _Base::insert(__iter, std::move(__v));
+	_M_profile_resize(__old_size);
+	return __res;
       }
 
       template<typename _InputIter>
-        void
-        insert(_InputIter __first, _InputIter __last)
-        {
-	  size_type __old_size = _Base::bucket_count(); 
+	void
+	insert(_InputIter __first, _InputIter __last)
+	{
+	  size_type __old_size = _Base::bucket_count();
 	  _Base::insert(__first, __last);
-	  _M_profile_resize(__old_size); 
+	  _M_profile_resize(__old_size);
 	}
 
       void
       rehash(size_type __n)
       {
-        size_type __old_size = _Base::bucket_count();
-        _Base::rehash(__n);
-        _M_profile_resize(__old_size); 
+	size_type __old_size = _Base::bucket_count();
+	_Base::rehash(__n);
+	_M_profile_resize(__old_size);
       }
 
     private:
@@ -461,8 +461,8 @@ namespace __profile
       _M_profile_resize(size_type __old_size)
       {
 	size_type __new_size = _Base::bucket_count();
-        if (__old_size != __new_size)
-          __profcxx_hashtable_resize(this, __old_size, __new_size);
+	if (__old_size != __new_size)
+	  __profcxx_hashtable_resize(this, __old_size, __new_size);
       }
    };