Patchwork [v3] More noexcept -- 6th

login
register
mail settings
Submitter Marc Glisse
Date Sept. 24, 2013, 4:13 p.m.
Message ID <alpine.DEB.2.02.1309241730280.9069@stedding.saclay.inria.fr>
Download mbox | patch
Permalink /patch/277534/
State New
Headers show

Comments

Marc Glisse - Sept. 24, 2013, 4:13 p.m.
Hello,

bootstrap+testsuite ok. I think all container iterators are done, but not 
the containers themselves.

2013-09-25  Marc Glisse  <marc.glisse@inria.fr>

 	PR libstdc++/58338
 	* include/bits/forward_list.h (_Fwd_list_node_base::_M_transfer_after):
 	Mark as noexcept.
 	(_Fwd_list_iterator) [_Fwd_list_iterator, operator*, operator->,
 	operator++, operator==, operator!=, _M_next]: Likewise.
 	(_Fwd_list_const_iterator) [_Fwd_list_const_iterator, operator*,
 	operator->, operator++, operator==, operator!=, _M_next]: Likewise.
 	(operator==(const _Fwd_list_iterator&, const _Fwd_list_const_iterator&),
 	operator!=(const _Fwd_list_iterator&, const _Fwd_list_const_iterator&)):
 	Likewise.
 	* include/bits/hashtable_policy.h (_Hash_node_base::_Hash_node_base,
 	_Hash_node::_M_next, _Node_iterator_base::_Node_iterator_base,
 	_Node_iterator_base::_M_incr, operator==(const _Node_iterator_base&,
 	const _Node_iterator_base&), operator!=(const _Node_iterator_base&,
 	const _Node_iterator_base&)): Likewise.
 	(_Node_iterator) [_Node_iterator, operator*, operator->, operator++]:
 	Likewise.
 	(_Node_const_iterator) [_Node_const_iterator, operator*, operator->,
 	operator++]: Likewise.
 	* include/debug/safe_iterator.h (_Safe_iterator) [_Safe_iterator,
 	operator=, operator*, operator->, operator++, operator--, operator[],
 	operator+=, operator+, operator-=, operator-, base, operator _Iterator]:
 	Likewise.
 	(operator==(const _Safe_iterator&, const _Safe_iterator&),
 	operator!=(const _Safe_iterator&, const _Safe_iterator&),
 	operator<(const _Safe_iterator&, const _Safe_iterator&),
 	operator<=(const _Safe_iterator&, const _Safe_iterator&),
 	operator>(const _Safe_iterator&, const _Safe_iterator&),
 	operator>=(const _Safe_iterator&, const _Safe_iterator&),
 	operator-(const _Safe_iterator&, const _Safe_iterator&),
 	operator+(difference_type, const _Safe_iterator&)): Likewise.
 	* include/profile/iterator_tracker.h (__iterator_tracker)
 	[__iterator_tracker, base, operator _Iterator, operator->, operator++,
 	operator--, operator=, operator*, operator[], operator+=, operator+,
 	operator-=, operator-]: Likewise.
 	(operator==(const __iterator_tracker&, const __iterator_tracker&),
 	operator!=(const __iterator_tracker&, const __iterator_tracker&),
 	operator<(const __iterator_tracker&, const __iterator_tracker&),
 	operator<=(const __iterator_tracker&, const __iterator_tracker&),
 	operator>(const __iterator_tracker&, const __iterator_tracker&),
 	operator>=(const __iterator_tracker&, const __iterator_tracker&),
 	operator-(const __iterator_tracker&, const __iterator_tracker&),
 	operator+(difference_type, const __iterator_tracker&)): Likewise.
Paolo Carlini - Sept. 24, 2013, 4:25 p.m.
Hi,

On 9/24/13 11:13 AM, Marc Glisse wrote:
> Hello,
>
> bootstrap+testsuite ok. I think all container iterators are done, but 
> not the containers themselves.
Ok, thanks.

Paolo.

Patch

Index: include/bits/forward_list.h

