+2016-04-13 Jonathan Wakely <jwakely@redhat.com>
+
+ * include/bits/c++config (_GLIBCXX_BEGIN_NAMESPACE_EMPTY_TYPES,
+ _GLIBCXX_END_NAMESPACE_EMPTY_TYPES, _GLIBCXX_ABI_TAG_EMPTY): Define.
+ * include/bits/hashtable.h (_Hashtable::_M_emplace): Change signatures
+ of functions taking empty structs by value. Add a template parameter
+ to overloads without hints. Rename overloads with hints to
+ _M_emplace_hint.
+ (_Hashtable::_M_erase(true_type, const_iterator),
+ _Hashtable::_M_erase(false_type, const_iterator)): Change signatures
+ by reordering parameters.
+ * include/bits/hashtable_policy.h (_Insert::insert): Adjust to call
+ _M_emplace_hint instead of _M_emplace.
+ * include/bits/shared_ptr.h (shared_ptr(_Tp1*, _Deleter, _Alloc),
+ shared_ptr(nullptr_t, _Deleter, _Alloc)): Use _GLIBCXX_ABI_TAG_EMPTY.
+ * include/bits/shared_ptr_base.h (_Sp_counted_deleter, __shared_count,
+ __shared_ptr): Likewise.
+ * include/bits/stl_algo.h (replace_if): Likewise.
+ * include/bits/stl_pair.h (piecewise_construct_t,
+ piecewise_construct): Use _GLIBCXX_BEGIN_NAMESPACE_EMPTY_TYPES.
+ * include/bits/uses_allocator.h (allocator_arg_t, allocator_arg,
+ __uses_alloc0): Likewise.
+ * include/ext/pb_ds/assoc_container.hpp (basic_hash_table): Likewise.
+ * testsuite/20_util/scoped_allocator/69293_neg.cc: Adjust dg-error.
+ * testsuite/20_util/shared_ptr/cons/43820_neg.cc: Likewise.
+ * testsuite/20_util/shared_ptr/cons/void_neg.cc: Likewise.
+ * testsuite/20_util/uses_allocator/69293_neg.cc: Likewise.
+ * testsuite/20_util/uses_allocator/cons_neg.cc: Likewise.
+ * testsuite/ext/profile/mutex_extensions_neg.cc: Likewise.
+
2016-04-12 Edward Smith-Rowland <3dw4rd@verizon.net>
Document C++17/TR29124 C++ Special Math Functions.
# define _GLIBCXX_DEPRECATED
#endif
+#if __cplusplus
+
// Macros for ABI tag attributes.
#ifndef _GLIBCXX_ABI_TAG_CXX11
# define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
#endif
-
-#if __cplusplus
+#if __GXX_ABI_VERSION >= 1010
+namespace std
+{
+ inline namespace _V2 { }
+}
+# define _GLIBCXX_BEGIN_NAMESPACE_EMPTY_TYPES \
+ _GLIBCXX_END_NAMESPACE_VERSION \
+ namespace _V2 { \
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_END_NAMESPACE_EMPTY_TYPES \
+ _GLIBCXX_END_NAMESPACE_VERSION \
+ } \
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_ABI_TAG_EMPTY __attribute ((__abi_tag__ ("cxxempty")))
+#else
+# define _GLIBCXX_BEGIN_NAMESPACE_EMPTY_TYPES
+# define _GLIBCXX_END_NAMESPACE_EMPTY_TYPES
+# define _GLIBCXX_ABI_TAG_EMPTY
+#endif
// Macro for constexpr, to support in mixed 03/0x mode.
#ifndef _GLIBCXX_CONSTEXPR
_M_insert_multi_node(__node_type* __hint,
__hash_code __code, __node_type* __n);
- template<typename... _Args>
- std::pair<iterator, bool>
- _M_emplace(std::true_type, _Args&&... __args);
+ template<bool _Uniq, typename... _Args>
+ typename enable_if<_Uniq, std::pair<iterator, bool>>::type
+ _M_emplace(__bool_constant<_Uniq>, _Args&&... __args);
- template<typename... _Args>
- iterator
- _M_emplace(std::false_type __uk, _Args&&... __args)
- { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); }
+ template<bool _Uniq, typename... _Args>
+ typename enable_if<!_Uniq, iterator>::type
+ _M_emplace(__bool_constant<_Uniq> __uk, _Args&&... __args)
+ {
+ return _M_emplace_hint(cend(), __uk, std::forward<_Args>(__args)...);
+ }
// Emplace with hint, useless when keys are unique.
template<typename... _Args>
iterator
- _M_emplace(const_iterator, std::true_type __uk, _Args&&... __args)
+ _M_emplace_hint(const_iterator, std::true_type __uk, _Args&&... __args)
{ return _M_emplace(__uk, std::forward<_Args>(__args)...).first; }
template<typename... _Args>
iterator
- _M_emplace(const_iterator, std::false_type, _Args&&... __args);
+ _M_emplace_hint(const_iterator, std::false_type, _Args&&... __args);
template<typename _Arg, typename _NodeGenerator>
std::pair<iterator, bool>
const _NodeGenerator&, std::false_type);
size_type
- _M_erase(std::true_type, const key_type&);
+ _M_erase(const key_type&, std::true_type);
size_type
- _M_erase(std::false_type, const key_type&);
+ _M_erase(const key_type&, std::false_type);
iterator
_M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n);
iterator
emplace_hint(const_iterator __hint, _Args&&... __args)
{
- return _M_emplace(__hint, __unique_keys(),
- std::forward<_Args>(__args)...);
+ return _M_emplace_hint(__hint, __unique_keys(),
+ std::forward<_Args>(__args)...);
}
// Insert member functions via inheritance.
size_type
erase(const key_type& __k)
- { return _M_erase(__unique_keys(), __k); }
+ { return _M_erase(__k, __unique_keys()); }
iterator
erase(const_iterator, const_iterator);
typename _Alloc, typename _ExtractKey, typename _Equal,
typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
typename _Traits>
- template<typename... _Args>
+ template<bool _Uniq, typename... _Args>
auto
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
- _M_emplace(std::true_type, _Args&&... __args)
- -> pair<iterator, bool>
+ _M_emplace(__bool_constant<_Uniq>, _Args&&... __args)
+ -> typename enable_if<_Uniq, pair<iterator, bool>>::type
{
// First build the node to get access to the hash code
__node_type* __node = this->_M_allocate_node(std::forward<_Args>(__args)...);
auto
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
- _M_emplace(const_iterator __hint, std::false_type, _Args&&... __args)
+ _M_emplace_hint(const_iterator __hint, std::false_type, _Args&&... __args)
-> iterator
{
// First build the node to get its hash code.
auto
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
- _M_erase(std::true_type, const key_type& __k)
+ _M_erase(const key_type& __k, std::true_type)
-> size_type
{
__hash_code __code = this->_M_hash_code(__k);
auto
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
- _M_erase(std::false_type, const key_type& __k)
+ _M_erase(const key_type& __k, std::false_type)
-> size_type
{
__hash_code __code = this->_M_hash_code(__k);
insert(const_iterator __hint, _Pair&& __v)
{
__hashtable& __h = this->_M_conjure_hashtable();
- return __h._M_emplace(__hint, __unique_keys(),
- std::forward<_Pair>(__v));
+ return __h._M_emplace_hint(__hint, __unique_keys(),
+ std::forward<_Pair>(__v));
}
};
* __shared_ptr will release __p by calling __d(__p)
*/
template<typename _Tp1, typename _Deleter, typename _Alloc>
+ _GLIBCXX_ABI_TAG_EMPTY
shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
* The last owner will call __d(__p)
*/
template<typename _Deleter, typename _Alloc>
+ _GLIBCXX_ABI_TAG_EMPTY
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
public:
+ _GLIBCXX_ABI_TAG_EMPTY
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(__d), _Alloc_base(__a)
{ }
: _M_impl(__p, __d, _Alloc()) { }
// __d(__p) must not throw.
+ _GLIBCXX_ABI_TAG_EMPTY
_Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_impl(__p, __d, __a) { }
{ }
template<typename _Ptr, typename _Deleter, typename _Alloc>
+ _GLIBCXX_ABI_TAG_EMPTY
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
}
template<typename _Tp1, typename _Deleter, typename _Alloc>
+ _GLIBCXX_ABI_TAG_EMPTY
__shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
{
{ }
template<typename _Deleter, typename _Alloc>
+ _GLIBCXX_ABI_TAG_EMPTY
__shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
{ }
{ __shared_ptr(__p, __d).swap(*this); }
template<typename _Tp1, typename _Deleter, typename _Alloc>
+ _GLIBCXX_ABI_TAG_EMPTY
void
reset(_Tp1* __p, _Deleter __d, _Alloc __a)
{ __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
* is true then the assignment @c *i = @p __new_value is performed.
*/
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+ _GLIBCXX_ABI_TAG_EMPTY
void
replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
*/
#if __cplusplus >= 201103L
+
+_GLIBCXX_BEGIN_NAMESPACE_EMPTY_TYPES
+
/// piecewise_construct_t
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
/// piecewise_construct
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
+_GLIBCXX_END_NAMESPACE_EMPTY_TYPES
+
// Forward declarations.
template<typename...>
class tuple;
using __is_erased_or_convertible
= __or_<is_same<_Tp, __erased_type>, is_convertible<_Alloc, _Tp>>;
+_GLIBCXX_BEGIN_NAMESPACE_EMPTY_TYPES
+
/// [allocator.tag]
struct allocator_arg_t { explicit allocator_arg_t() = default; };
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+_GLIBCXX_END_NAMESPACE_EMPTY_TYPES
+
template<typename _Tp, typename _Alloc, typename = __void_t<>>
struct __uses_allocator_helper
: false_type { };
struct __uses_alloc_base { };
+_GLIBCXX_BEGIN_NAMESPACE_EMPTY_TYPES
+
struct __uses_alloc0 : __uses_alloc_base
{
struct _Sink { void operator=(const void*) { } } _M_a;
};
+_GLIBCXX_END_NAMESPACE_EMPTY_TYPES
+
template<typename _Alloc>
struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
basic_hash_table(T0 t0) : base_type(t0) { }
template<typename T0, typename T1>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1) : base_type(t0, t1) { }
template<typename T0, typename T1, typename T2>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1, T2 t2) : base_type(t0, t1, t2) { }
template<typename T0, typename T1, typename T2, typename T3>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3)
: base_type(t0, t1, t2, t3) { }
template<typename T0, typename T1, typename T2, typename T3, typename T4>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4)
: base_type(t0, t1, t2, t3, t4) { }
template<typename T0, typename T1, typename T2, typename T3, typename T4,
typename T5>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
: base_type(t0, t1, t2, t3, t4, t5) { }
template<typename T0, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
: base_type(t0, t1, t2, t3, t4, t5, t6) { }
template<typename T0, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
: base_type(t0, t1, t2, t3, t4, t5, t6, t7) { }
template<typename T0, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
+ _GLIBCXX_ABI_TAG_EMPTY
basic_hash_table(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6,
T7 t7, T8 t8)
: base_type(t0, t1, t2, t3, t4, t5, t6, t7, t8)
scoped_alloc sa;
auto p = sa.allocate(1);
sa.construct(p); // this is required to be ill-formed
- // { dg-error "static assertion failed" "" { target *-*-* } 89 }
+ // { dg-error "static assertion failed" "" { target *-*-* } 97 }
}
{
X* px = 0;
std::shared_ptr<X> p1(px); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 889 }
+ // { dg-error "incomplete" "" { target *-*-* } 892 }
std::shared_ptr<X> p9(ap()); // { dg-error "here" }
// { dg-error "incomplete" "" { target *-*-* } 307 }
void test01()
{
std::shared_ptr<void> p((void*)nullptr); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 888 }
+ // { dg-error "incomplete" "" { target *-*-* } 891 }
}
{
alloc_type a;
std::tuple<X> t(std::allocator_arg, a); // this is required to be ill-formed
- // { dg-error "static assertion failed" "" { target *-*-* } 89 }
+ // { dg-error "static assertion failed" "" { target *-*-* } 97 }
}
tuple<Type> t(allocator_arg, a, 1);
}
-// { dg-error "static assertion failed" "" { target *-*-* } 89 }
+// { dg-error "static assertion failed" "" { target *-*-* } 97 }
#include <vector>
-// { dg-error "multiple inlined namespaces" "" { target *-*-* } 324 }
+// { dg-error "multiple inlined namespaces" "" { target *-*-* } 343 }
// "template argument 1 is invalid"
// { dg-prune-output "tuple:993" }
projects / gcc.git / commitdiff