std::vector move assign patch

Index: include/bits/stl_vector.h
===================================================================
--- include/bits/stl_vector.h	(revision 206214)
+++ include/bits/stl_vector.h	(working copy)
@@ -1433,7 +1433,7 @@ 
       void
       _M_move_assign(vector&& __x, std::true_type) noexcept
       {
-	const vector __tmp(std::move(*this));
+	const vector __tmp(std::move(*this), get_allocator());
 	this->_M_impl._M_swap_data(__x._M_impl);
 	if (_Alloc_traits::_S_propagate_on_move_assign())
 	  std::__alloc_on_move(_M_get_Tp_allocator(),
Index: include/debug/safe_base.h
===================================================================
--- include/debug/safe_base.h	(revision 206214)
+++ include/debug/safe_base.h	(working copy)
@@ -192,6 +192,12 @@ 
     : _M_iterators(0), _M_const_iterators(0), _M_version(1)
     { }
 
+#if __cplusplus >= 201103L
+    _Safe_sequence_base(_Safe_sequence_base&& __x) noexcept
+      : _Safe_sequence_base()
+    { _M_swap(__x); }
+#endif
+
     /** Notify all iterators that reference this sequence that the
 	sequence is being destroyed. */
     ~_Safe_sequence_base()
Index: include/debug/vector
===================================================================
--- include/debug/vector	(revision 206214)
+++ include/debug/vector	(working copy)
@@ -52,6 +52,7 @@ 
       typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
 
 #if __cplusplus >= 201103L
+      typedef __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> > _Safe_base;
       typedef __gnu_cxx::__alloc_traits<_Allocator>  _Alloc_traits;
 #endif
 
@@ -111,18 +112,16 @@ 
       vector(const vector& __x)
       : _Base(__x), _M_guaranteed_capacity(__x.size()) { }
 
-      /// Construction from a release-mode vector
+      /// Construction from a normal-mode vector
       vector(const _Base& __x)
       : _Base(__x), _M_guaranteed_capacity(__x.size()) { }
 
 #if __cplusplus >= 201103L
       vector(vector&& __x) noexcept
       : _Base(std::move(__x)),
+	_Safe_base(std::move(__x)),
 	_M_guaranteed_capacity(this->size())
-      {
-	this->_M_swap(__x);
-	__x._M_guaranteed_capacity = 0;
-      }
+      { __x._M_guaranteed_capacity = 0; }
 
       vector(const vector& __x, const allocator_type& __a)
       : _Base(__x, __a), _M_guaranteed_capacity(__x.size()) { }
@@ -131,7 +130,10 @@ 
       : _Base(std::move(__x), __a),
         _M_guaranteed_capacity(this->size())
       {
-	__x._M_invalidate_all();
+	if (__x.get_allocator() == __a)
+	  this->_M_swap(__x);
+	else
+	  __x._M_invalidate_all();
 	__x._M_guaranteed_capacity = 0;
       }
 
@@ -146,7 +148,7 @@ 
       vector&
       operator=(const vector& __x)
       {
-	static_cast<_Base&>(*this) = __x;
+	_M_base() = __x;
 	this->_M_invalidate_all();
 	_M_update_guaranteed_capacity();
 	return *this;
@@ -157,8 +159,13 @@ 
       operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
       {
 	__glibcxx_check_self_move_assign(__x);
-	_Base::operator=(std::move(__x));
-	this->_M_invalidate_all();
+	bool xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
+	    || __x.get_allocator() == this->get_allocator();
+	_M_base() = std::move(__x._M_base());
+	if (xfer_memory)
+	  this->_M_swap(__x);
+	else
+	  this->_M_invalidate_all();
 	_M_update_guaranteed_capacity();
 	__x._M_invalidate_all();
 	__x._M_guaranteed_capacity = 0;
@@ -168,7 +175,7 @@ 
       vector&
       operator=(initializer_list<value_type> __l)
       {
-	static_cast<_Base&>(*this) = __l;
+	_M_base() = __l;
 	this->_M_invalidate_all();
 	_M_update_guaranteed_capacity();
 	return *this;
Index: testsuite/23_containers/vector/allocator/move.cc
===================================================================
--- testsuite/23_containers/vector/allocator/move.cc	(revision 206214)
+++ testsuite/23_containers/vector/allocator/move.cc	(working copy)
@@ -32,9 +32,11 @@ 
   typedef std::vector<T, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1 = { T() };
+  auto it = v1.begin();
   test_type v2(std::move(v1));
   VERIFY(1 == v1.get_allocator().get_personality());
   VERIFY(1 == v2.get_allocator().get_personality());
+  VERIFY( it == v2.begin() );
 }
 
 void test02()
Index: testsuite/23_containers/vector/allocator/move_assign.cc
===================================================================
--- testsuite/23_containers/vector/allocator/move_assign.cc	(revision 206214)
+++ testsuite/23_containers/vector/allocator/move_assign.cc	(working copy)
@@ -46,16 +46,35 @@ 
   typedef std::vector<T, alloc_type> test_type;
   test_type v1(alloc_type(1));
   v1.push_back(T());
+  auto it = v1.begin();
   test_type v2(alloc_type(2));
+  v2.push_back(T());
   v2 = std::move(v1);
-  v2.push_back(T());
+  VERIFY( it == v2.begin() );
   VERIFY(0 == v1.get_allocator().get_personality());
   VERIFY(1 == v2.get_allocator().get_personality());
 }
 
+void test03()
+{
+  bool test __attribute__((unused)) = true;
+  typedef propagating_allocator<T, false> alloc_type;
+  typedef std::vector<T, alloc_type> test_type;
+  test_type v1(alloc_type(1));
+  v1.push_back(T());
+  auto it = v1.begin();
+  test_type v2(alloc_type(1));
+  v2.push_back(T());
+  v2 = std::move(v1);
+  VERIFY( it == v2.begin() );
+  VERIFY(1 == v1.get_allocator().get_personality());
+  VERIFY(1 == v2.get_allocator().get_personality());
+}
+
 int main()
 {
   test01();
   test02();
+  test03();
   return 0;
 }
Index: testsuite/23_containers/vector/debug/move_assign_neg.cc
===================================================================
--- testsuite/23_containers/vector/debug/move_assign_neg.cc	(revision 0)
+++ testsuite/23_containers/vector/debug/move_assign_neg.cc	(revision 0)
@@ -0,0 +1,50 @@ 
+// Copyright (C) 2013 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.
+//
+// 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/>.
+//
+// { dg-options "-std=gnu++11" }
+// { dg-do run { xfail *-*-* } }
+
+#include <debug/vector>
+
+#include <testsuite_allocator.h>
+#include <testsuite_hooks.h>
+
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  typedef __gnu_test::uneq_allocator<int> alloc_type;
+  typedef __gnu_debug::vector<int, alloc_type> test_type;
+
+  test_type v1(alloc_type(1));
+  v1 = { 0, 1, 2, 3 };
+
+  test_type v2(alloc_type(2));
+  v2 = { 4, 5, 6, 7 };
+
+  auto it = v2.begin();
+
+  v1 = std::move(v2);
+
+  VERIFY( it == v1.begin() ); // Error, it singular
+}
+
+int main()
+{
+  test01();
+  return 0;
+}