===================================================================
--- include/bits/forward_list.h	(revision 202868)

+++ include/bits/forward_list.h	(working copy)

@@ -51,21 +51,21 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER

    *          There are purely list shuffling utility methods here.
    */
   struct _Fwd_list_node_base
   {
     _Fwd_list_node_base() = default;
 
     _Fwd_list_node_base* _M_next = nullptr;
 
     _Fwd_list_node_base*
     _M_transfer_after(_Fwd_list_node_base* __begin,
-		      _Fwd_list_node_base* __end)

+		      _Fwd_list_node_base* __end) noexcept

     {
       _Fwd_list_node_base* __keep = __begin->_M_next;
       if (__end)
 	{
 	  __begin->_M_next = __end->_M_next;
 	  __end->_M_next = _M_next;
 	}
       else
 	__begin->_M_next = 0;
       _M_next = __keep;
@@ -121,60 +121,60 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER

     {
       typedef _Fwd_list_iterator<_Tp>            _Self;
       typedef _Fwd_list_node<_Tp>                _Node;
 
       typedef _Tp                                value_type;
       typedef _Tp*                               pointer;
       typedef _Tp&                               reference;
       typedef ptrdiff_t                          difference_type;
       typedef std::forward_iterator_tag          iterator_category;
 
-      _Fwd_list_iterator()

+      _Fwd_list_iterator() noexcept

       : _M_node() { }
 
       explicit
-      _Fwd_list_iterator(_Fwd_list_node_base* __n) 

+      _Fwd_list_iterator(_Fwd_list_node_base* __n) noexcept

       : _M_node(__n) { }
 
       reference
-      operator*() const

+      operator*() const noexcept

       { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       pointer
-      operator->() const

+      operator->() const noexcept

       { return static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       _Self&
-      operator++()

+      operator++() noexcept

       {
         _M_node = _M_node->_M_next;
         return *this;
       }
 
       _Self
-      operator++(int)

+      operator++(int) noexcept

       {
         _Self __tmp(*this);
         _M_node = _M_node->_M_next;
         return __tmp;
       }
 
       bool
-      operator==(const _Self& __x) const

+      operator==(const _Self& __x) const noexcept

       { return _M_node == __x._M_node; }
 
       bool
-      operator!=(const _Self& __x) const

+      operator!=(const _Self& __x) const noexcept

       { return _M_node != __x._M_node; }
 
       _Self
-      _M_next() const

+      _M_next() const noexcept

       {
         if (_M_node)
           return _Fwd_list_iterator(_M_node->_M_next);
         else
           return _Fwd_list_iterator(0);
       }
 
       _Fwd_list_node_base* _M_node;
     };
 
@@ -189,89 +189,89 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER

       typedef _Fwd_list_const_iterator<_Tp>      _Self;
       typedef const _Fwd_list_node<_Tp>          _Node;
       typedef _Fwd_list_iterator<_Tp>            iterator;
 
       typedef _Tp                                value_type;
       typedef const _Tp*                         pointer;
       typedef const _Tp&                         reference;
       typedef ptrdiff_t                          difference_type;
       typedef std::forward_iterator_tag          iterator_category;
 
-      _Fwd_list_const_iterator()

+      _Fwd_list_const_iterator() noexcept

       : _M_node() { }
 
       explicit
-      _Fwd_list_const_iterator(const _Fwd_list_node_base* __n) 

+      _Fwd_list_const_iterator(const _Fwd_list_node_base* __n)  noexcept

       : _M_node(__n) { }
 
-      _Fwd_list_const_iterator(const iterator& __iter)

+      _Fwd_list_const_iterator(const iterator& __iter) noexcept

       : _M_node(__iter._M_node) { }
 
       reference
-      operator*() const

+      operator*() const noexcept

       { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       pointer
-      operator->() const

+      operator->() const noexcept

       { return static_cast<_Node*>(this->_M_node)->_M_valptr(); }
 
       _Self&
-      operator++()

+      operator++() noexcept

       {
         _M_node = _M_node->_M_next;
         return *this;
       }
 
       _Self
-      operator++(int)

+      operator++(int) noexcept

       {
         _Self __tmp(*this);
         _M_node = _M_node->_M_next;
         return __tmp;
       }
 
       bool
-      operator==(const _Self& __x) const

+      operator==(const _Self& __x) const noexcept

       { return _M_node == __x._M_node; }
 
       bool
-      operator!=(const _Self& __x) const

+      operator!=(const _Self& __x) const noexcept

       { return _M_node != __x._M_node; }
 
       _Self
-      _M_next() const

+      _M_next() const noexcept

       {
         if (this->_M_node)
           return _Fwd_list_const_iterator(_M_node->_M_next);
         else
           return _Fwd_list_const_iterator(0);
       }
 
       const _Fwd_list_node_base* _M_node;
     };
 
   /**
    *  @brief  Forward list iterator equality comparison.
    */
   template<typename _Tp>
     inline bool
     operator==(const _Fwd_list_iterator<_Tp>& __x,
-               const _Fwd_list_const_iterator<_Tp>& __y)

+               const _Fwd_list_const_iterator<_Tp>& __y) noexcept

     { return __x._M_node == __y._M_node; }
 
   /**
    *  @brief  Forward list iterator inequality comparison.
    */
   template<typename _Tp>
     inline bool
     operator!=(const _Fwd_list_iterator<_Tp>& __x,
-               const _Fwd_list_const_iterator<_Tp>& __y)

+               const _Fwd_list_const_iterator<_Tp>& __y) noexcept

     { return __x._M_node != __y._M_node; }
 
   /**
    *  @brief  Base class for %forward_list.
    */
   template<typename _Tp, typename _Alloc>
     struct _Fwd_list_base
     {
     protected:
       typedef typename __gnu_cxx::__alloc_traits<_Alloc> _Alloc_traits;
Index: include/bits/hashtable_policy.h

===================================================================
--- include/bits/hashtable_policy.h	(revision 202868)

+++ include/bits/hashtable_policy.h	(working copy)

@@ -223,23 +223,23 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION

    *
    *  Nodes, used to wrap elements stored in the hash table.  A policy
    *  template parameter of class template _Hashtable controls whether
    *  nodes also store a hash code. In some cases (e.g. strings) this
    *  may be a performance win.
    */
   struct _Hash_node_base
   {
     _Hash_node_base* _M_nxt;
 
-    _Hash_node_base() : _M_nxt() { }

+    _Hash_node_base() noexcept : _M_nxt() { }

 
-    _Hash_node_base(_Hash_node_base* __next) : _M_nxt(__next) { }

+    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }

   };
 
   /**
    *  struct _Hash_node_value_base
    *
    *  Node type with the value to store.
    */
   template<typename _Value>
     struct _Hash_node_value_base : _Hash_node_base
     {
@@ -274,61 +274,65 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION

    *  Specialization for nodes with caches, struct _Hash_node.
    *
    *  Base class is __detail::_Hash_node_value_base.
    */
   template<typename _Value>
     struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value>
     {
       std::size_t  _M_hash_code;
 
       _Hash_node*
-      _M_next() const { return static_cast<_Hash_node*>(this->_M_nxt); }

+      _M_next() const noexcept

+      { return static_cast<_Hash_node*>(this->_M_nxt); }

     };
 
   /**
    *  Specialization for nodes without caches, struct _Hash_node.
    *
    *  Base class is __detail::_Hash_node_value_base.
    */
   template<typename _Value>
     struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
     {
       _Hash_node*
-      _M_next() const { return static_cast<_Hash_node*>(this->_M_nxt); }

+      _M_next() const noexcept

+      { return static_cast<_Hash_node*>(this->_M_nxt); }

     };
 
   /// Base class for node iterators.
   template<typename _Value, bool _Cache_hash_code>
     struct _Node_iterator_base
     {
       using __node_type = _Hash_node<_Value, _Cache_hash_code>;
 
       __node_type*  _M_cur;
 
-      _Node_iterator_base(__node_type* __p)

+      _Node_iterator_base(__node_type* __p) noexcept

       : _M_cur(__p) { }
 
       void
-      _M_incr()

+      _M_incr() noexcept

       { _M_cur = _M_cur->_M_next(); }
     };
 
   template<typename _Value, bool _Cache_hash_code>
     inline bool
     operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
 	       const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
+    noexcept

     { return __x._M_cur == __y._M_cur; }
 
   template<typename _Value, bool _Cache_hash_code>
     inline bool
     operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
 	       const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
+    noexcept

     { return __x._M_cur != __y._M_cur; }
 
   /// Node iterators, used to iterate through all the hashtable.
   template<typename _Value, bool __constant_iterators, bool __cache>
     struct _Node_iterator
     : public _Node_iterator_base<_Value, __cache>
     {
     private:
       using __base_type = _Node_iterator_base<_Value, __cache>;
       using __node_type = typename __base_type::__node_type;
@@ -337,44 +341,44 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION

       typedef _Value					value_type;
       typedef std::ptrdiff_t				difference_type;
       typedef std::forward_iterator_tag			iterator_category;
 
       using pointer = typename std::conditional<__constant_iterators,
 						const _Value*, _Value*>::type;
 
       using reference = typename std::conditional<__constant_iterators,
 						  const _Value&, _Value&>::type;
 
-      _Node_iterator()

+      _Node_iterator() noexcept

       : __base_type(0) { }
 
       explicit
-      _Node_iterator(__node_type* __p)

+      _Node_iterator(__node_type* __p) noexcept

       : __base_type(__p) { }
 
       reference
-      operator*() const

+      operator*() const noexcept

       { return this->_M_cur->_M_v(); }
 
       pointer
-      operator->() const

+      operator->() const noexcept

       { return this->_M_cur->_M_valptr(); }
 
       _Node_iterator&
-      operator++()

+      operator++() noexcept

       {
 	this->_M_incr();
 	return *this;
       }
 
       _Node_iterator
-      operator++(int)

+      operator++(int) noexcept

       {
 	_Node_iterator __tmp(*this);
 	this->_M_incr();
 	return __tmp;
       }
     };
 
   /// Node const_iterators, used to iterate through all the hashtable.
   template<typename _Value, bool __constant_iterators, bool __cache>
     struct _Node_const_iterator
@@ -385,48 +389,48 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION

       using __node_type = typename __base_type::__node_type;
 
     public:
       typedef _Value					value_type;
       typedef std::ptrdiff_t				difference_type;
       typedef std::forward_iterator_tag			iterator_category;
 
       typedef const _Value*				pointer;
       typedef const _Value&				reference;
 
-      _Node_const_iterator()

+      _Node_const_iterator() noexcept

       : __base_type(0) { }
 
       explicit
-      _Node_const_iterator(__node_type* __p)

+      _Node_const_iterator(__node_type* __p) noexcept

       : __base_type(__p) { }
 
       _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
-			   __cache>& __x)

+			   __cache>& __x) noexcept

       : __base_type(__x._M_cur) { }
 
       reference
