On 9 March 2018 at 00:41, Jonathan Wakely wrote:
> In order to meet the total order requirements of [comparisons] p2 we
> need to cast unrelated pointers to uintptr_t before comparing them.
> Those casts aren't allowed in constant expressions, so only cast
> when __builtin_constant_p says the result of the comparison is not a
> compile-time constant (because the arguments are not constants, or the
> result of the comparison is unspecified). When the result is constant
> just compare the pointers directly without casting.
>
> This ensures that the function can be called in constant expressions
> with suitable arguments, but still yields a total order even for
> otherwise unspecified pointer comparisons.
>
> PR libstdc++/78420
> * include/bits/stl_function.h (__ptr_rel_ops): New struct providing
> relational operators defining total order on pointers.
> (greater<_Tp*>, less<_Tp*>, greater_equal<_Tp*>, less_equal<_Tp>*):
> New partial specializations for pointers, using __ptr_rel_ops.
> (greater<void>, less<void>, greater_equal<void>, less_equal<void*):
> Dispatch to __ptr_rel_ops when both arguments are pointers.
> * testsuite/20_util/function_objects/comparisons_pointer.cc: New.
>
> Tested powerpc64le-linux. I intend to commit this to trunk and
> backport to the active branches, unless anybody sees a problem with
> this solution, or has any suggestions for improvement.
I intentionally used "_Tp* const&" for the parameter types of the new
partial specializations like greater<_Tp*>, because that's what the
standard says for the primary templates. But it would be more
efficient to pass pointers by value, and 20.5.5.5 [member.functions]
p2 allows us to do that. Here's a new patch with that change.
commit e783a8e1c3cc0d41221796a9cadea796269a95a0
Author: Jonathan Wakely <jwak...@redhat.com>
Date: Thu Mar 8 20:27:04 2018 +0000
PR libstdc++/78420 Make std::less etc. yield total order for pointers
In order to meet the total order requirements of [comparisons] p2 we
need to cast unrelated pointers to uintptr_t before comparing them.
Those casts aren't allowed in constant expressions, so only cast
when __builtin_constant_p says the result of the comparison is not a
compile-time constant (because the arguments are not constants, or the
result of the comparison is unspecified). When the result is constant
just compare the pointers directly without casting.
This ensures that the function can be called in constant expressions
with suitable arguments, but still yields a total order even for
otherwise unspecified pointer comparisons.
PR libstdc++/78420
* include/bits/stl_function.h (__ptr_rel_ops): New struct providing
relational operators defining total order on pointers.
(greater<_Tp*>, less<_Tp*>, greater_equal<_Tp*>, less_equal<_Tp>*):
New partial specializations for pointers, using __ptr_rel_ops.
(greater<void>, less<void>, greater_equal<void>, less_equal<void*):
Dispatch to __ptr_rel_ops when both arguments are pointers.
* testsuite/20_util/function_objects/comparisons_pointer.cc: New.
diff --git a/libstdc++-v3/include/bits/stl_function.h
b/libstdc++-v3/include/bits/stl_function.h
index f5f98b25395..b2c356c1b13 100644
--- a/libstdc++-v3/include/bits/stl_function.h
+++ b/libstdc++-v3/include/bits/stl_function.h
@@ -406,14 +406,91 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return __x <= __y; }
};
-#if __cplusplus > 201103L
+ struct __ptr_rel_ops
+ {
+ __ptr_rel_ops() = delete;
+ ~__ptr_rel_ops() = delete;
+
+ template<typename _Tp, typename _Up>
+ static _GLIBCXX14_CONSTEXPR bool
+ _S_greater(_Tp* __x, _Up* __y)
+ {
+ if (__builtin_constant_p (__x > __y))
+ return __x > __y;
+ return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y;
+ }
+
+ template<typename _Tp, typename _Up>
+ static _GLIBCXX14_CONSTEXPR bool
+ _S_less(_Tp* __x, _Up* __y)
+ {
+ if (__builtin_constant_p (__x < __y))
+ return __x < __y;
+ return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y;
+ }
+
+ template<typename _Tp, typename _Up>
+ static _GLIBCXX14_CONSTEXPR bool
+ _S_greater_equal(_Tp* __x, _Up* __y)
+ {
+ if (__builtin_constant_p (__x >= __y))
+ return __x >= __y;
+ return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y;
+ }
+
+ template<typename _Tp, typename _Up>
+ static _GLIBCXX14_CONSTEXPR bool
+ _S_less_equal(_Tp* __x, _Up* __y)
+ {
+ if (__builtin_constant_p (__x <= __y))
+ return __x <= __y;
+ return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y;
+ }
+ };
+
+ // Partial specialization of std::greater for pointers.
+ template<typename _Tp>
+ struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+ {
+ _GLIBCXX14_CONSTEXPR bool
+ operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
+ { return __ptr_rel_ops::_S_greater(__x, __y); }
+ };
+
+ // Partial specialization of std::less for pointers.
+ template<typename _Tp>
+ struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+ {
+ _GLIBCXX14_CONSTEXPR bool
+ operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
+ { return __ptr_rel_ops::_S_less(__x, __y); }
+ };
+
+ // Partial specialization of std::greater_equal for pointers.
+ template<typename _Tp>
+ struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+ {
+ _GLIBCXX14_CONSTEXPR bool
+ operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
+ { return __ptr_rel_ops::_S_greater_equal(__x, __y); }
+ };
+
+ // Partial specialization of std::less_equal for pointers.
+ template<typename _Tp>
+ struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+ {
+ _GLIBCXX14_CONSTEXPR bool
+ operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
+ { return __ptr_rel_ops::_S_less_equal(__x, __y); }
+ };
+
+#if __cplusplus >= 201402L
/// One of the @link comparison_functors comparison functors@endlink.
template<>
struct equal_to<void>
{
template <typename _Tp, typename _Up>
- _GLIBCXX14_CONSTEXPR
- auto
+ constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
@@ -427,8 +504,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct not_equal_to<void>
{
template <typename _Tp, typename _Up>
- _GLIBCXX14_CONSTEXPR
- auto
+ constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
@@ -442,14 +518,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct greater<void>
{
template <typename _Tp, typename _Up>
- _GLIBCXX14_CONSTEXPR
- auto
+ constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+ {
+ using _Ptrs = __and_<is_pointer<decay_t<_Tp>>,
is_pointer<decay_t<_Up>>>;
+ return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
_Ptrs());
+ }
typedef __is_transparent is_transparent;
+
+ private:
+ template<typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp* __t, _Up* __u, true_type) noexcept
+ { return __ptr_rel_ops::_S_greater(__t, __u); }
};
/// One of the @link comparison_functors comparison functors@endlink.
@@ -457,14 +546,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct less<void>
{
template <typename _Tp, typename _Up>
- _GLIBCXX14_CONSTEXPR
- auto
+ constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+ {
+ using _Ptrs = __and_<is_pointer<decay_t<_Tp>>,
is_pointer<decay_t<_Up>>>;
+ return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
_Ptrs());
+ }
typedef __is_transparent is_transparent;
+
+ private:
+ template<typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp* __t, _Up* __u, true_type) noexcept
+ { return __ptr_rel_ops::_S_less(__t, __u); }
};
/// One of the @link comparison_functors comparison functors@endlink.
@@ -472,14 +574,27 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct greater_equal<void>
{
template <typename _Tp, typename _Up>
- _GLIBCXX14_CONSTEXPR
- auto
+ constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+ {
+ using _Ptrs = __and_<is_pointer<decay_t<_Tp>>,
is_pointer<decay_t<_Up>>>;
+ return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
_Ptrs());
+ }
typedef __is_transparent is_transparent;
+
+ private:
+ template<typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp* __t, _Up* __u, true_type) noexcept
+ { return __ptr_rel_ops::_S_greater_equal(__t, __u); }
};
/// One of the @link comparison_functors comparison functors@endlink.
@@ -487,16 +602,29 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct less_equal<void>
{
template <typename _Tp, typename _Up>
- _GLIBCXX14_CONSTEXPR
- auto
+ constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+ {
+ using _Ptrs = __and_<is_pointer<decay_t<_Tp>>,
is_pointer<decay_t<_Up>>>;
+ return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
_Ptrs());
+ }
typedef __is_transparent is_transparent;
+
+ private:
+ template<typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp* __t, _Up* __u, true_type) noexcept
+ { return __ptr_rel_ops::_S_less_equal(__t, __u); }
};
-#endif
+#endif // C++14
/** @} */
// 20.3.4 logical operations
diff --git
a/libstdc++-v3/testsuite/20_util/function_objects/comparisons_pointer.cc
b/libstdc++-v3/testsuite/20_util/function_objects/comparisons_pointer.cc
new file mode 100644
index 00000000000..317e42d8f11
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/function_objects/comparisons_pointer.cc
@@ -0,0 +1,166 @@
+// Copyright (C) 2018 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-do run }
+
+#include <functional>
+#include <sstream>
+#include <testsuite_hooks.h>
+
+int b[8];
+int a[8];
+
+void
+test01()
+{
+ auto p = a + 8;
+ std::greater<int*> gt;
+
+ std::stringstream ss;
+ ss << gt(p, b) << ' ' << gt(b, p) << ' ' << (!gt(p, b) && !gt(b, p));
+ int sum = 0, n = 0;
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+#if __cplusplus >= 201402L
+ static_assert( gt(a+1, a), "constexpr greater<int*>" );
+ static_assert( !gt(a, a+1), "constexpr greater<int*>" );
+
+ ss.str("");
+ ss.clear();
+ sum = 0;
+ auto p2 = a + 8;
+ std::greater<> gt2;
+ ss << gt2(p2, b) << ' ' << gt2(b, p2) << ' ' << (!gt2(p2, b) && !gt2(b, p2));
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+ static_assert( gt2(a+1, a), "constexpr greater<>" );
+ static_assert( !gt2(a, a+1), "constexpr greater<>" );
+#endif
+}
+
+void
+test02()
+{
+ auto p = a + 8;
+ std::less<int*> lt;
+
+ std::stringstream ss;
+ ss << lt(p, b) << ' ' << lt(b, p) << ' ' << (!lt(p, b) && !lt(b, p));
+ int sum = 0, n = 0;
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+#if __cplusplus >= 201402L
+ static_assert( lt(a, a+1), "constexpr less<int*>" );
+ static_assert( !lt(a+1, a), "constexpr less<int*>" );
+
+ ss.str("");
+ ss.clear();
+ sum = 0;
+ auto p2 = a + 8;
+ std::less<> lt2;
+ ss << lt2(p2, b) << ' ' << lt2(b, p2) << ' ' << (!lt2(p2, b) && !lt2(b, p2));
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+ static_assert( lt2(a, a+1), "constexpr less<>" );
+ static_assert( !lt2(a+1, a), "constexpr less<>" );
+#endif
+}
+
+void
+test03()
+{
+ auto p = a + 8;
+ std::greater_equal<int*> ge;
+
+ std::stringstream ss;
+ ss << !ge(p, b) << ' ' << !ge(b, p) << ' ' << (ge(p, b) && ge(b, p));
+ int sum = 0, n = 0;
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+#if __cplusplus >= 201402L
+ static_assert( !ge(a, a+1), "constexpr greater_equal<int*>" );
+ static_assert( ge(a, a), "constexpr greater_equal<int*>" );
+ static_assert( ge(a+1, a), "constexpr greater_equal<int*>" );
+
+ ss.str("");
+ ss.clear();
+ sum = 0;
+ auto p2 = a + 8;
+ std::greater_equal<> ge2;
+ ss << !ge2(p2, b) << ' ' << !ge2(b, p2) << ' ' << (ge2(p2, b) && ge2(b, p2));
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+ static_assert( !ge2(a, a+1), "constexpr greater_equal<>" );
+ static_assert( ge2(a, a), "constexpr greater_equal<>" );
+ static_assert( ge2(a+1, a), "constexpr greater_equal<>" );
+#endif
+}
+
+void
+test04()
+{
+ auto p = a + 8;
+ std::less_equal<int*> le;
+
+ std::stringstream ss;
+ ss << !le(p, b) << ' ' << !le(b, p) << ' ' << (le(p, b) && le(b, p));
+ int sum = 0, n = 0;
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+#if __cplusplus >= 201402L
+ static_assert( !le(a+1, a), "constexpr less_equal<int*>" );
+ static_assert( le(a, a), "constexpr less_equal<int*>" );
+ static_assert( le(a, a+1), "constexpr less_equal<int*>" );
+
+ ss.str("");
+ ss.clear();
+ sum = 0;
+ auto p2 = a + 8;
+ std::less_equal<> le2;
+ ss << !le2(p2, b) << ' ' << !le2(b, p2) << ' ' << (le2(p2, b) && le2(b, p2));
+ while (ss >> n)
+ sum += n;
+ VERIFY( sum == 1 );
+
+ static_assert( !le2(a+1, a), "constexpr less_equal<>" );
+ static_assert( le2(a, a), "constexpr less_equal<>" );
+ static_assert( le2(a, a+1), "constexpr less_equal<>" );
+#endif
+}
+
+int
+main()
+{
+ test01();
+ test02();
+ test03();
+ test04();
+}
