1// -*- C++ -*- operator<=> three-way comparison support. 
2 
3// Copyright (C) 2019-2021 Free Software Foundation, Inc. 
4// 
5// This file is part of GCC. 
6// 
7// GCC is free software; you can redistribute it and/or modify 
8// it under the terms of the GNU General Public License as published by 
9// the Free Software Foundation; either version 3, or (at your option) 
10// any later version. 
11// 
12// GCC is distributed in the hope that it will be useful, 
13// but WITHOUT ANY WARRANTY; without even the implied warranty of 
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
15// GNU General Public License for more details. 
16// 
17// Under Section 7 of GPL version 3, you are granted additional 
18// permissions described in the GCC Runtime Library Exception, version 
19// 3.1, as published by the Free Software Foundation. 
20 
21// You should have received a copy of the GNU General Public License and 
22// a copy of the GCC Runtime Library Exception along with this program; 
23// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 
24// <http://www.gnu.org/licenses/>. 
25 
26/** @file compare 
27 * This is a Standard C++ Library header. 
28 */ 
29 
30#ifndef _COMPARE 
31#define _COMPARE 
32 
33#pragma GCC system_header 
34 
35#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L 
36 
37#pragma GCC visibility push(default) 
38 
39#include <concepts> 
40 
41#if __cpp_lib_concepts 
42# define __cpp_lib_three_way_comparison 201907L 
43#endif 
44 
45namespace std 
46{ 
47 // [cmp.categories], comparison category types 
48 
49 namespace __cmp_cat 
50 { 
51 using type = signed char; 
52 
53 enum class _Ord : type { equivalent = 0, less = -1, greater = 1 }; 
54 
55 enum class _Ncmp : type { _Unordered = 2 }; 
56 
57 struct __unspec 
58 { 
59 constexpr __unspec(__unspec*) noexcept { } 
60 }; 
61 } 
62 
63 class partial_ordering 
64 { 
65 // less=0xff, equiv=0x00, greater=0x01, unordered=0x02 
66 __cmp_cat::type _M_value; 
67 
68 constexpr explicit 
69 partial_ordering(__cmp_cat::_Ord __v) noexcept 
70 : _M_value(__cmp_cat::type(__v)) 
71 { } 
72 
73 constexpr explicit 
74 partial_ordering(__cmp_cat::_Ncmp __v) noexcept 
75 : _M_value(__cmp_cat::type(__v)) 
76 { } 
77 
78 friend class weak_ordering; 
79 friend class strong_ordering; 
80 
81 public: 
82 // valid values 
83 static const partial_ordering less; 
84 static const partial_ordering equivalent; 
85 static const partial_ordering greater; 
86 static const partial_ordering unordered; 
87 
88 // comparisons 
89 friend constexpr bool 
90 operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept 
91 { return __v._M_value == 0; } 
92 
93 friend constexpr bool 
94 operator==(partial_ordering, partial_ordering) noexcept = default; 
95 
96 friend constexpr bool 
97 operator< (partial_ordering __v, __cmp_cat::__unspec) noexcept 
98 { return __v._M_value == -1; } 
99 
100 friend constexpr bool 
101 operator> (partial_ordering __v, __cmp_cat::__unspec) noexcept 
102 { return __v._M_value == 1; } 
103 
104 friend constexpr bool 
105 operator<=(partial_ordering __v, __cmp_cat::__unspec) noexcept 
106 { return __v._M_value <= 0; } 
107 
108 friend constexpr bool 
109 operator>=(partial_ordering __v, __cmp_cat::__unspec) noexcept 
110 { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; } 
111 
112 friend constexpr bool 
113 operator< (__cmp_cat::__unspec, partial_ordering __v) noexcept 
114 { return __v._M_value == 1; } 
115 
116 friend constexpr bool 
117 operator> (__cmp_cat::__unspec, partial_ordering __v) noexcept 
118 { return __v._M_value == -1; } 
119 
120 friend constexpr bool 
121 operator<=(__cmp_cat::__unspec, partial_ordering __v) noexcept 
122 { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; } 
123 
124 friend constexpr bool 
125 operator>=(__cmp_cat::__unspec, partial_ordering __v) noexcept 
126 { return 0 >= __v._M_value; } 
127 
128 friend constexpr partial_ordering 
129 operator<=>(partial_ordering __v, __cmp_cat::__unspec) noexcept 
130 { return __v; } 
131 
132 friend constexpr partial_ordering 
133 operator<=>(__cmp_cat::__unspec, partial_ordering __v) noexcept 
134 { 
135 if (__v._M_value & 1) 
136 return partial_ordering(__cmp_cat::_Ord(-__v._M_value)); 
137 else 
138 return __v; 
139 } 
140 }; 
141 
142 // valid values' definitions 
143 inline constexpr partial_ordering 
144 partial_ordering::less(__cmp_cat::_Ord::less); 
145 
146 inline constexpr partial_ordering 
147 partial_ordering::equivalent(__cmp_cat::_Ord::equivalent); 
148 
149 inline constexpr partial_ordering 
150 partial_ordering::greater(__cmp_cat::_Ord::greater); 
151 
152 inline constexpr partial_ordering 
153 partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered); 
154 
155 class weak_ordering 
156 { 
157 __cmp_cat::type _M_value; 
158 
159 constexpr explicit 
160 weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v)) 
161 { } 
162 
163 friend class strong_ordering; 
164 
165 public: 
166 // valid values 
167 static const weak_ordering less; 
168 static const weak_ordering equivalent; 
169 static const weak_ordering greater; 
170 
171 constexpr operator partial_ordering() const noexcept 
172 { return partial_ordering(__cmp_cat::_Ord(_M_value)); } 
173 
174 // comparisons 
175 friend constexpr bool 
176 operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept 
177 { return __v._M_value == 0; } 
178 
179 friend constexpr bool 
180 operator==(weak_ordering, weak_ordering) noexcept = default; 
181 
182 friend constexpr bool 
183 operator< (weak_ordering __v, __cmp_cat::__unspec) noexcept 
184 { return __v._M_value < 0; } 
185 
186 friend constexpr bool 
187 operator> (weak_ordering __v, __cmp_cat::__unspec) noexcept 
188 { return __v._M_value > 0; } 
189 
190 friend constexpr bool 
191 operator<=(weak_ordering __v, __cmp_cat::__unspec) noexcept 
192 { return __v._M_value <= 0; } 
193 
194 friend constexpr bool 
195 operator>=(weak_ordering __v, __cmp_cat::__unspec) noexcept 
196 { return __v._M_value >= 0; } 
197 
198 friend constexpr bool 
199 operator< (__cmp_cat::__unspec, weak_ordering __v) noexcept 
200 { return 0 < __v._M_value; } 
201 
202 friend constexpr bool 
203 operator> (__cmp_cat::__unspec, weak_ordering __v) noexcept 
204 { return 0 > __v._M_value; } 
205 
206 friend constexpr bool 
207 operator<=(__cmp_cat::__unspec, weak_ordering __v) noexcept 
208 { return 0 <= __v._M_value; } 
209 
210 friend constexpr bool 
211 operator>=(__cmp_cat::__unspec, weak_ordering __v) noexcept 
212 { return 0 >= __v._M_value; } 
213 
214 friend constexpr weak_ordering 
215 operator<=>(weak_ordering __v, __cmp_cat::__unspec) noexcept 
216 { return __v; } 
217 
218 friend constexpr weak_ordering 
219 operator<=>(__cmp_cat::__unspec, weak_ordering __v) noexcept 
220 { return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); } 
221 }; 
222 
223 // valid values' definitions 
224 inline constexpr weak_ordering 
225 weak_ordering::less(__cmp_cat::_Ord::less); 
226 
227 inline constexpr weak_ordering 
228 weak_ordering::equivalent(__cmp_cat::_Ord::equivalent); 
229 
230 inline constexpr weak_ordering 
231 weak_ordering::greater(__cmp_cat::_Ord::greater); 
232 
233 class strong_ordering 
234 { 
235 __cmp_cat::type _M_value; 
236 
237 constexpr explicit 
238 strong_ordering(__cmp_cat::_Ord __v) noexcept 
239 : _M_value(__cmp_cat::type(__v)) 
240 { } 
241 
242 public: 
243 // valid values 
244 static const strong_ordering less; 
245 static const strong_ordering equal; 
246 static const strong_ordering equivalent; 
247 static const strong_ordering greater; 
248 
249 constexpr operator partial_ordering() const noexcept 
250 { return partial_ordering(__cmp_cat::_Ord(_M_value)); } 
251 
252 constexpr operator weak_ordering() const noexcept 
253 { return weak_ordering(__cmp_cat::_Ord(_M_value)); } 
254 
255 // comparisons 
256 friend constexpr bool 
257 operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept 
258 { return __v._M_value == 0; } 
259 
260 friend constexpr bool 
261 operator==(strong_ordering, strong_ordering) noexcept = default; 
262 
263 friend constexpr bool 
264 operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept 
265 { return __v._M_value < 0; } 
266 
267 friend constexpr bool 
268 operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept 
269 { return __v._M_value > 0; } 
270 
271 friend constexpr bool 
272 operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept 
273 { return __v._M_value <= 0; } 
274 
275 friend constexpr bool 
276 operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept 
277 { return __v._M_value >= 0; } 
278 
279 friend constexpr bool 
280 operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept 
281 { return 0 < __v._M_value; } 
282 
283 friend constexpr bool 
284 operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept 
285 { return 0 > __v._M_value; } 
286 
287 friend constexpr bool 
288 operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept 
289 { return 0 <= __v._M_value; } 
290 
291 friend constexpr bool 
292 operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept 
293 { return 0 >= __v._M_value; } 
294 
295 friend constexpr strong_ordering 
296 operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept 
297 { return __v; } 
298 
299 friend constexpr strong_ordering 
300 operator<=>(__cmp_cat::__unspec, strong_ordering __v) noexcept 
301 { return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); } 
302 }; 
303 
304 // valid values' definitions 
305 inline constexpr strong_ordering 
306 strong_ordering::less(__cmp_cat::_Ord::less); 
307 
308 inline constexpr strong_ordering 
309 strong_ordering::equal(__cmp_cat::_Ord::equivalent); 
310 
311 inline constexpr strong_ordering 
312 strong_ordering::equivalent(__cmp_cat::_Ord::equivalent); 
313 
314 inline constexpr strong_ordering 
315 strong_ordering::greater(__cmp_cat::_Ord::greater); 
316 
317 
318 // named comparison functions 
319 constexpr bool 
320 is_eq(partial_ordering __cmp) noexcept 
321 { return __cmp == 0; } 
322 
323 constexpr bool 
324 is_neq(partial_ordering __cmp) noexcept 
325 { return __cmp != 0; } 
326 
327 constexpr bool 
328 is_lt (partial_ordering __cmp) noexcept 
329 { return __cmp < 0; } 
330 
331 constexpr bool 
332 is_lteq(partial_ordering __cmp) noexcept 
333 { return __cmp <= 0; } 
334 
335 constexpr bool 
336 is_gt (partial_ordering __cmp) noexcept 
337 { return __cmp > 0; } 
338 
339 constexpr bool 
340 is_gteq(partial_ordering __cmp) noexcept 
341 { return __cmp >= 0; } 
342 
343 namespace __detail 
344 { 
345 template<typename _Tp> 
346 inline constexpr unsigned __cmp_cat_id = 1; 
347 template<> 
348 inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2; 
349 template<> 
350 inline constexpr unsigned __cmp_cat_id<weak_ordering> = 4; 
351 template<> 
352 inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8; 
353 
354 template<typename... _Ts> 
355 constexpr auto __common_cmp_cat() 
356 { 
357 constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...); 
358 // If any Ti is not a comparison category type, U is void. 
359 if constexpr (__cats & 1) 
360 return; 
361 // Otherwise, if at least one Ti is std::partial_ordering, 
362 // U is std::partial_ordering. 
363 else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>)) 
364 return partial_ordering::equivalent; 
365 // Otherwise, if at least one Ti is std::weak_ordering, 
366 // U is std::weak_ordering. 
367 else if constexpr (bool(__cats & __cmp_cat_id<weak_ordering>)) 
368 return weak_ordering::equivalent; 
369 // Otherwise, U is std::strong_ordering. 
370 else 
371 return strong_ordering::equivalent; 
372 } 
373 } // namespace __detail 
374 
375 // [cmp.common], common comparison category type 
376 template<typename... _Ts> 
377 struct common_comparison_category 
378 { 
379 using type = decltype(__detail::__common_cmp_cat<_Ts...>()); 
380 }; 
381 
382 // Partial specializations for one and zero argument cases. 
383 
384 template<typename _Tp> 
385 struct common_comparison_category<_Tp> 
386 { using type = void; }; 
387 
388 template<> 
389 struct common_comparison_category<partial_ordering> 
390 { using type = partial_ordering; }; 
391 
392 template<> 
393 struct common_comparison_category<weak_ordering> 
394 { using type = weak_ordering; }; 
395 
396 template<> 
397 struct common_comparison_category<strong_ordering> 
398 { using type = strong_ordering; }; 
399 
400 template<> 
401 struct common_comparison_category<> 
402 { using type = strong_ordering; }; 
403 
404 template<typename... _Ts> 
405 using common_comparison_category_t 
406 = typename common_comparison_category<_Ts...>::type; 
407 
408#if __cpp_lib_concepts 
409 namespace __detail 
410 { 
411 template<typename _Tp, typename _Cat> 
412 concept __compares_as 
413 = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>; 
414 } // namespace __detail 
415 
416 // [cmp.concept], concept three_way_comparable 
417 template<typename _Tp, typename _Cat = partial_ordering> 
418 concept three_way_comparable 
419 = __detail::__weakly_eq_cmp_with<_Tp, _Tp> 
420 && __detail::__partially_ordered_with<_Tp, _Tp> 
421 && requires(const remove_reference_t<_Tp>& __a, 
422 const remove_reference_t<_Tp>& __b) 
423 { 
424 { __a <=> __b } -> __detail::__compares_as<_Cat>; 
425 }; 
426 
427 template<typename _Tp, typename _Up, typename _Cat = partial_ordering> 
428 concept three_way_comparable_with 
429 = three_way_comparable<_Tp, _Cat> 
430 && three_way_comparable<_Up, _Cat> 
431 && common_reference_with<const remove_reference_t<_Tp>&, 
432 const remove_reference_t<_Up>&> 
433 && three_way_comparable< 
434 common_reference_t<const remove_reference_t<_Tp>&, 
435 const remove_reference_t<_Up>&>, _Cat> 
436 && __detail::__weakly_eq_cmp_with<_Tp, _Up> 
437 && __detail::__partially_ordered_with<_Tp, _Up> 
438 && requires(const remove_reference_t<_Tp>& __t, 
439 const remove_reference_t<_Up>& __u) 
440 { 
441 { __t <=> __u } -> __detail::__compares_as<_Cat>; 
442 { __u <=> __t } -> __detail::__compares_as<_Cat>; 
443 }; 
444 
445 namespace __detail 
446 { 
447 template<typename _Tp, typename _Up> 
448 using __cmp3way_res_t 
449 = decltype(std::declval<_Tp>() <=> std::declval<_Up>()); 
450 
451 // Implementation of std::compare_three_way_result. 
452 // It is undefined for a program to add specializations of 
453 // std::compare_three_way_result, so the std::compare_three_way_result_t 
454 // alias ignores std::compare_three_way_result and uses 
455 // __detail::__cmp3way_res_impl directly instead. 
456 template<typename _Tp, typename _Up> 
457 struct __cmp3way_res_impl 
458 { }; 
459 
460 template<typename _Tp, typename _Up> 
461 requires requires { typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; } 
462 struct __cmp3way_res_impl<_Tp, _Up> 
463 { 
464 using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; 
465 }; 
466 } // namespace __detail 
467 
468 /// [cmp.result], result of three-way comparison 
469 template<typename _Tp, typename _Up = _Tp> 
470 struct compare_three_way_result 
471 : __detail::__cmp3way_res_impl<_Tp, _Up> 
472 { }; 
473 
474 /// [cmp.result], result of three-way comparison 
475 template<typename _Tp, typename _Up = _Tp> 
476 using compare_three_way_result_t 
477 = typename __detail::__cmp3way_res_impl<_Tp, _Up>::type; 
478 
479 namespace __detail 
480 { 
481 // BUILTIN-PTR-THREE-WAY(T, U) 
482 // This determines whether t <=> u results in a call to a built-in 
483 // operator<=> comparing pointers. It doesn't work for function pointers 
484 // (PR 93628). 
485 template<typename _Tp, typename _Up> 
486 concept __3way_builtin_ptr_cmp 
487 = requires(_Tp&& __t, _Up&& __u) 
488 { static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); } 
489 && convertible_to<_Tp, const volatile void*> 
490 && convertible_to<_Up, const volatile void*> 
491 && ! requires(_Tp&& __t, _Up&& __u) 
492 { operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); } 
493 && ! requires(_Tp&& __t, _Up&& __u) 
494 { static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); }; 
495 } // namespace __detail 
496 
497 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
498 // 3530 BUILTIN-PTR-MEOW should not opt the type out of syntactic checks 
499 
500 // [cmp.object], typename compare_three_way 
501 struct compare_three_way 
502 { 
503 template<typename _Tp, typename _Up> 
504 requires three_way_comparable_with<_Tp, _Up> 
505 constexpr auto 
506 operator()(_Tp&& __t, _Up&& __u) const 
507 noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>())) 
508 { 
509 if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>) 
510 { 
511 auto __pt = static_cast<const volatile void*>(__t); 
512 auto __pu = static_cast<const volatile void*>(__u); 
513 if (__builtin_is_constant_evaluated()) 
514 return __pt <=> __pu; 
515 auto __it = reinterpret_cast<__UINTPTR_TYPE__>(__pt); 
516 auto __iu = reinterpret_cast<__UINTPTR_TYPE__>(__pu); 
517 return __it <=> __iu; 
518 } 
519 else 
520 return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); 
521 } 
522 
523 using is_transparent = void; 
524 }; 
525 
526 namespace __cmp_cust 
527 { 
528 template<floating_point _Tp> 
529 constexpr weak_ordering 
530 __fp_weak_ordering(_Tp __e, _Tp __f) 
531 { 
532 // Returns an integer with the same sign as the argument, and magnitude 
533 // indicating the classification: zero=1 subnorm=2 norm=3 inf=4 nan=5 
534 auto __cat = [](_Tp __fp) -> int { 
535 const int __sign = __builtin_signbit(__fp) ? -1 : 1; 
536 if (__builtin_isnormal(__fp)) 
537 return (__fp == 0 ? 1 : 3) * __sign; 
538 if (__builtin_isnan(__fp)) 
539 return 5 * __sign; 
540 if (int __inf = __builtin_isinf_sign(__fp)) 
541 return 4 * __inf; 
542 return 2 * __sign; 
543 }; 
544 
545 auto __po = __e <=> __f; 
546 if (is_lt(__po)) 
547 return weak_ordering::less; 
548 else if (is_gt(__po)) 
549 return weak_ordering::greater; 
550 else if (__po == partial_ordering::equivalent) 
551 return weak_ordering::equivalent; 
552 else // unordered, at least one argument is NaN 
553 { 
554 // return -1 for negative nan, +1 for positive nan, 0 otherwise. 
555 auto __isnan_sign = [](_Tp __fp) -> int { 
556 return __builtin_isnan(__fp) 
557 ? __builtin_signbit(__fp) ? -1 : 1 
558 : 0; 
559 }; 
560 auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f); 
561 if (is_eq(__ord)) 
562 return weak_ordering::equivalent; 
563 else if (is_lt(__ord)) 
564 return weak_ordering::less; 
565 else 
566 return weak_ordering::greater; 
567 } 
568 } 
569 
570 template<typename _Tp, typename _Up> 
571 concept __adl_strong = requires(_Tp&& __t, _Up&& __u) 
572 { 
573 strong_ordering(strong_order(static_cast<_Tp&&>(__t), 
574 static_cast<_Up&&>(__u))); 
575 }; 
576 
577 template<typename _Tp, typename _Up> 
578 concept __adl_weak = requires(_Tp&& __t, _Up&& __u) 
579 { 
580 weak_ordering(weak_order(static_cast<_Tp&&>(__t), 
581 static_cast<_Up&&>(__u))); 
582 }; 
583 
584 template<typename _Tp, typename _Up> 
585 concept __adl_partial = requires(_Tp&& __t, _Up&& __u) 
586 { 
587 partial_ordering(partial_order(static_cast<_Tp&&>(__t), 
588 static_cast<_Up&&>(__u))); 
589 }; 
590 
591 template<typename _Ord, typename _Tp, typename _Up> 
592 concept __cmp3way = requires(_Tp&& __t, _Up&& __u, compare_three_way __c) 
593 { 
594 _Ord(__c(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u))); 
595 }; 
596 
597 template<typename _Tp, typename _Up> 
598 concept __strongly_ordered 
599 = __adl_strong<_Tp, _Up> 
600 // FIXME: || floating_point<remove_reference_t<_Tp>> 
601 || __cmp3way<strong_ordering, _Tp, _Up>; 
602 
603 template<typename _Tp, typename _Up> 
604 concept __decayed_same_as = same_as<decay_t<_Tp>, decay_t<_Up>>; 
605 
606 class _Strong_order 
607 { 
608 template<typename _Tp, typename _Up> 
609 static constexpr bool 
610 _S_noexcept() 
611 { 
612 if constexpr (floating_point<decay_t<_Tp>>) 
613 return true; 
614 else if constexpr (__adl_strong<_Tp, _Up>) 
615 return noexcept(strong_ordering(strong_order(std::declval<_Tp>(), 
616 std::declval<_Up>()))); 
617 else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>) 
618 return noexcept(compare_three_way()(std::declval<_Tp>(), 
619 std::declval<_Up>())); 
620 } 
621 
622 friend class _Weak_order; 
623 friend class _Strong_fallback; 
624 
625 public: 
626 template<typename _Tp, __decayed_same_as<_Tp> _Up> 
627 requires __strongly_ordered<_Tp, _Up> 
628 constexpr strong_ordering 
629 operator()(_Tp&& __e, _Up&& __f) const 
630 noexcept(_S_noexcept<_Tp, _Up>()) 
631 { 
632 /* FIXME: 
633 if constexpr (floating_point<decay_t<_Tp>>) 
634 return __cmp_cust::__fp_strong_order(__e, __f); 
635 else */ if constexpr (__adl_strong<_Tp, _Up>) 
636 return strong_ordering(strong_order(static_cast<_Tp&&>(__e), 
637 static_cast<_Up&&>(__f))); 
638 else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>) 
639 return compare_three_way()(static_cast<_Tp&&>(__e), 
640 static_cast<_Up&&>(__f)); 
641 } 
642 }; 
643 
644 template<typename _Tp, typename _Up> 
645 concept __weakly_ordered 
646 = floating_point<remove_reference_t<_Tp>> 
647 || __adl_weak<_Tp, _Up> 
648 || __cmp3way<weak_ordering, _Tp, _Up> 
649 || __strongly_ordered<_Tp, _Up>; 
650 
651 class _Weak_order 
652 { 
653 template<typename _Tp, typename _Up> 
654 static constexpr bool 
655 _S_noexcept() 
656 { 
657 if constexpr (floating_point<decay_t<_Tp>>) 
658 return true; 
659 else if constexpr (__adl_weak<_Tp, _Up>) 
660 return noexcept(weak_ordering(weak_order(std::declval<_Tp>(), 
661 std::declval<_Up>()))); 
662 else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>) 
663 return noexcept(compare_three_way()(std::declval<_Tp>(), 
664 std::declval<_Up>())); 
665 else if constexpr (__strongly_ordered<_Tp, _Up>) 
666 return _Strong_order::_S_noexcept<_Tp, _Up>(); 
667 } 
668 
669 friend class _Partial_order; 
670 friend class _Weak_fallback; 
671 
672 public: 
673 template<typename _Tp, __decayed_same_as<_Tp> _Up> 
674 requires __weakly_ordered<_Tp, _Up> 
675 constexpr weak_ordering 
676 operator()(_Tp&& __e, _Up&& __f) const 
677 noexcept(_S_noexcept<_Tp, _Up>()) 
678 { 
679 if constexpr (floating_point<decay_t<_Tp>>) 
680 return __cmp_cust::__fp_weak_ordering(__e, __f); 
681 else if constexpr (__adl_weak<_Tp, _Up>) 
682 return weak_ordering(weak_order(static_cast<_Tp&&>(__e), 
683 static_cast<_Up&&>(__f))); 
684 else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>) 
685 return compare_three_way()(static_cast<_Tp&&>(__e), 
686 static_cast<_Up&&>(__f)); 
687 else if constexpr (__strongly_ordered<_Tp, _Up>) 
688 return _Strong_order{}(static_cast<_Tp&&>(__e), 
689 static_cast<_Up&&>(__f)); 
690 } 
691 }; 
692 
693 template<typename _Tp, typename _Up> 
694 concept __partially_ordered 
695 = __adl_partial<_Tp, _Up> 
696 || __cmp3way<partial_ordering, _Tp, _Up> 
697 || __weakly_ordered<_Tp, _Up>; 
698 
699 class _Partial_order 
700 { 
701 template<typename _Tp, typename _Up> 
702 static constexpr bool 
703 _S_noexcept() 
704 { 
705 if constexpr (__adl_partial<_Tp, _Up>) 
706 return noexcept(partial_ordering(partial_order(std::declval<_Tp>(), 
707 std::declval<_Up>()))); 
708 else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>) 
709 return noexcept(compare_three_way()(std::declval<_Tp>(), 
710 std::declval<_Up>())); 
711 else if constexpr (__weakly_ordered<_Tp, _Up>) 
712 return _Weak_order::_S_noexcept<_Tp, _Up>(); 
713 } 
714 
715 friend class _Partial_fallback; 
716 
717 public: 
718 template<typename _Tp, __decayed_same_as<_Tp> _Up> 
719 requires __partially_ordered<_Tp, _Up> 
720 constexpr partial_ordering 
721 operator()(_Tp&& __e, _Up&& __f) const 
722 noexcept(_S_noexcept<_Tp, _Up>()) 
723 { 
724 if constexpr (__adl_partial<_Tp, _Up>) 
725 return partial_ordering(partial_order(static_cast<_Tp&&>(__e), 
726 static_cast<_Up&&>(__f))); 
727 else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>) 
728 return compare_three_way()(static_cast<_Tp&&>(__e), 
729 static_cast<_Up&&>(__f)); 
730 else if constexpr (__weakly_ordered<_Tp, _Up>) 
731 return _Weak_order{}(static_cast<_Tp&&>(__e), 
732 static_cast<_Up&&>(__f)); 
733 } 
734 }; 
735 
736 template<typename _Tp, typename _Up> 
737 concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u) 
738 { 
739 { static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) } 
740 -> convertible_to<bool>; 
741 { static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) } 
742 -> convertible_to<bool>; 
743 }; 
744 
745 class _Strong_fallback 
746 { 
747 template<typename _Tp, typename _Up> 
748 static constexpr bool 
749 _S_noexcept() 
750 { 
751 if constexpr (__strongly_ordered<_Tp, _Up>) 
752 return _Strong_order::_S_noexcept<_Tp, _Up>(); 
753 else 
754 return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>())) 
755 && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>())); 
756 } 
757 
758 public: 
759 template<typename _Tp, __decayed_same_as<_Tp> _Up> 
760 requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> 
761 constexpr strong_ordering 
762 operator()(_Tp&& __e, _Up&& __f) const 
763 noexcept(_S_noexcept<_Tp, _Up>()) 
764 { 
765 if constexpr (__strongly_ordered<_Tp, _Up>) 
766 return _Strong_order{}(static_cast<_Tp&&>(__e), 
767 static_cast<_Up&&>(__f)); 
768 else // __op_eq_lt<_Tp, _Up> 
769 return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f) 
770 ? strong_ordering::equal 
771 : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f) 
772 ? strong_ordering::less 
773 : strong_ordering::greater; 
774 } 
775 }; 
776 
777 class _Weak_fallback 
778 { 
779 template<typename _Tp, typename _Up> 
780 static constexpr bool 
781 _S_noexcept() 
782 { 
783 if constexpr (__weakly_ordered<_Tp, _Up>) 
784 return _Weak_order::_S_noexcept<_Tp, _Up>(); 
785 else 
786 return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>())) 
787 && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>())); 
788 } 
789 
790 public: 
791 template<typename _Tp, __decayed_same_as<_Tp> _Up> 
792 requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> 
793 constexpr weak_ordering 
794 operator()(_Tp&& __e, _Up&& __f) const 
795 noexcept(_S_noexcept<_Tp, _Up>()) 
796 { 
797 if constexpr (__weakly_ordered<_Tp, _Up>) 
798 return _Weak_order{}(static_cast<_Tp&&>(__e), 
799 static_cast<_Up&&>(__f)); 
800 else // __op_eq_lt<_Tp, _Up> 
801 return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f) 
802 ? weak_ordering::equivalent 
803 : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f) 
804 ? weak_ordering::less 
805 : weak_ordering::greater; 
806 } 
807 }; 
808 
809 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
810 // 3465. compare_partial_order_fallback requires F < E 
811 template<typename _Tp, typename _Up> 
812 concept __op_eq_lt_lt = __op_eq_lt<_Tp, _Up> 
813 && requires(_Tp&& __t, _Up&& __u) 
814 { 
815 { static_cast<_Up&&>(__u) < static_cast<_Tp&&>(__t) } 
816 -> convertible_to<bool>; 
817 }; 
818 
819 class _Partial_fallback 
820 { 
821 template<typename _Tp, typename _Up> 
822 static constexpr bool 
823 _S_noexcept() 
824 { 
825 if constexpr (__partially_ordered<_Tp, _Up>) 
826 return _Partial_order::_S_noexcept<_Tp, _Up>(); 
827 else 
828 return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>())) 
829 && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>())); 
830 } 
831 
832 public: 
833 template<typename _Tp, __decayed_same_as<_Tp> _Up> 
834 requires __partially_ordered<_Tp, _Up> || __op_eq_lt_lt<_Tp, _Up> 
835 constexpr partial_ordering 
836 operator()(_Tp&& __e, _Up&& __f) const 
837 noexcept(_S_noexcept<_Tp, _Up>()) 
838 { 
839 if constexpr (__partially_ordered<_Tp, _Up>) 
840 return _Partial_order{}(static_cast<_Tp&&>(__e), 
841 static_cast<_Up&&>(__f)); 
842 else // __op_eq_lt_lt<_Tp, _Up> 
843 return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f) 
844 ? partial_ordering::equivalent 
845 : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f) 
846 ? partial_ordering::less 
847 : static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e) 
848 ? partial_ordering::greater 
849 : partial_ordering::unordered; 
850 } 
851 }; 
852 } // namespace __cmp_cust 
853 
854 // [cmp.alg], comparison algorithms 
855 inline namespace __cmp_alg 
856 { 
857 inline constexpr __cmp_cust::_Strong_order strong_order{}; 
858 
859 inline constexpr __cmp_cust::_Weak_order weak_order{}; 
860 
861 inline constexpr __cmp_cust::_Partial_order partial_order{}; 
862 
863 inline constexpr __cmp_cust::_Strong_fallback 
864 compare_strong_order_fallback{}; 
865 
866 inline constexpr __cmp_cust::_Weak_fallback 
867 compare_weak_order_fallback{}; 
868 
869 inline constexpr __cmp_cust::_Partial_fallback 
870 compare_partial_order_fallback{}; 
871 } 
872 
873 namespace __detail 
874 { 
875 // [expos.only.func] synth-three-way 
876 inline constexpr struct _Synth3way 
877 { 
878 template<typename _Tp, typename _Up> 
879 static constexpr bool 
880 _S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr) 
881 { 
882 if constexpr (three_way_comparable_with<_Tp, _Up>) 
883 return noexcept(*__t <=> *__u); 
884 else 
885 return noexcept(*__t < *__u) && noexcept(*__u < *__t); 
886 } 
887 
888 template<typename _Tp, typename _Up> 
889 constexpr auto 
890 operator()(const _Tp& __t, const _Up& __u) const 
891 noexcept(_S_noexcept<_Tp, _Up>()) 
892 requires requires 
893 { 
894 { __t < __u } -> __boolean_testable; 
895 { __u < __t } -> __boolean_testable; 
896 } 
897 { 
898 if constexpr (three_way_comparable_with<_Tp, _Up>) 
899 return __t <=> __u; 
900 else 
901 { 
902 if (__t < __u) 
903 return weak_ordering::less; 
904 else if (__u < __t) 
905 return weak_ordering::greater; 
906 else 
907 return weak_ordering::equivalent; 
908 } 
909 } 
910 } __synth3way = {}; 
911 
912 // [expos.only.func] synth-three-way-result 
913 template<typename _Tp, typename _Up = _Tp> 
914 using __synth3way_t 
915 = decltype(__detail::__synth3way(std::declval<_Tp&>(), 
916 std::declval<_Up&>())); 
917 } // namespace __detail 
918#endif // concepts 
919} // namespace std 
920 
921#pragma GCC visibility pop 
922 
923#endif // C++20 
924 
925#endif // _COMPARE 
926