-      operator*() const

+      operator*() const noexcept

       { return this->_M_cur->_M_v(); }
 
       pointer
-      operator->() const

+      operator->() const noexcept

       { return this->_M_cur->_M_valptr(); }
 
       _Node_const_iterator&
-      operator++()

+      operator++() noexcept

       {
 	this->_M_incr();
 	return *this;
       }
 
       _Node_const_iterator
-      operator++(int)

+      operator++(int) noexcept

       {
 	_Node_const_iterator __tmp(*this);
 	this->_M_incr();
 	return __tmp;
       }
     };
 
   // Many of class template _Hashtable's template parameters are policy
   // classes.  These are defaults for the policies.
 
Index: include/debug/safe_iterator.h

===================================================================
--- include/debug/safe_iterator.h	(revision 202868)

+++ include/debug/safe_iterator.h	(working copy)

@@ -132,58 +132,59 @@  namespace __gnu_debug

 
     public:
       typedef _Iterator                           iterator_type;
       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;
 
       /// @post the iterator is singular and unattached
-      _Safe_iterator() : _M_current() { }

+      _Safe_iterator() _GLIBCXX_NOEXCEPT : _M_current() { }

 
       /**
        * @brief Safe iterator construction from an unsafe iterator and
        * its sequence.
        *
        * @pre @p seq is not NULL
        * @post this is not singular
        */
       _Safe_iterator(const _Iterator& __i, const _Sequence* __seq)
