compare
Go to the documentation of this file.
// -*- C++ -*- operator<=> three-way comparison support.
// Copyright (C) 2019-2026 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC 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.
//
// GCC 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.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file compare
* This is a Standard C++ Library header.
*/
#ifndef _COMPARE
#define _COMPARE
#ifdef _GLIBCXX_SYSHDR
#pragma GCC system_header
#endif
#define __glibcxx_want_concepts
#define __glibcxx_want_three_way_comparison
#define __glibcxx_want_type_order
#include <bits/version.h>
#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
#include <concepts>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic" // __int128
#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
namespace std _GLIBCXX_VISIBILITY(default)
{
// [cmp.categories], comparison category types
namespace __cmp_cat
{
using type = signed char;
enum class _Ord : type
{
equivalent = 0, less = -1, greater = 1,
// value remains unchanged when negated
unordered = -__SCHAR_MAX__ - 1
};
template<typename _Ordering>
[[__gnu__::__always_inline__]]
constexpr _Ord
__ord(_Ordering __o) noexcept
{ return _Ord(__o._M_value); }
template<typename _Ordering>
[[__gnu__::__always_inline__]]
constexpr _Ordering
__make(_Ord __o) noexcept
{ return _Ordering(__o); }
struct __literal_zero
{
consteval __literal_zero(__literal_zero*) noexcept { }
};
}
class partial_ordering
{
// less=0xff, equiv=0x00, greater=0x01, unordered=0x80
__cmp_cat::type _M_value;
constexpr explicit
partial_ordering(__cmp_cat::_Ord __v) noexcept
: _M_value(__cmp_cat::type(__v))
{ }
[[__gnu__::__always_inline__]]
constexpr __cmp_cat::type
_M_reverse() const
{
// leaves _Ord::unordered unchanged
return static_cast<__cmp_cat::type>(-_M_value);
}
friend constexpr __cmp_cat::_Ord
__cmp_cat::__ord<partial_ordering>(partial_ordering) noexcept;
friend constexpr partial_ordering
__cmp_cat::__make<partial_ordering>(__cmp_cat::_Ord) noexcept;
public:
// valid values
static const partial_ordering less;
static const partial_ordering equivalent;
static const partial_ordering greater;
static const partial_ordering unordered;
// comparisons
[[nodiscard]]
friend constexpr bool
operator==(partial_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value == 0; }
[[nodiscard]]
friend constexpr bool
operator==(partial_ordering, partial_ordering) noexcept = default;
[[nodiscard]]
friend constexpr bool
operator< (partial_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value == -1; }
[[nodiscard]]
friend constexpr bool
operator> (partial_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value == 1; }
[[nodiscard]]
friend constexpr bool
operator<=(partial_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_reverse() >= 0; }
[[nodiscard]]
friend constexpr bool
operator>=(partial_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value >= 0; }
[[nodiscard]]
friend constexpr bool
operator< (__cmp_cat::__literal_zero, partial_ordering __v) noexcept
{ return __v._M_value == 1; }
[[nodiscard]]
friend constexpr bool
operator> (__cmp_cat::__literal_zero, partial_ordering __v) noexcept
{ return __v._M_value == -1; }
[[nodiscard]]
friend constexpr bool
operator<=(__cmp_cat::__literal_zero, partial_ordering __v) noexcept
{ return 0 <= __v._M_value; }
[[nodiscard]]
friend constexpr bool
operator>=(__cmp_cat::__literal_zero, partial_ordering __v) noexcept
{ return 0 <= __v._M_reverse(); }
[[nodiscard]]
friend constexpr partial_ordering
operator<=>(partial_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v; }
[[nodiscard]]
friend constexpr partial_ordering
operator<=>(__cmp_cat::__literal_zero, partial_ordering __v) noexcept
{ return partial_ordering(__cmp_cat::_Ord(__v._M_reverse())); }
};
// valid values' definitions
inline constexpr partial_ordering
partial_ordering::less(__cmp_cat::_Ord::less);
inline constexpr partial_ordering
partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);
inline constexpr partial_ordering
partial_ordering::greater(__cmp_cat::_Ord::greater);
inline constexpr partial_ordering
partial_ordering::unordered(__cmp_cat::_Ord::unordered);
class weak_ordering
{
__cmp_cat::type _M_value;
constexpr explicit
weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v))
{ }
friend constexpr __cmp_cat::_Ord
__cmp_cat::__ord<weak_ordering>(weak_ordering) noexcept;
friend constexpr weak_ordering
__cmp_cat::__make<weak_ordering>(__cmp_cat::_Ord) noexcept;
public:
// valid values
static const weak_ordering less;
static const weak_ordering equivalent;
static const weak_ordering greater;
[[nodiscard]]
constexpr operator partial_ordering() const noexcept
{ return __cmp_cat::__make<partial_ordering>(__cmp_cat::_Ord(_M_value)); }
// comparisons
[[nodiscard]]
friend constexpr bool
operator==(weak_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value == 0; }
[[nodiscard]]
friend constexpr bool
operator==(weak_ordering, weak_ordering) noexcept = default;
[[nodiscard]]
friend constexpr bool
operator< (weak_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value < 0; }
[[nodiscard]]
friend constexpr bool
operator> (weak_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value > 0; }
[[nodiscard]]
friend constexpr bool
operator<=(weak_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value <= 0; }
[[nodiscard]]
friend constexpr bool
operator>=(weak_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value >= 0; }
[[nodiscard]]
friend constexpr bool
operator< (__cmp_cat::__literal_zero, weak_ordering __v) noexcept
{ return 0 < __v._M_value; }
[[nodiscard]]
friend constexpr bool
operator> (__cmp_cat::__literal_zero, weak_ordering __v) noexcept
{ return 0 > __v._M_value; }
[[nodiscard]]
friend constexpr bool
operator<=(__cmp_cat::__literal_zero, weak_ordering __v) noexcept
{ return 0 <= __v._M_value; }
[[nodiscard]]
friend constexpr bool
operator>=(__cmp_cat::__literal_zero, weak_ordering __v) noexcept
{ return 0 >= __v._M_value; }
[[nodiscard]]
friend constexpr weak_ordering
operator<=>(weak_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v; }
[[nodiscard]]
friend constexpr weak_ordering
operator<=>(__cmp_cat::__literal_zero, weak_ordering __v) noexcept
{ return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); }
};
// valid values' definitions
inline constexpr weak_ordering
weak_ordering::less(__cmp_cat::_Ord::less);
inline constexpr weak_ordering
weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);
inline constexpr weak_ordering
weak_ordering::greater(__cmp_cat::_Ord::greater);
class strong_ordering
{
__cmp_cat::type _M_value;
constexpr explicit
strong_ordering(__cmp_cat::_Ord __v) noexcept
: _M_value(__cmp_cat::type(__v))
{ }
friend constexpr __cmp_cat::_Ord
__cmp_cat::__ord<strong_ordering>(strong_ordering) noexcept;
friend constexpr strong_ordering
__cmp_cat::__make<strong_ordering>(__cmp_cat::_Ord) noexcept;
public:
// valid values
static const strong_ordering less;
static const strong_ordering equal;
static const strong_ordering equivalent;
static const strong_ordering greater;
[[nodiscard]]
constexpr operator partial_ordering() const noexcept
{ return __cmp_cat::__make<partial_ordering>(__cmp_cat::_Ord(_M_value)); }
[[nodiscard]]
constexpr operator weak_ordering() const noexcept
{ return __cmp_cat::__make<weak_ordering>(__cmp_cat::_Ord(_M_value)); }
// comparisons
[[nodiscard]]
friend constexpr bool
operator==(strong_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value == 0; }
[[nodiscard]]
friend constexpr bool
operator==(strong_ordering, strong_ordering) noexcept = default;
[[nodiscard]]
friend constexpr bool
operator< (strong_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value < 0; }
[[nodiscard]]
friend constexpr bool
operator> (strong_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value > 0; }
[[nodiscard]]
friend constexpr bool
operator<=(strong_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value <= 0; }
[[nodiscard]]
friend constexpr bool
operator>=(strong_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v._M_value >= 0; }
[[nodiscard]]
friend constexpr bool
operator< (__cmp_cat::__literal_zero, strong_ordering __v) noexcept
{ return 0 < __v._M_value; }
[[nodiscard]]
friend constexpr bool
operator> (__cmp_cat::__literal_zero, strong_ordering __v) noexcept
{ return 0 > __v._M_value; }
[[nodiscard]]
friend constexpr bool
operator<=(__cmp_cat::__literal_zero, strong_ordering __v) noexcept
{ return 0 <= __v._M_value; }
[[nodiscard]]
friend constexpr bool
operator>=(__cmp_cat::__literal_zero, strong_ordering __v) noexcept
{ return 0 >= __v._M_value; }
[[nodiscard]]
friend constexpr strong_ordering
operator<=>(strong_ordering __v, __cmp_cat::__literal_zero) noexcept
{ return __v; }
[[nodiscard]]
friend constexpr strong_ordering
operator<=>(__cmp_cat::__literal_zero, strong_ordering __v) noexcept
{ return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }
};
// valid values' definitions
inline constexpr strong_ordering
strong_ordering::less(__cmp_cat::_Ord::less);
inline constexpr strong_ordering
strong_ordering::equal(__cmp_cat::_Ord::equivalent);
inline constexpr strong_ordering
strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);
inline constexpr strong_ordering
strong_ordering::greater(__cmp_cat::_Ord::greater);
// named comparison functions
[[nodiscard]]
constexpr bool
is_eq(partial_ordering __cmp) noexcept
{ return __cmp == 0; }
[[nodiscard]]
constexpr bool
is_neq(partial_ordering __cmp) noexcept
{ return __cmp != 0; }
[[nodiscard]]
constexpr bool
is_lt (partial_ordering __cmp) noexcept
{ return __cmp < 0; }
[[nodiscard]]
constexpr bool
is_lteq(partial_ordering __cmp) noexcept
{ return __cmp <= 0; }
[[nodiscard]]
constexpr bool
is_gt (partial_ordering __cmp) noexcept
{ return __cmp > 0; }
[[nodiscard]]
constexpr bool
is_gteq(partial_ordering __cmp) noexcept
{ return __cmp >= 0; }
namespace __detail
{
template<typename _Tp>
inline constexpr unsigned __cmp_cat_id = 1;
template<>
inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2;
template<>
inline constexpr unsigned __cmp_cat_id<weak_ordering> = 4;
template<>
inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8;
template<typename... _Ts>
constexpr auto __common_cmp_cat()
{
constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...);
// If any Ti is not a comparison category type, U is void.
if constexpr (__cats & 1)
return;
// Otherwise, if at least one Ti is std::partial_ordering,
// U is std::partial_ordering.
else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>))
return partial_ordering::equivalent;
// Otherwise, if at least one Ti is std::weak_ordering,
// U is std::weak_ordering.
else if constexpr (bool(__cats & __cmp_cat_id<weak_ordering>))
return weak_ordering::equivalent;
// Otherwise, U is std::strong_ordering.
else
return strong_ordering::equivalent;
}
} // namespace __detail
// [cmp.common], common comparison category type
template<typename... _Ts>
struct common_comparison_category
{
using type = decltype(__detail::__common_cmp_cat<_Ts...>());
};
// Partial specializations for one and zero argument cases.
template<typename _Tp>
struct common_comparison_category<_Tp>
{ using type = void; };
template<>
struct common_comparison_category<partial_ordering>
{ using type = partial_ordering; };
template<>
struct common_comparison_category<weak_ordering>
{ using type = weak_ordering; };
template<>
struct common_comparison_category<strong_ordering>
{ using type = strong_ordering; };
template<>
struct common_comparison_category<>
{ using type = strong_ordering; };
template<typename... _Ts>
using common_comparison_category_t
= typename common_comparison_category<_Ts...>::type;
#if __cpp_lib_three_way_comparison >= 201907L
// C++ >= 20 && impl_3way_comparison >= 201907 && lib_concepts
namespace __detail
{
template<typename _Tp, typename _Cat>
concept __compares_as
= same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
} // namespace __detail
// [cmp.concept], concept three_way_comparable
template<typename _Tp, typename _Cat = partial_ordering>
concept three_way_comparable
= __detail::__weakly_eq_cmp_with<_Tp, _Tp>
&& __detail::__partially_ordered_with<_Tp, _Tp>
&& requires(const remove_reference_t<_Tp>& __a,
const remove_reference_t<_Tp>& __b)
{
{ __a <=> __b } -> __detail::__compares_as<_Cat>;
};
template<typename _Tp, typename _Up, typename _Cat = partial_ordering>
concept three_way_comparable_with
= three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat>
&& __detail::__comparison_common_type_with<_Tp, _Up>
&& three_way_comparable<
common_reference_t<const remove_reference_t<_Tp>&,
const remove_reference_t<_Up>&>, _Cat>
&& __detail::__weakly_eq_cmp_with<_Tp, _Up>
&& __detail::__partially_ordered_with<_Tp, _Up>
&& requires(const remove_reference_t<_Tp>& __t,
const remove_reference_t<_Up>& __u)
{
{ __t <=> __u } -> __detail::__compares_as<_Cat>;
{ __u <=> __t } -> __detail::__compares_as<_Cat>;
};
namespace __detail
{
template<typename _Tp, typename _Up>
using __cmp3way_res_t
= decltype(std::declval<_Tp>() <=> std::declval<_Up>());
// Implementation of std::compare_three_way_result.
// It is undefined for a program to add specializations of
// std::compare_three_way_result, so the std::compare_three_way_result_t
// alias ignores std::compare_three_way_result and uses
// __detail::__cmp3way_res_impl directly instead.
template<typename _Tp, typename _Up>
struct __cmp3way_res_impl
{ };
template<typename _Tp, typename _Up>
requires requires { typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; }
struct __cmp3way_res_impl<_Tp, _Up>
{
using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>;
};
} // namespace __detail
/// [cmp.result], result of three-way comparison
template<typename _Tp, typename _Up = _Tp>
struct compare_three_way_result
: __detail::__cmp3way_res_impl<_Tp, _Up>
{ };
/// [cmp.result], result of three-way comparison
template<typename _Tp, typename _Up = _Tp>
using compare_three_way_result_t
= typename __detail::__cmp3way_res_impl<_Tp, _Up>::type;
namespace __detail
{
// BUILTIN-PTR-THREE-WAY(T, U)
// This determines whether t <=> u results in a call to a built-in
// operator<=> comparing pointers. It doesn't work for function pointers
// (PR 93628).
template<typename _Tp, typename _Up>
concept __3way_builtin_ptr_cmp
= requires(_Tp&& __t, _Up&& __u)
{ static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); }
&& convertible_to<_Tp, const volatile void*>
&& convertible_to<_Up, const volatile void*>
&& __not_overloaded_spaceship<_Tp, _Up>;
} // namespace __detail
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3530 BUILTIN-PTR-MEOW should not opt the type out of syntactic checks
// [cmp.object], typename compare_three_way
struct compare_three_way
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++23-extensions" // static operator()
template<typename _Tp, typename _Up>
requires three_way_comparable_with<_Tp, _Up>
static constexpr auto
operator() [[nodiscard]] (_Tp&& __t, _Up&& __u)
noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>()))
{
if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>)
{
auto __pt = static_cast<const volatile void*>(__t);
auto __pu = static_cast<const volatile void*>(__u);
if (std::__is_constant_evaluated())
return __pt <=> __pu;
auto __it = reinterpret_cast<__UINTPTR_TYPE__>(__pt);
auto __iu = reinterpret_cast<__UINTPTR_TYPE__>(__pu);
return __it <=> __iu;
}
else
return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u);
}
#pragma GCC diagnostic pop
using is_transparent = void;
};
/// @cond undocumented
// Namespace for helpers for the <compare> customization points.
namespace __compare
{
template<floating_point _Tp>
constexpr weak_ordering
__fp_weak_ordering(_Tp __e, _Tp __f)
{
auto __po = __cmp_cat::__ord(__e <=> __f);
if (__po != __cmp_cat::_Ord::unordered)
return __cmp_cat::__make<weak_ordering>(__po);
else // unordered, at least one argument is NaN
{
// return -1 for negative nan, +1 for positive nan, 0 otherwise.
auto __isnan_sign = [](_Tp __fp) -> int {
return __builtin_isnan(__fp)
? __builtin_signbit(__fp) ? -1 : 1
: 0;
};
return __isnan_sign(__e) <=> __isnan_sign(__f);
}
}
void strong_order() = delete;
template<typename _Tp, typename _Up>
concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
{
strong_ordering(strong_order(static_cast<_Tp&&>(__t),
static_cast<_Up&&>(__u)));
};
void weak_order() = delete;
template<typename _Tp, typename _Up>
concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
{
weak_ordering(weak_order(static_cast<_Tp&&>(__t),
static_cast<_Up&&>(__u)));
};
void partial_order() = delete;
template<typename _Tp, typename _Up>
concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
{
partial_ordering(partial_order(static_cast<_Tp&&>(__t),
static_cast<_Up&&>(__u)));
};
template<typename _Ord, typename _Tp, typename _Up>
concept __cmp3way = requires(_Tp&& __t, _Up&& __u, compare_three_way __c)
{
_Ord(__c(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)));
};
template<typename _Tp, typename _Up>
concept __strongly_ordered
= __adl_strong<_Tp, _Up>
|| floating_point<remove_reference_t<_Tp>>
|| __cmp3way<strong_ordering, _Tp, _Up>;
template<typename _Tp, typename _Up>
concept __decayed_same_as = same_as<decay_t<_Tp>, decay_t<_Up>>;
class _Strong_order
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (floating_point<decay_t<_Tp>>)
return true;
else if constexpr (__adl_strong<_Tp, _Up>)
return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
std::declval<_Up>())));
else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
return noexcept(compare_three_way()(std::declval<_Tp>(),
std::declval<_Up>()));
}
friend class _Weak_order;
friend class _Strong_fallback;
// Names for the supported floating-point representations.
enum class _Fp_fmt
{
_Binary16, _Binary32, _Binary64, _Binary128, // IEEE
_X86_80bit, // x86 80-bit extended precision
_M68k_80bit, // m68k 80-bit extended precision
_Dbldbl, // IBM 128-bit double-double
_Bfloat16, // std::bfloat16_t
};
#ifndef __cpp_using_enum
// XXX Remove these once 'using enum' support is ubiquitous.
static constexpr _Fp_fmt _Binary16 = _Fp_fmt::_Binary16;
static constexpr _Fp_fmt _Binary32 = _Fp_fmt::_Binary32;
static constexpr _Fp_fmt _Binary64 = _Fp_fmt::_Binary64;
static constexpr _Fp_fmt _Binary128 = _Fp_fmt::_Binary128;
static constexpr _Fp_fmt _X86_80bit = _Fp_fmt::_X86_80bit;
static constexpr _Fp_fmt _M68k_80bit = _Fp_fmt::_M68k_80bit;
static constexpr _Fp_fmt _Dbldbl = _Fp_fmt::_Dbldbl;
static constexpr _Fp_fmt _Bfloat16 = _Fp_fmt::_Bfloat16;
#endif
// Identify the format used by a floating-point type.
template<typename _Tp>
static consteval _Fp_fmt
_S_fp_fmt() noexcept
{
#ifdef __cpp_using_enum
using enum _Fp_fmt;
#endif
// Identify these formats first, then assume anything else is IEEE.
// N.B. ARM __fp16 alternative format can be handled as binary16.
#ifdef __LONG_DOUBLE_IBM128__
if constexpr (__is_same(_Tp, long double))
return _Dbldbl;
#elif defined __LONG_DOUBLE_IEEE128__ && defined __SIZEOF_IBM128__
if constexpr (__is_same(_Tp, __ibm128))
return _Dbldbl;
#endif
#if __LDBL_MANT_DIG__ == 64
if constexpr (__is_same(_Tp, long double))
return __LDBL_MIN_EXP__ == -16381 ? _X86_80bit : _M68k_80bit;
#endif
#ifdef __SIZEOF_FLOAT80__
if constexpr (__is_same(_Tp, __float80))
return _X86_80bit;
#endif
#ifdef __STDCPP_BFLOAT16_T__
if constexpr (__is_same(_Tp, decltype(0.0bf16)))
return _Bfloat16;
#endif
constexpr int __width = sizeof(_Tp) * __CHAR_BIT__;
if constexpr (__width == 16) // IEEE binary16 (or ARM fp16).
return _Binary16;
else if constexpr (__width == 32) // IEEE binary32
return _Binary32;
else if constexpr (__width == 64) // IEEE binary64
return _Binary64;
else if constexpr (__width == 128) // IEEE binary128
return _Binary128;
}
// So we don't need to include <stdint.h> and pollute the namespace.
using int64_t = __INT64_TYPE__;
using int32_t = __INT32_TYPE__;
using int16_t = __INT16_TYPE__;
using uint64_t = __UINT64_TYPE__;
using uint16_t = __UINT16_TYPE__;
// Used to unpack floating-point types that do not fit into an integer.
template<typename _Tp>
struct _Int
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint64_t _M_lo;
_Tp _M_hi;
#else
_Tp _M_hi;
uint64_t _M_lo;
#endif
constexpr explicit
_Int(_Tp __hi, uint64_t __lo) noexcept : _M_hi(__hi)
{ _M_lo = __lo; }
constexpr explicit
_Int(uint64_t __lo) noexcept : _M_hi(0)
{ _M_lo = __lo; }
constexpr bool operator==(const _Int&) const = default;
#if defined __hppa__ || (defined __mips__ && !defined __mips_nan2008)
consteval _Int
operator<<(int __n) const noexcept
{
// XXX this assumes n >= 64, which is true for the use below.
return _Int(static_cast<_Tp>(_M_lo << (__n - 64)), 0);
}
#endif
constexpr _Int&
operator^=(const _Int& __rhs) noexcept
{
_M_hi ^= __rhs._M_hi;
_M_lo ^= __rhs._M_lo;
return *this;
}
constexpr strong_ordering
operator<=>(const _Int& __rhs) const noexcept
{
strong_ordering __cmp = _M_hi <=> __rhs._M_hi;
if (__cmp != strong_ordering::equal)
return __cmp;
return _M_lo <=> __rhs._M_lo;
}
};
template<typename _Tp>
static constexpr _Tp
_S_compl(_Tp __t) noexcept
{
constexpr int __width = sizeof(_Tp) * __CHAR_BIT__;
// Sign extend to get all ones or all zeros.
make_unsigned_t<_Tp> __sign = __t >> (__width - 1);
// If the sign bit was set, this flips all bits below it.
// This converts ones' complement to two's complement.
return __t ^ (__sign >> 1);
}
// As above but works on both parts of _Int<T>.
template<typename _Tp>
static constexpr _Int<_Tp>
_S_compl(_Int<_Tp> __t) noexcept
{
constexpr int __width = sizeof(_Tp) * __CHAR_BIT__;
make_unsigned_t<_Tp> __sign = __t._M_hi >> (__width - 1);
__t._M_hi ^= (__sign >> 1 );
uint64_t __sign64 = (_Tp)__sign;
__t._M_lo ^= __sign64;
return __t;
}
// Bit-cast a floating-point value to an unsigned integer.
template<typename _Tp>
constexpr static auto
_S_fp_bits(_Tp __val) noexcept
{
if constexpr (sizeof(_Tp) == sizeof(int64_t))
return __builtin_bit_cast(int64_t, __val);
else if constexpr (sizeof(_Tp) == sizeof(int32_t))
return __builtin_bit_cast(int32_t, __val);
else if constexpr (sizeof(_Tp) == sizeof(int16_t))
return __builtin_bit_cast(int16_t, __val);
else
{
#ifdef __cpp_using_enum
using enum _Fp_fmt;
#endif
constexpr auto __fmt = _S_fp_fmt<_Tp>();
if constexpr (__fmt == _X86_80bit)
{
if constexpr (sizeof(_Tp) == 3 * sizeof(int32_t))
{
auto __ival = __builtin_bit_cast(_Int<int32_t>, __val);
return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
}
else
{
auto __ival = __builtin_bit_cast(_Int<int64_t>, __val);
return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
}
}
else if constexpr (__fmt == _M68k_80bit)
{
auto __ival = __builtin_bit_cast(_Int<int32_t>, __val);
return _Int<int16_t>(__ival._M_hi >> 16, __ival._M_lo);
}
else if constexpr (sizeof(_Tp) == 2 * sizeof(int64_t))
{
#if __SIZEOF_INT128__
return __builtin_bit_cast(__int128, __val);
#else
return __builtin_bit_cast(_Int<int64_t>, __val);
#endif
}
else
static_assert(sizeof(_Tp) == sizeof(int64_t),
"unsupported floating-point type");
}
}
template<typename _Tp>
static constexpr strong_ordering
_S_fp_cmp(_Tp __x, _Tp __y) noexcept
{
#ifdef __vax__
if (__builtin_isnan(__x) || __builtin_isnan(__y))
{
int __ix = (bool) __builtin_isnan(__x);
int __iy = (bool) __builtin_isnan(__y);
__ix *= __builtin_signbit(__x) ? -1 : 1;
__iy *= __builtin_signbit(__y) ? -1 : 1;
return __ix <=> __iy;
}
else
return __builtin_bit_cast(strong_ordering, __x <=> __y);
#endif
auto __ix = _S_fp_bits(__x);
auto __iy = _S_fp_bits(__y);
if (__ix == __iy)
return strong_ordering::equal; // All bits are equal, we're done.
#ifdef __cpp_using_enum
using enum _Fp_fmt;
#endif
constexpr auto __fmt = _S_fp_fmt<_Tp>();
if constexpr (__fmt == _Dbldbl) // double-double
{
// Unpack the double-double into two parts.
// We never inspect the low double as a double, cast to integer.
struct _Unpacked { double _M_hi; int64_t _M_lo; };
auto __x2 = __builtin_bit_cast(_Unpacked, __x);
auto __y2 = __builtin_bit_cast(_Unpacked, __y);
// Compare the high doubles first and use result if unequal.
auto __cmp = _S_fp_cmp(__x2._M_hi, __y2._M_hi);
if (__cmp != strong_ordering::equal)
return __cmp;
// For NaN the low double is unused, so if the high doubles
// are the same NaN, we don't need to compare the low doubles.
if (__builtin_isnan(__x2._M_hi))
return strong_ordering::equal;
// Similarly, if the low doubles are +zero or -zero (which is
// true for all infinities and some other values), we're done.
if (((__x2._M_lo | __y2._M_lo) & 0x7fffffffffffffffULL) == 0)
return strong_ordering::equal;
// Otherwise, compare the low parts.
return _S_compl(__x2._M_lo) <=> _S_compl(__y2._M_lo);
}
else
{
if constexpr (__fmt == _M68k_80bit)
{
// For m68k the MSB of the significand is ignored for the
// greatest exponent, so either 0 or 1 is valid there.
// Set it before comparing, so that we never have 0 there.
constexpr uint16_t __maxexp = 0x7fff;
if ((__ix._M_hi & __maxexp) == __maxexp)
__ix._M_lo |= 1ull << 63;
if ((__iy._M_hi & __maxexp) == __maxexp)
__iy._M_lo |= 1ull << 63;
}
else
{
#if defined __hppa__ || (defined __mips__ && !defined __mips_nan2008)
// IEEE 754-1985 allowed the meaning of the quiet/signaling
// bit to be reversed. Flip that to give desired ordering.
if (__builtin_isnan(__x) && __builtin_isnan(__y))
{
using _Int = decltype(__ix);
constexpr int __nantype = __fmt == _Binary32 ? 22
: __fmt == _Binary64 ? 51
: __fmt == _Binary128 ? 111
: -1;
constexpr _Int __bit = _Int(1) << __nantype;
__ix ^= __bit;
__iy ^= __bit;
}
#endif
}
return _S_compl(__ix) <=> _S_compl(__iy);
}
}
public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __strongly_ordered<_Tp, _Up>
constexpr strong_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (floating_point<decay_t<_Tp>>)
return _S_fp_cmp(__e, __f);
else if constexpr (__adl_strong<_Tp, _Up>)
return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f)));
else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
return compare_three_way()(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
}
};
template<typename _Tp, typename _Up>
concept __weakly_ordered
= floating_point<remove_reference_t<_Tp>>
|| __adl_weak<_Tp, _Up>
|| __cmp3way<weak_ordering, _Tp, _Up>
|| __strongly_ordered<_Tp, _Up>;
class _Weak_order
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (floating_point<decay_t<_Tp>>)
return true;
else if constexpr (__adl_weak<_Tp, _Up>)
return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
std::declval<_Up>())));
else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
return noexcept(compare_three_way()(std::declval<_Tp>(),
std::declval<_Up>()));
else if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order::_S_noexcept<_Tp, _Up>();
}
friend class _Partial_order;
friend class _Weak_fallback;
public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __weakly_ordered<_Tp, _Up>
constexpr weak_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (floating_point<decay_t<_Tp>>)
return __compare::__fp_weak_ordering(__e, __f);
else if constexpr (__adl_weak<_Tp, _Up>)
return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f)));
else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
return compare_three_way()(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
}
};
template<typename _Tp, typename _Up>
concept __partially_ordered
= __adl_partial<_Tp, _Up>
|| __cmp3way<partial_ordering, _Tp, _Up>
|| __weakly_ordered<_Tp, _Up>;
class _Partial_order
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__adl_partial<_Tp, _Up>)
return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
std::declval<_Up>())));
else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
return noexcept(compare_three_way()(std::declval<_Tp>(),
std::declval<_Up>()));
else if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order::_S_noexcept<_Tp, _Up>();
}
friend class _Partial_fallback;
public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __partially_ordered<_Tp, _Up>
constexpr partial_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__adl_partial<_Tp, _Up>)
return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f)));
else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
return compare_three_way()(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
}
};
template<typename _Tp, typename _Up>
concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
{
{ static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
-> convertible_to<bool>;
{ static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
-> convertible_to<bool>;
};
class _Strong_fallback
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order::_S_noexcept<_Tp, _Up>();
else
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
}
public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
constexpr strong_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else // __op_eq_lt<_Tp, _Up>
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
? strong_ordering::equal
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
? strong_ordering::less
: strong_ordering::greater;
}
};
class _Weak_fallback
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order::_S_noexcept<_Tp, _Up>();
else
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
}
public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
constexpr weak_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else // __op_eq_lt<_Tp, _Up>
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
? weak_ordering::equivalent
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
? weak_ordering::less
: weak_ordering::greater;
}
};
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3465. compare_partial_order_fallback requires F < E
template<typename _Tp, typename _Up>
concept __op_eq_lt_lt = __op_eq_lt<_Tp, _Up>
&& requires(_Tp&& __t, _Up&& __u)
{
{ static_cast<_Up&&>(__u) < static_cast<_Tp&&>(__t) }
-> convertible_to<bool>;
};
class _Partial_fallback
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__partially_ordered<_Tp, _Up>)
return _Partial_order::_S_noexcept<_Tp, _Up>();
else
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
}
public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __partially_ordered<_Tp, _Up> || __op_eq_lt_lt<_Tp, _Up>
constexpr partial_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__partially_ordered<_Tp, _Up>)
return _Partial_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else // __op_eq_lt_lt<_Tp, _Up>
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
? partial_ordering::equivalent
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
? partial_ordering::less
: static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
? partial_ordering::greater
: partial_ordering::unordered;
}
};
} // namespace @endcond
// [cmp.alg], comparison algorithms
inline namespace _Cpo
{
inline constexpr __compare::_Strong_order strong_order{};
inline constexpr __compare::_Weak_order weak_order{};
inline constexpr __compare::_Partial_order partial_order{};
inline constexpr __compare::_Strong_fallback
compare_strong_order_fallback{};
inline constexpr __compare::_Weak_fallback
compare_weak_order_fallback{};
inline constexpr __compare::_Partial_fallback
compare_partial_order_fallback{};
}
/// @cond undocumented
namespace __detail
{
// [expos.only.func] synth-three-way
inline constexpr struct _Synth3way
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr)
{
if constexpr (three_way_comparable_with<_Tp, _Up>)
return noexcept(*__t <=> *__u);
else
return noexcept(*__t < *__u) && noexcept(*__u < *__t);
}
template<typename _Tp, typename _Up>
[[nodiscard]]
constexpr auto
operator()(const _Tp& __t, const _Up& __u) const
noexcept(_S_noexcept<_Tp, _Up>())
requires requires
{
{ __t < __u } -> __boolean_testable;
{ __u < __t } -> __boolean_testable;
}
{
if constexpr (three_way_comparable_with<_Tp, _Up>)
return __t <=> __u;
else
{
if (__t < __u)
return weak_ordering::less;
else if (__u < __t)
return weak_ordering::greater;
else
return weak_ordering::equivalent;
}
}
} __synth3way = {};
// [expos.only.func] synth-three-way-result
template<typename _Tp, typename _Up = _Tp>
using __synth3way_t
= decltype(__detail::__synth3way(std::declval<_Tp&>(),
std::declval<_Up&>()));
} // namespace __detail
/// @endcond
#if __glibcxx_type_order >= 202506L // C++ >= 26
/// Total ordering of types.
/// @since C++26
template<typename _Tp, typename _Up>
struct type_order
{
static constexpr strong_ordering value = __builtin_type_order(_Tp, _Up);
using value_type = strong_ordering;
constexpr operator value_type() const noexcept { return value; }
constexpr value_type operator()() const noexcept { return value; }
};
/// @ingroup variable_templates
/// @since C++26
template<typename _Tp, typename _Up>
inline constexpr strong_ordering type_order_v
= __builtin_type_order(_Tp, _Up);
#endif // __glibcxx_type_order >= 202506L
#endif // __cpp_lib_three_way_comparison >= 201907L
} // namespace std
#pragma GCC diagnostic pop
#endif // C++20
#endif // _COMPARE
concepts
version.h
std::type_order_v
constexpr strong_ordering type_order_v
Definition compare:1280
std::common_reference_t
typename common_reference< _Tp... >::type common_reference_t
Definition type_traits:4289
std::remove_reference_t
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
Definition type_traits:1890
std::declval
auto declval() noexcept -> decltype(__declval< _Tp >(0))
Definition type_traits:2718
std
ISO C++ entities toplevel namespace is std.
std::compare_three_way_result_t
typename __detail::__cmp3way_res_impl< _Tp, _Up >::type compare_three_way_result_t
[cmp.result], result of three-way comparison
Definition compare:547
std::operator<<
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition bitset:1754
std::__detail
Implementation details not part of the namespace std interface.
std::compare_three_way_result
[cmp.result], result of three-way comparison
Definition compare:543
std::type_order
Total ordering of types.
Definition compare:1269
std::convertible_to
[concept.convertible], concept convertible_to
Definition concepts:81