+2010-11-24 Benjamin Kosnik <bkoz@redhat.com>
+
+ * include/std/tuple: Mark more constructors constexpr.
+ * include/bits/stl_pair.h: Same.
+ * testsuite/20_util/tuple/requirements/dr801.cc: New.
+ * testsuite/20_util/pair/requirements/dr801.cc: New.
+ * testsuite/20_util/tuple/cons/constexpr.cc: Add cases for new
+ constexpr constructors.
+ * testsuite/20_util/pair/cons/constexpr.cc: Same.
+ * testsuite/20_util/pair/comparison_operators/constexpr.cc: New.
+
+ * testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Adjust line number.
+
2010-11-24 Paolo Carlini <paolo.carlini@oracle.com>
* testsuite/30_threads/future/cons/constexpr.cc: Add dg-require*
: first(), second() { }
/** Two objects may be passed to a @c pair constructor to be copied. */
- pair(const _T1& __a, const _T2& __b)
+ _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
+ /** There is also a templated copy ctor for the @c pair class itself. */
+ template<class _U1, class _U2>
+ _GLIBCXX_CONSTEXPR pair(const pair<_U1, _U2>& __p)
+ : first(__p.first), second(__p.second) { }
+
#ifdef __GXX_EXPERIMENTAL_CXX0X__
- pair(const pair&) = default;
+ constexpr pair(const pair&) = default;
+
+ // Implicit.
+ // pair(pair&&) = default;
// DR 811.
template<class _U1, class = typename
std::enable_if<std::is_convertible<_U1, _T1>::value>::type>
- pair(_U1&& __x, const _T2& __y)
- : first(std::forward<_U1>(__x)),
- second(__y) { }
+ pair(_U1&& __x, const _T2& __y)
+ : first(std::forward<_U1>(__x)), second(__y) { }
template<class _U2, class = typename
std::enable_if<std::is_convertible<_U2, _T2>::value>::type>
- pair(const _T1& __x, _U2&& __y)
- : first(__x),
- second(std::forward<_U2>(__y)) { }
+ pair(const _T1& __x, _U2&& __y)
+ : first(__x), second(std::forward<_U2>(__y)) { }
template<class _U1, class _U2, class = typename
std::enable_if<std::is_convertible<_U1, _T1>::value
&& std::is_convertible<_U2, _T2>::value>::type>
- pair(_U1&& __x, _U2&& __y)
- : first(std::forward<_U1>(__x)),
- second(std::forward<_U2>(__y)) { }
+ pair(_U1&& __x, _U2&& __y)
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
- template<class... _Args1, class... _Args2>
- pair(piecewise_construct_t,
- tuple<_Args1...> __first_args,
- tuple<_Args2...> __second_args)
- : first(__cons<first_type>(std::move(__first_args))),
- second(__cons<second_type>(std::move(__second_args))) { }
-#endif
-
- /** There is also a templated copy ctor for the @c pair class itself. */
template<class _U1, class _U2>
- pair(const pair<_U1, _U2>& __p)
- : first(__p.first),
- second(__p.second) { }
-
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
- template<class _U1, class _U2>
- pair(pair<_U1, _U2>&& __p)
+ pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second)) { }
+ template<class... _Args1, class... _Args2>
+ pair(piecewise_construct_t,
+ tuple<_Args1...> __first, tuple<_Args2...> __second)
+ : first(__cons<first_type>(std::move(__first))),
+ second(__cons<second_type>(std::move(__second))) { }
+
+ pair&
+ operator=(const pair& __p)
+ {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+ }
+
pair&
operator=(pair&& __p)
- {
+ {
first = std::move(__p.first);
second = std::move(__p.second);
return *this;
}
template<class _U1, class _U2>
- pair&
- operator=(const pair<_U1, _U2>& __p)
+ pair&
+ operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
}
template<class _U1, class _U2>
- pair&
- operator=(pair<_U1, _U2>&& __p)
+ pair&
+ operator=(pair<_U1, _U2>&& __p)
{
first = std::move(__p.first);
second = std::move(__p.second);
{
using std::swap;
swap(first, __p.first);
- swap(second, __p.second);
+ swap(second, __p.second);
}
private:
template<typename _Tp, typename... _Args>
- static _Tp
- __cons(tuple<_Args...>&&);
+ static _Tp
+ __cons(tuple<_Args...>&&);
template<typename _Tp, typename... _Args, int... _Indexes>
- static _Tp
- __do_cons(tuple<_Args...>&&, const _Index_tuple<_Indexes...>&);
+ static _Tp
+ __do_cons(tuple<_Args...>&&, const _Index_tuple<_Indexes...>&);
#endif
};
/// Two pairs of the same type are equal iff their members are equal.
template<class _T1, class _T2>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
/// <http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html>
template<class _T1, class _T2>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __x.first < __y.first
|| (!(__y.first < __x.first) && __x.second < __y.second); }
/// Uses @c operator== to find the result.
template<class _T1, class _T2>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
/// Uses @c operator< to find the result.
template<class _T1, class _T2>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
*/
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 181. make_pair() unintended behavior
-#ifndef __GXX_EXPERIMENTAL_CXX0X__
- template<class _T1, class _T2>
- inline pair<_T1, _T2>
- make_pair(_T1 __x, _T2 __y)
- { return pair<_T1, _T2>(__x, __y); }
-#else
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
// NB: DR 706.
template<class _T1, class _T2>
inline pair<typename __decay_and_strip<_T1>::__type,
typename __decay_and_strip<_T2>::__type>
make_pair(_T1&& __x, _T2&& __y)
{
- return pair<typename __decay_and_strip<_T1>::__type,
- typename __decay_and_strip<_T2>::__type>
- (std::forward<_T1>(__x), std::forward<_T2>(__y));
+ typedef typename __decay_and_strip<_T1>::__type __ds_type1;
+ typedef typename __decay_and_strip<_T2>::__type __ds_type2;
+ typedef pair<__ds_type1, __ds_type2> __pair_type;
+ return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
}
+#else
+ template<class _T1, class _T2>
+ inline pair<_T1, _T2>
+ make_pair(_T1 __x, _T2 __y)
+ { return pair<_T1, _T2>(__x, __y); }
#endif
_GLIBCXX_END_NAMESPACE
constexpr _Head_base()
: _Head() { }
- _Head_base(const _Head& __h)
+ constexpr _Head_base(const _Head& __h)
: _Head(__h) { }
template<typename _UHead>
_Head& _M_head() { return *this; }
const _Head& _M_head() const { return *this; }
- void _M_swap_impl(_Head&) { /* no-op */ }
+ void
+ _M_swap_impl(_Head&) { /* no-op */ }
};
template<std::size_t _Idx, typename _Head>
constexpr _Head_base()
: _M_head_impl() { }
- _Head_base(const _Head& __h)
+ constexpr _Head_base(const _Head& __h)
: _M_head_impl(__h) { }
template<typename _UHead>
: _Inherited(), _Base() { }
explicit
- _Tuple_impl(const _Head& __head, const _Tail&... __tail)
+ constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
: _Inherited(__tail...), _Base(__head) { }
template<typename _UHead, typename... _UTail>
: _Inherited(std::forward<_UTail>(__tail)...),
_Base(std::forward<_UHead>(__head)) { }
- _Tuple_impl(const _Tuple_impl&) = default;
+ constexpr _Tuple_impl(const _Tuple_impl&) = default;
_Tuple_impl(_Tuple_impl&& __in)
- : _Inherited(std::move(__in._M_tail())),
+ : _Inherited(std::move(__in._M_tail())),
_Base(std::forward<_Head>(__in._M_head())) { }
template<typename... _UElements>
: _Inherited() { }
explicit
- tuple(const _Elements&... __elements)
+ constexpr tuple(const _Elements&... __elements)
: _Inherited(__elements...) { }
template<typename... _UElements, typename = typename
tuple(_UElements&&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) { }
- tuple(const tuple&) = default;
+ constexpr tuple(const tuple&) = default;
tuple(tuple&& __in)
: _Inherited(static_cast<_Inherited&&>(__in)) { }
: _Inherited() { }
explicit
- tuple(const _T1& __a1, const _T2& __a2)
+ constexpr tuple(const _T1& __a1, const _T2& __a2)
: _Inherited(__a1, __a2) { }
template<typename _U1, typename _U2>
tuple(_U1&& __a1, _U2&& __a2)
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
- tuple(const tuple&) = default;
+ constexpr tuple(const tuple&) = default;
tuple(tuple&& __in)
: _Inherited(static_cast<_Inherited&&>(__in)) { }
: _Inherited() { }
explicit
- tuple(const _T1& __a1)
+ constexpr tuple(const _T1& __a1)
: _Inherited(__a1) { }
template<typename _U1, typename = typename
tuple(_U1&& __a1)
: _Inherited(std::forward<_U1>(__a1)) { }
- tuple(const tuple&) = default;
+ constexpr tuple(const tuple&) = default;
tuple(tuple&& __in)
: _Inherited(static_cast<_Inherited&&>(__in)) { }
template<typename _U1>
tuple(const tuple<_U1>& __in)
- : _Inherited(static_cast<const _Tuple_impl<0, _U1>&>(__in)) { }
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1>&>(__in)) { }
template<typename _U1>
tuple(tuple<_U1>&& __in)
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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/>.
+
+#include <utility>
+#include <testsuite_common_types.h>
+
+int main()
+{
+ __gnu_test::constexpr_comparison_operators test;
+ test.operator()<std::pair<int, int>>();
+ return 0;
+}
int main()
{
- __gnu_test::constexpr_default_constructible test;
- test.operator()<std::pair<int, int>>();
+ __gnu_test::constexpr_default_constructible test1;
+ test1.operator()<std::pair<int, int>>();
+
+ __gnu_test::constexpr_single_value_constructible test2;
+ test2.operator()<std::pair<int, int>, std::pair<int, int>>();
+ test2.operator()<std::pair<int, int>, std::pair<short, short>>();
+
+ // test 3
+ const int i1(129);
+ const int i2(6);
+ constexpr std::pair<int, int> p3(i1, i2);
+
return 0;
}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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/>.
+
+#include <memory>
+#include <type_traits>
+
+// DR 801, pair and tuple vs. "passed in registers"
+void test_trivial()
+{
+ // PODType, TType, NType, SLType, LType, NLType, LTypeDerived
+ typedef std::pair<int, int> pair_type;
+ // static_assert(std::is_literal_type<pair_type>::value, "! literal");
+ static_assert(std::has_trivial_copy_constructor<pair_type>::value,
+ "! triv copy");
+ static_assert(std::has_trivial_destructor<pair_type>::value,
+ "! triv destructor");
+ // static_assert(std::is_standard_layout<pair_type>::value,
+ // "! standard layout");
+
+ // Negative
+ /*
+ static_assert(std::has_trivial_default_constructor<pair_type>::value,
+ "! triv default");
+ static_assert(std::has_trivial_copy_assign<pair_type>::value,
+ "! triv assign");
+ static_assert(std::is_trivial<pair_type>::value, "! triv");
+ static_assert(std::is_pod<pair_type>::value, "! pod");
+ */
+}
+
+int main()
+{
+ test_trivial();
+ return 0;
+}
int main()
{
- __gnu_test::constexpr_default_constructible test;
- test.operator()<std::tuple<int, int>>();
+ __gnu_test::constexpr_default_constructible test1;
+ test1.operator()<std::tuple<int, int>>();
+
+ __gnu_test::constexpr_single_value_constructible test2;
+ test2.operator()<std::tuple<int, int>, std::tuple<int, int>>();
+ // test2.operator()<std::tuple<int, int>, std::pair<short, short>>();
+ // test2.operator()<std::tuple<int>, std::tuple<short>>();
+ // test2.operator()<std::tuple<int, int>, std::tuple<short, short>>();
+
+ // test 3
+ const int i1(129);
+ const int i2(6);
+ constexpr std::tuple<int, int> p3(i1, i2);
+
+ // test 4
+ const int i3(415);
+ const int i4(550);
+ const int i5(6414);
+ constexpr std::tuple<int, int, int, int, int> p4(i1, i2, i3, i4, i5);
+
return 0;
}
--- /dev/null
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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/>.
+
+#include <tuple>
+#include <type_traits>
+
+// DR 801, pair and tuple vs. "passed in registers"
+void test_trivial()
+{
+ // PODType, TType, NType, SLType, LType, NLType, LTypeDerived
+ typedef std::tuple<int, int> tuple_type;
+ // static_assert(std::is_literal_type<tuple_type>::value, "! literal");
+ static_assert(std::has_trivial_copy_constructor<tuple_type>::value,
+ "! triv copy");
+ static_assert(std::has_trivial_destructor<tuple_type>::value,
+ "! triv destructor");
+ // static_assert(std::is_standard_layout<tuple_type>::value,
+ // "! standard layout");
+
+ // Negative
+ /*
+ static_assert(std::has_trivial_default_constructor<tuple_type>::value,
+ "! triv default");
+ static_assert(std::has_trivial_copy_assign<tuple_type>::value,
+ "! triv assign");
+ static_assert(std::is_trivial<tuple_type>::value, "! triv");
+ static_assert(std::is_pod<tuple_type>::value, "! pod");
+ */
+}
+
+int main()
+{
+ test_trivial();
+ return 0;
+}
// { dg-warning "note" "" { target *-*-* } 350 }
// { dg-warning "note" "" { target *-*-* } 1082 }
// { dg-warning "note" "" { target *-*-* } 465 }
-// { dg-warning "note" "" { target *-*-* } 580 }
+// { dg-warning "note" "" { target *-*-* } 581 }
// { dg-warning "note" "" { target *-*-* } 1027 }
// { dg-warning "note" "" { target *-*-* } 340 }
// { dg-warning "note" "" { target *-*-* } 290 }
-// { dg-warning "note" "" { target *-*-* } 201 }
+// { dg-warning "note" "" { target *-*-* } 205 }
OSDN Git Service