+      _GLIBCXX_NOEXCEPT

       : _Safe_iterator_base(__seq, _M_constant()), _M_current(__i)
       {
 	_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
 			      _M_message(__msg_init_singular)
 			      ._M_iterator(*this, "this"));
       }
 
       /**
        * @brief Copy construction.
        */
-      _Safe_iterator(const _Safe_iterator& __x)

+      _Safe_iterator(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT

       : _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current)
       {
 	// _GLIBCXX_RESOLVE_LIB_DEFECTS
 	// DR 408. Is vector<reverse_iterator<char*> > forbidden?
 	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 			      || __x._M_current == _Iterator(),
 			      _M_message(__msg_init_copy_singular)
 			      ._M_iterator(*this, "this")
 			      ._M_iterator(__x, "other"));
       }
 
 #if __cplusplus >= 201103L
       /**
        * @brief Move construction.
        * @post __x is singular and unattached
        */
-      _Safe_iterator(_Safe_iterator&& __x) : _M_current()

+      _Safe_iterator(_Safe_iterator&& __x) noexcept : _M_current()

       {
 	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 			      || __x._M_current == _Iterator(),
 			      _M_message(__msg_init_copy_singular)
 			      ._M_iterator(*this, "this")
 			      ._M_iterator(__x, "other"));
 	std::swap(_M_current, __x._M_current);
 	this->_M_attach(__x._M_sequence);
 	__x._M_detach();
       }
