+2014-01-08 François Dumont <fdumont@gcc.gnu.org>
+
+ * include/bits/stl_vector.h (std::vector<>::_M_move_assign): Pass
+ *this allocator instance when building temporary vector instance
+ so that *this allocator does not get moved.
+ * include/debug/safe_base.h
+ (_Safe_sequence_base(_Safe_sequence_base&&)): New.
+ * include/debug/vector (__gnu_debug::vector<>(vector&&)): Use new
+ move constructor from _Safe_sequence_base.
+ (__gnu_debug::vector<>(vector&&, const allocator_type&)): Swap
+ safe iterators if the instance is moved.
+ (__gnu_debug::vector<>::operator=(vector&&)): Likewise.
+ * testsuite/23_containers/vector/allocator/move.cc (test01): Add
+ check on a vector iterator.
+ * testsuite/23_containers/vector/allocator/move_assign.cc
+ (test02): Likewise.
+ (test03): New, test with a non-propagating allocator.
+ * testsuite/23_containers/vector/debug/move_assign_neg.cc: New.
+
2014-01-07 Tim Shen <timshen91@gmail.com>
* include/bits/regex_compiler.h (_AnyMatcher<>::_AnyMatcher(),
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(),
: _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()
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
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()) { }
: _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;
}
vector&
operator=(const vector& __x)
{
- static_cast<_Base&>(*this) = __x;
+ _M_base() = __x;
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
return *this;
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;
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;
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()
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 = std::move(v1);
v2.push_back(T());
+ v2 = std::move(v1);
+ 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;
}
--- /dev/null
+// 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 is singular
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
projects / thirdparty / gcc.git / commitdiff
