+2013-01-16 Jonathan Wakely <jwakely.gcc@gmail.com>
+
+ PR libstdc++/55043
+ * include/std/unordered_map: Include alloc_traits.h
+ * include/std/unordered_set: Likewise.
+ * include/bits/alloc_traits.h: Define __is_copy_insertable.
+ * include/bits/unordered_map.h: Use it.
+ * include/bits/unordered_set.h: Likewise.
+ * include/debug/unordered_map.h: Likewise.
+ * include/debug/unordered_set.h: Likewise.
+ * include/profile/unordered_map.h: Likewise.
+ * include/profile/unordered_set.h: Likewise.
+ * include/bits/hashtable.h: Fix comment typos.
+ * testsuite/23_containers/unordered_map/55043.cc: New.
+ * testsuite/23_containers/unordered_multimap/55043.cc: New.
+ * testsuite/23_containers/unordered_multiset/55043.cc: New.
+ * testsuite/23_containers/unordered_set/55043.cc: New.
+
2013-01-03 Janis Johnson <janisjo@codesourcery.com>
* testsuite/lib/gdb-test.exp (gdb_batch_check): Catch error running
// Allocator traits -*- C++ -*-
-// Copyright (C) 2011-2012 Free Software Foundation, Inc.
+// Copyright (C) 2011-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
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename _Tp>
+ class allocator;
+
template<typename _Alloc, typename _Tp>
class __alloctr_rebind_helper
{
__do_alloc_on_swap(__one, __two, __pocs());
}
+ template<typename _Alloc>
+ class __is_copy_insertable_impl
+ {
+ typedef allocator_traits<_Alloc> _Traits;
+
+ template<typename _Up, typename
+ = decltype(_Traits::construct(std::declval<_Alloc&>(),
+ std::declval<_Up*>(),
+ std::declval<const _Up&>()))>
+ static true_type
+ _M_select(int);
+
+ template<typename _Up>
+ static false_type
+ _M_select(...);
+
+ public:
+ typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
+ };
+
+ template<typename _Alloc>
+ struct __is_copy_insertable
+ : __is_copy_insertable_impl<_Alloc>::type
+ { };
+
+ // std::allocator<_Tp> just requires CopyConstructible
+ template<typename _Tp>
+ struct __is_copy_insertable<allocator<_Tp>>
+ : is_copy_constructible<_Tp>
+ { };
+
+ template<typename _Container>
+ using __has_copy_insertable_val
+ = __is_copy_insertable<typename _Container::allocator_type>;
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
_Hashtable(_Hashtable&&);
- // Use delegating construtors.
+ // Use delegating constructors.
explicit
_Hashtable(size_type __n = 10,
const _H1& __hf = _H1(),
_M_element_count(__ht._M_element_count),
_M_rehash_policy(__ht._M_rehash_policy)
{
- // Update, if necessary, bucket pointing to before begin that hasn't move.
+ // Update, if necessary, bucket pointing to before begin that hasn't moved.
if (_M_begin())
_M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin();
__ht._M_rehash_policy = _RehashPolicy();
{ return !(__x == __y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Pred,
+ typename _Alloc>
+ struct
+ is_copy_constructible<_GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash,
+ _Pred, _Alloc>>
+ : __has_copy_insertable_val<_GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash,
+ _Pred, _Alloc>>
+ { };
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Pred,
+ typename _Alloc>
+ struct
+ is_copy_constructible<_GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
+ _Pred, _Alloc>>
+ : __has_copy_insertable_val<_GLIBCXX_STD_C::unordered_multimap<_Key, _Tp,
+ _Hash, _Pred,
+ _Alloc>>
+ { };
+
} // namespace std
#endif /* _UNORDERED_MAP_H */
// unordered_set implementation -*- C++ -*-
-// Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc.
+// Copyright (C) 2010-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
{ return !(__x == __y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
+
+ template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+ struct is_copy_constructible<_GLIBCXX_STD_C::unordered_set<_Key, _Hash,
+ _Pred, _Alloc>>
+ : __has_copy_insertable_val<_GLIBCXX_STD_C::unordered_set<_Key, _Hash,
+ _Pred, _Alloc>>
+ { };
+
+ template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+ struct
+ is_copy_constructible<_GLIBCXX_STD_C::unordered_multiset<_Key, _Hash,
+ _Pred, _Alloc>>
+ : __has_copy_insertable_val<_GLIBCXX_STD_C::unordered_multiset<_Key, _Hash,
+ _Pred,
+ _Alloc>>
+ { };
+
} // namespace std
#endif /* _UNORDERED_SET_H */
// Debugging unordered_map/unordered_multimap implementation -*- C++ -*-
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
-// Free Software Foundation, Inc.
+// Copyright (C) 2003-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
{ return !(__x == __y); }
} // namespace __debug
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Pred,
+ typename _Alloc>
+ struct
+ is_copy_constructible<__debug::unordered_map<_Key, _Tp, _Hash, _Pred,
+ _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_C::unordered_map<_Key, _Tp,
+ _Hash, _Pred,
+ _Alloc> >
+ { };
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Pred,
+ typename _Alloc>
+ struct
+ is_copy_constructible<__debug::unordered_multimap<_Key, _Tp, _Hash, _Pred,
+ _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp,
+ _Hash, _Pred,
+ _Alloc> >
+ { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
// Debugging unordered_set/unordered_multiset implementation -*- C++ -*-
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
-// Free Software Foundation, Inc.
+// Copyright (C) 2003-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
{ return !(__x == __y); }
} // namespace __debug
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+ struct
+ is_copy_constructible<__debug::unordered_set<_Key, _Hash, _Pred, _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_C::unordered_set<_Key,
+ _Hash, _Pred,
+ _Alloc> >
+ { };
+
+ template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+ struct
+ is_copy_constructible<__debug::unordered_multiset<_Key, _Hash, _Pred,
+ _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_C::unordered_multiset<_Key,
+ _Hash, _Pred,
+ _Alloc> >
+ { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
// Profiling unordered_map/unordered_multimap implementation -*- C++ -*-
-// Copyright (C) 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+// Copyright (C) 2009-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
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ return !(__x == __y); }
+} // namespace __profile
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename _Key, typename _Tp, typename _Hash, typename _Pred,
+ typename _Alloc>
+ struct
+ is_copy_constructible<__profile::unordered_map<_Key, _Tp, _Hash,
+ _Pred, _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_BASE >
+ { };
+_GLIBCXX_END_NAMESPACE_VERSION
+
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
#define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
+namespace __profile
+{
/// Class std::unordered_multimap wrapper with performance instrumentation.
template<typename _Key, typename _Tp,
typename _Hash = std::hash<_Key>,
{ return !(__x == __y); }
} // namespace __profile
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _Key, typename _Tp, typename _Hash, typename _Pred,
+ typename _Alloc>
+ struct
+ is_copy_constructible<__profile::unordered_multimap<_Key, _Tp, _Hash,
+ _Pred, _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_BASE >
+ { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#undef _GLIBCXX_BASE
// Profiling unordered_set/unordered_multiset implementation -*- C++ -*-
-// Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright (C) 2009-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
const unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
{ return !(__x == __y); }
+} // namespace __profile
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
+ struct
+ is_copy_constructible<__profile::unordered_set<_Key, _Hash, _Pred, _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_BASE >
+ { };
+_GLIBCXX_END_NAMESPACE_VERSION
+
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
#define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc>
+namespace __profile
+{
/** @brief Unordered_multiset wrapper with performance instrumentation. */
template<typename _Value,
typename _Hash = std::hash<_Value>,
{ return !(__x == __y); }
} // namespace __profile
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
+ struct
+ is_copy_constructible<__profile::unordered_multiset<_Value, _Hash,
+ _Pred, _Alloc>>
+ : is_copy_constructible< _GLIBCXX_STD_BASE >
+ { };
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#undef _GLIBCXX_BASE
// <unordered_map> -*- C++ -*-
-// Copyright (C) 2007, 2008, 2009, 2010, 2012 Free Software Foundation, Inc.
+// Copyright (C) 2007-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
#include <tuple>
#include <bits/stl_algobase.h>
#include <bits/allocator.h>
+#include <bits/alloc_traits.h>
#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
#include <bits/functional_hash.h>
#include <bits/hashtable.h>
// <unordered_set> -*- C++ -*-
-// Copyright (C) 2007, 2008, 2009, 2010, 2012 Free Software Foundation, Inc.
+// Copyright (C) 2007-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
#include <tuple>
#include <bits/stl_algobase.h>
#include <bits/allocator.h>
+#include <bits/alloc_traits.h>
#include <bits/stl_function.h> // equal_to, _Identity, _Select1st
#include <bits/functional_hash.h>
#include <bits/hashtable.h>
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// libstdc++/55043
+
+#include <unordered_map>
+#include <vector>
+
+struct MoveOnly
+{
+ MoveOnly() = default;
+ MoveOnly(MoveOnly&&) = default;
+};
+
+using hash = std::hash<int>;
+using equal = std::equal_to<int>;
+
+template<typename Alloc>
+ using test_type = std::unordered_map<int, MoveOnly, hash, equal, Alloc>;
+
+void test01()
+{
+ typedef test_type<std::allocator<MoveOnly>> uim;
+ std::vector<uim> v;
+ v.emplace_back(uim());
+}
+
+// Unordered containers don't use allocator_traits yet so need full
+// Allocator interface, derive from std::allocator to get it.
+template<typename T, bool R>
+struct Alloc : std::allocator<T>
+{
+ template<typename U>
+ struct rebind { typedef Alloc<U, R> other; };
+
+ Alloc() = default;
+
+ template<typename U>
+ Alloc(const Alloc<U, R>&) { }
+
+ typedef typename std::conditional<R, T&&, const T&>::type arg_type;
+
+ void construct(T* p, arg_type) const
+ { new((void*)p) T(); }
+};
+
+// verify is_copy_constructible depends on allocator
+typedef test_type<Alloc<MoveOnly, true>> uim_rval;
+static_assert(std::is_copy_constructible<uim_rval>::value, "is not copyable");
+
+typedef test_type<Alloc<MoveOnly, false>> uim_lval;
+static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// libstdc++/55043
+
+#include <unordered_map>
+#include <vector>
+
+struct MoveOnly
+{
+ MoveOnly() = default;
+ MoveOnly(MoveOnly&&) = default;
+};
+
+using hash = std::hash<int>;
+using equal = std::equal_to<int>;
+
+template<typename Alloc>
+ using test_type = std::unordered_multimap<int, MoveOnly, hash, equal, Alloc>;
+
+void test01()
+{
+ typedef test_type<std::allocator<MoveOnly>> uim;
+ std::vector<uim> v;
+ v.emplace_back(uim());
+}
+
+// Unordered containers don't use allocator_traits yet so need full
+// Allocator interface, derive from std::allocator to get it.
+template<typename T, bool R>
+struct Alloc : std::allocator<T>
+{
+ template<typename U>
+ struct rebind { typedef Alloc<U, R> other; };
+
+ Alloc() = default;
+
+ template<typename U>
+ Alloc(const Alloc<U, R>&) { }
+
+ typedef typename std::conditional<R, T&&, const T&>::type arg_type;
+
+ void construct(T* p, arg_type) const
+ { new((void*)p) T(); }
+};
+
+// verify is_copy_constructible depends on allocator
+typedef test_type<Alloc<MoveOnly, true>> uim_rval;
+static_assert(std::is_copy_constructible<uim_rval>::value, "is not copyable");
+
+typedef test_type<Alloc<MoveOnly, false>> uim_lval;
+static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// libstdc++/55043
+
+#include <unordered_set>
+#include <vector>
+
+struct MoveOnly
+{
+ MoveOnly() = default;
+ MoveOnly(MoveOnly&&) = default;
+};
+
+struct equal {
+ bool operator()(const MoveOnly&, const MoveOnly) const { return true; }
+};
+struct hash {
+ size_t operator()(const MoveOnly&) const { return 0; }
+};
+
+template<typename Alloc>
+ using test_type = std::unordered_multiset<MoveOnly, hash, equal, Alloc>;
+
+void test01()
+{
+ typedef test_type<std::allocator<MoveOnly>> uim;
+ std::vector<uim> v;
+ v.emplace_back(uim());
+}
+
+// Unordered containers don't use allocator_traits yet so need full
+// Allocator interface, derive from std::allocator to get it.
+template<typename T, bool R>
+struct Alloc : std::allocator<T>
+{
+ template<typename U>
+ struct rebind { typedef Alloc<U, R> other; };
+
+ Alloc() = default;
+
+ template<typename U>
+ Alloc(const Alloc<U, R>&) { }
+
+ typedef typename std::conditional<R, T&&, const T&>::type arg_type;
+
+ void construct(T* p, arg_type) const
+ { new((void*)p) T(); }
+};
+
+// verify is_copy_constructible depends on allocator
+typedef test_type<Alloc<MoveOnly, true>> uim_rval;
+static_assert(std::is_copy_constructible<uim_rval>::value, "is not copyable");
+
+typedef test_type<Alloc<MoveOnly, false>> uim_lval;
+static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// libstdc++/55043
+
+#include <unordered_set>
+#include <vector>
+
+struct MoveOnly
+{
+ MoveOnly() = default;
+ MoveOnly(MoveOnly&&) = default;
+};
+
+struct equal {
+ bool operator()(const MoveOnly&, const MoveOnly) const { return true; }
+};
+struct hash {
+ size_t operator()(const MoveOnly&) const { return 0; }
+};
+
+template<typename Alloc>
+ using test_type = std::unordered_set<MoveOnly, hash, equal, Alloc>;
+
+void test01()
+{
+ typedef test_type<std::allocator<MoveOnly>> uim;
+ std::vector<uim> v;
+ v.emplace_back(uim());
+}
+
+// Unordered containers don't use allocator_traits yet so need full
+// Allocator interface, derive from std::allocator to get it.
+template<typename T, bool R>
+struct Alloc : std::allocator<T>
+{
+ template<typename U>
+ struct rebind { typedef Alloc<U, R> other; };
+
+ Alloc() = default;
+
+ template<typename U>
+ Alloc(const Alloc<U, R>&) { }
+
+ typedef typename std::conditional<R, T&&, const T&>::type arg_type;
+
+ void construct(T* p, arg_type) const
+ { new((void*)p) T(); }
+};
+
+// verify is_copy_constructible depends on allocator
+typedef test_type<Alloc<MoveOnly, true>> uim_rval;
+static_assert(std::is_copy_constructible<uim_rval>::value, "is not copyable");
+
+typedef test_type<Alloc<MoveOnly, false>> uim_lval;
+static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");
projects / platform / upstream / linaro-gcc.git / commitdiff