@@ -191,57 +192,57 @@  namespace __gnu_debug

 
       /**
        *  @brief Converting constructor from a mutable iterator to a
        *  constant iterator.
       */
       template<typename _MutableIterator>
         _Safe_iterator(
           const _Safe_iterator<_MutableIterator,
           typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator,
                       typename _Sequence::iterator::iterator_type>::__value),
-                   _Sequence>::__type>& __x)

+                   _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT

 	: _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base())
         {
 	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
 	  // DR 408. Is vector<reverse_iterator<char*> > forbidden?
 	  _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 				|| __x.base() == _Iterator(),
 				_M_message(__msg_init_const_singular)
 				._M_iterator(*this, "this")
 				._M_iterator(__x, "other"));
 	}
 
       /**
        * @brief Copy assignment.
        */
       _Safe_iterator&
-      operator=(const _Safe_iterator& __x)

+      operator=(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT

       {
 	// _GLIBCXX_RESOLVE_LIB_DEFECTS
 	// DR 408. Is vector<reverse_iterator<char*> > forbidden?
 	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 			      || __x._M_current == _Iterator(),
 			      _M_message(__msg_copy_singular)
 			      ._M_iterator(*this, "this")
 			      ._M_iterator(__x, "other"));
 	_M_current = __x._M_current;
 	this->_M_attach(__x._M_sequence);
 	return *this;
       }
 
 #if __cplusplus >= 201103L
       /**
        * @brief Move assignment.
        * @post __x is singular and unattached
        */
       _Safe_iterator&
-      operator=(_Safe_iterator&& __x)

+      operator=(_Safe_iterator&& __x) noexcept

       {
 	_GLIBCXX_DEBUG_VERIFY(this != &__x,
 			      _M_message(__msg_self_move_assign)
 			      ._M_iterator(*this, "this"));
 	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 			      || __x._M_current == _Iterator(),
 			      _M_message(__msg_copy_singular)
 			      ._M_iterator(*this, "this")
 			      ._M_iterator(__x, "other"));
 	_M_current = __x._M_current;
@@ -250,162 +251,162 @@  namespace __gnu_debug

 	__x._M_current = _Iterator();
 	return *this;
       }
 #endif
 
       /**
        *  @brief Iterator dereference.
        *  @pre iterator is dereferenceable
        */
       reference
-      operator*() const

+      operator*() const _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
 			      _M_message(__msg_bad_deref)
 			      ._M_iterator(*this, "this"));
 	return *_M_current;
       }
 
       /**
        *  @brief Iterator dereference.
        *  @pre iterator is dereferenceable
        *  @todo Make this correct w.r.t. iterators that return proxies
        */
       pointer
-      operator->() const

+      operator->() const _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
 			      _M_message(__msg_bad_deref)
 			      ._M_iterator(*this, "this"));
 	return std::__addressof(*_M_current);
       }
 
       // ------ Input iterator requirements ------
       /**
        *  @brief Iterator preincrement
        *  @pre iterator is incrementable
        */
       _Safe_iterator&
-      operator++()

+      operator++() _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
 			      _M_message(__msg_bad_inc)
 			      ._M_iterator(*this, "this"));
 	++_M_current;
 	return *this;
       }
 
       /**
        *  @brief Iterator postincrement
        *  @pre iterator is incrementable
        */
       _Safe_iterator
-      operator++(int)

+      operator++(int) _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
 			      _M_message(__msg_bad_inc)
 			      ._M_iterator(*this, "this"));
 	_Safe_iterator __tmp(*this);
 	++_M_current;
 	return __tmp;
       }
 
       // ------ Bidirectional iterator requirements ------
       /**
        *  @brief Iterator predecrement
        *  @pre iterator is decrementable
        */
       _Safe_iterator&
-      operator--()

+      operator--() _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
 			      _M_message(__msg_bad_dec)
 			      ._M_iterator(*this, "this"));
 	--_M_current;
 	return *this;
       }
 
       /**
        *  @brief Iterator postdecrement
        *  @pre iterator is decrementable
        */
       _Safe_iterator
-      operator--(int)

+      operator--(int) _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
 			      _M_message(__msg_bad_dec)
 			      ._M_iterator(*this, "this"));
 	_Safe_iterator __tmp(*this);
 	--_M_current;
 	return __tmp;
       }
 
       // ------ Random access iterator requirements ------
       reference
-      operator[](const difference_type& __n) const

+      operator[](const difference_type& __n) const _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
 			      && this->_M_can_advance(__n+1),
 			      _M_message(__msg_iter_subscript_oob)
 			      ._M_iterator(*this)._M_integer(__n));
 
 	return _M_current[__n];
       }
 
       _Safe_iterator&
-      operator+=(const difference_type& __n)

+      operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n),
 			      _M_message(__msg_advance_oob)
 			      ._M_iterator(*this)._M_integer(__n));
 	_M_current += __n;
 	return *this;
       }
 
       _Safe_iterator
-      operator+(const difference_type& __n) const

+      operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT

       {
 	_Safe_iterator __tmp(*this);
 	__tmp += __n;
 	return __tmp;
       }
 
       _Safe_iterator&
-      operator-=(const difference_type& __n)

+      operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT

       {
 	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n),
 			      _M_message(__msg_retreat_oob)
 			      ._M_iterator(*this)._M_integer(__n));
 	_M_current += -__n;
 	return *this;
       }
 
       _Safe_iterator
-      operator-(const difference_type& __n) const

+      operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT

       {
 	_Safe_iterator __tmp(*this);
 	__tmp -= __n;
 	return __tmp;
       }
 
       // ------ Utilities ------
       /**
        * @brief Return the underlying iterator
        */
       _Iterator
-      base() const { return _M_current; }

+      base() const _GLIBCXX_NOEXCEPT { return _M_current; }

 
       /**
        * @brief Conversion to underlying non-debug iterator to allow
        * better interaction with non-debug containers.
        */
-      operator _Iterator() const { return _M_current; }

+      operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }

 
       /** Attach iterator to the given sequence. */
       void
       _M_attach(_Safe_sequence_base* __seq)
       {
 	_Safe_iterator_base::_M_attach(__seq, _M_constant());
       }
 
       /** Likewise, but not thread-safe. */
       void
@@ -475,244 +476,258 @@  namespace __gnu_debug

       {
 	return _BeforeBeginHelper<_Sequence>::_S_Is_Beginnest(base(),
 							  _M_get_sequence());
       }
     };
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_compare_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_compare_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() == __rhs.base();
     }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_compare_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_compare_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() == __rhs.base();
     }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_compare_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_compare_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() != __rhs.base();
     }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_compare_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_compare_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() != __rhs.base();
     }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 	      const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() < __rhs.base();
     }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 	      const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() < __rhs.base();
     }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() <= __rhs.base();
     }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() <= __rhs.base();
     }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 	      const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() > __rhs.base();
     }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 	      const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() > __rhs.base();
     }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 	       const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() >= __rhs.base();
     }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_iter_order_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_order_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() >= __rhs.base();
     }
 
   // _GLIBCXX_RESOLVE_LIB_DEFECTS
   // According to the resolution of DR179 not only the various comparison
   // operators but also operator- must accept mixed iterator/const_iterator
   // parameters.
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type
     operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 	      const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     {
       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			    _M_message(__msg_distance_bad)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			    _M_message(__msg_distance_different)
 			    ._M_iterator(__lhs, "lhs")
 			    ._M_iterator(__rhs, "rhs"));
       return __lhs.base() - __rhs.base();
     }
 
    template<typename _Iterator, typename _Sequence>
      inline typename _Safe_iterator<_Iterator, _Sequence>::difference_type
      operator-(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 	       const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

      {
        _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 			     _M_message(__msg_distance_bad)
 			     ._M_iterator(__lhs, "lhs")
 			     ._M_iterator(__rhs, "rhs"));
        _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 			     _M_message(__msg_distance_different)
 			     ._M_iterator(__lhs, "lhs")
 			     ._M_iterator(__rhs, "rhs"));
        return __lhs.base() - __rhs.base();
      }
 
   template<typename _Iterator, typename _Sequence>
     inline _Safe_iterator<_Iterator, _Sequence>
     operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n,
-	      const _Safe_iterator<_Iterator, _Sequence>& __i)

+	      const _Safe_iterator<_Iterator, _Sequence>& __i) _GLIBCXX_NOEXCEPT

     { return __i + __n; }
 } // namespace __gnu_debug
 
 #include <debug/safe_iterator.tcc>
 
 #endif
Index: include/profile/iterator_tracker.h

===================================================================
--- include/profile/iterator_tracker.h	(revision 202868)

+++ include/profile/iterator_tracker.h	(working copy)

@@ -49,226 +49,242 @@  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;
 
-      __iterator_tracker()

+      __iterator_tracker() _GLIBCXX_NOEXCEPT

       : _M_current(), _M_ds(0) { }
 
-      __iterator_tracker(const _Iterator& __i, const _Sequence* __seq) 

+      __iterator_tracker(const _Iterator& __i, const _Sequence* __seq)

+      _GLIBCXX_NOEXCEPT

       : _M_current(__i), _M_ds(__seq) { }
 
-      __iterator_tracker(const __iterator_tracker& __x) 

+      __iterator_tracker(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT

       : _M_current(__x._M_current), _M_ds(__x._M_ds) { }
 
       template<typename _MutableIterator>
         __iterator_tracker(const __iterator_tracker<_MutableIterator,
 			   typename __gnu_cxx::__enable_if
 			   <(std::__are_same<_MutableIterator, typename
 			     _Sequence::iterator::_Base_iterator>::__value),
-			   _Sequence>::__type>& __x)

+			   _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT

 	:  _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { }
 
       _Iterator
-      base() const { return _M_current; }

+      base() const _GLIBCXX_NOEXCEPT { return _M_current; }

   
       /**
        * @brief Conversion to underlying non-debug iterator to allow
        * better interaction with non-profile containers.
        */
-      operator _Iterator() const { return _M_current; }

+      operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }

 
       pointer
-      operator->() const { return &*_M_current; }

+      operator->() const _GLIBCXX_NOEXCEPT { return &*_M_current; }

 
       __iterator_tracker&
-      operator++()

+      operator++() _GLIBCXX_NOEXCEPT

       {
 	_M_ds->_M_profile_iterate();
 	++_M_current;
 	return *this;
       }
 
       __iterator_tracker
-      operator++(int)

+      operator++(int) _GLIBCXX_NOEXCEPT

       {
 	_M_ds->_M_profile_iterate();
 	__iterator_tracker __tmp(*this);
 	++_M_current;
 	return __tmp;
       }
 
       __iterator_tracker&
-      operator--()

+      operator--() _GLIBCXX_NOEXCEPT

       {
 	_M_ds->_M_profile_iterate(1);
 	--_M_current;
 	return *this;
       }
 
       __iterator_tracker
-      operator--(int)

+      operator--(int) _GLIBCXX_NOEXCEPT

       {
 	_M_ds->_M_profile_iterate(1);
 	__iterator_tracker __tmp(*this);
 	--_M_current;
 	return __tmp;
       }
 
       __iterator_tracker&
-      operator=(const __iterator_tracker& __x)

+      operator=(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT

       {
 	_M_current = __x._M_current;
 	return *this;
       }
 
       reference
-      operator*() const

+      operator*() const _GLIBCXX_NOEXCEPT

       { return *_M_current; }
 
       // ------ Random access iterator requirements ------
       reference
-      operator[](const difference_type& __n) const 

+      operator[](const difference_type& __n) const  _GLIBCXX_NOEXCEPT

       { return _M_current[__n]; }
 
       __iterator_tracker&
-      operator+=(const difference_type& __n)

+      operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT

       {
 	_M_current += __n;
 	return *this;
       }
 
       __iterator_tracker
-      operator+(const difference_type& __n) const

+      operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT

       {
 	__iterator_tracker __tmp(*this);
 	__tmp += __n;
 	return __tmp;
       }
 
       __iterator_tracker&
-      operator-=(const difference_type& __n)

+      operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT

       {
 	_M_current += -__n;
 	return *this;
       }
 
       __iterator_tracker
-      operator-(const difference_type& __n) const

+      operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT

       {
 	__iterator_tracker __tmp(*this);
 	__tmp -= __n;
 	return __tmp;
       }
 
       void
       _M_find()
       { _M_ds->_M_profile_find(); }
 
       const _Sequence*
       _M_get_sequence() const
       { return static_cast<const _Sequence*>(_M_ds); }
   };
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
 	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() == __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
 	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() == __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
 	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() != __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
                const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() != __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
 	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() < __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
 	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() < __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
 	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() <= __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
 	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() <= __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
 	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() > __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
 	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() > __rhs.base(); }
 
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline bool
     operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
 	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() >= __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline bool
     operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
 	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() >= __rhs.base(); }
 
   // _GLIBCXX_RESOLVE_LIB_DEFECTS
   // According to the resolution of DR179 not only the various comparison
   // operators but also operator- must accept mixed iterator/const_iterator
   // parameters.
   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
     inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type
     operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,
 	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() - __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type
     operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs,
 	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)
+    _GLIBCXX_NOEXCEPT

     { return __lhs.base() - __rhs.base(); }
 
   template<typename _Iterator, typename _Sequence>
     inline __iterator_tracker<_Iterator, _Sequence>
     operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type
 	      __n,
 	      const __iterator_tracker<_Iterator, _Sequence>& __i)
+    _GLIBCXX_NOEXCEPT

     { return __i + __n; }
 	
 }  // namespace __profile
 }  // namespace std
 #endif