This is an archive of the discontinued LLVM Phabricator instance.

Differential D107036

[WIP] [libc++] [P1614] Various unimplemented parts of <compare>. [WIP]
AbandonedPublic

Authored by • Quuxplusone on Jul 28 2021, 10:38 PM.

Details

Reviewers
ldionne
cjdb
Group Reviewers
Restricted Project
Summary

I have this locally as five commits, and plan to upload several PRs when it's actually ready to land.

Duplicates/supersedes the following similar PRs by others:

  • D80899 compare_three_way, blocked by lack of three_way_comparable

But does not supersede this one:

  • D80902 lexicographical_compare_three_way, blocked by lack of compare_three_way

Diff Detail

Unit TestsFailed

TimeTest
700 mslibcxx CI GCC 11 / C++latest > libc++.std/language_support/cmp/cmp_alg::strong_order.pass.cpp

Event Timeline

• Quuxplusone created this revision.Jul 28 2021, 10:38 PM
Herald added a subscriber: mgorny. · View Herald TranscriptJul 28 2021, 10:38 PM
• Quuxplusone requested review of this revision.Jul 28 2021, 10:38 PM
Herald added a reviewer: Restricted Project. · View Herald TranscriptJul 28 2021, 10:38 PM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
• Quuxplusone planned changes to this revision.Jul 28 2021, 10:38 PM
Harbormaster completed remote builds in B116876: Diff 362642.Jul 28 2021, 10:56 PM
• Quuxplusone updated this revision to Diff 362854.Jul 29 2021, 12:57 PM

Has tests now.
std::strong_order still doesn't compare NaNs correctly; we may need a domain expert for this.
Everything up to strong_order is probably ready to upload separately for review:

  • [libc++][modularisation] Split up <concepts> into granular headers.
  • [libc++] [p1614] Implement std::compare_three_way_result.
  • [libc++] [p1614] Implement std::three_way_comparable.
  • [libc++] [p1614] Implement std::compare_three_way.

@ldionne: Do you want the above as four PRs, one PR, or something in between?

Harbormaster completed remote builds in B117029: Diff 362854.Jul 29 2021, 1:18 PM
• Quuxplusone mentioned this in D107098: [libc++] Implement the underlying mechanism for range adaptors.Jul 30 2021, 10:47 AM
• Quuxplusone edited the summary of this revision. (Show Details)Jul 30 2021, 11:13 AM
• Quuxplusone updated this revision to Diff 363160.Jul 30 2021, 11:17 AM

Rebase (expecting CI to pass this time)

Harbormaster completed remote builds in B117233: Diff 363160.Jul 30 2021, 2:10 PM
Wmbat added a subscriber: Wmbat.Jul 31 2021, 8:33 AM
cjdb requested changes to this revision.Aug 1 2021, 5:14 PM
cjdb added a subscriber: cjdb.
In D107036#2914445, @Quuxplusone wrote:

Has tests now.
std::strong_order still doesn't compare NaNs correctly; we may need a domain expert for this.
Everything up to strong_order is probably ready to upload separately for review:

  • [libc++][modularisation] Split up <concepts> into granular headers.
  • [libc++] [p1614] Implement std::compare_three_way_result.
  • [libc++] [p1614] Implement std::three_way_comparable.
  • [libc++] [p1614] Implement std::compare_three_way.

@ldionne: Do you want the above as four PRs, one PR, or something in between?

I'd appreciate it if you could make these dependent PRs to make it easier to review.

libcxx/include/__concepts/__boolean_testable.h
1 ↗(On Diff #363160)

Please rename this file to boolean_testable.h. We decided a while back to not prefix detail headers with underscores.

libcxx/include/concepts
155–159 ↗(On Diff #363160)

If you're going to split up <concepts>, please entirely split it up. Having some content in <concepts> and other stuff in __concepts is going to be difficult to track.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp
1 ↗(On Diff #363160)

There are a lot of missing tests for this file. Please reintroduce them.

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp
1 ↗(On Diff #363160)

There are a lot of missing tests for this file. Please reintroduce them.

This revision now requires changes to proceed.Aug 1 2021, 5:14 PM
• Quuxplusone mentioned this in D107584: [libc++][modularisation] Split up <concepts> into granular headers..Aug 5 2021, 10:23 AM
cjdb added a comment.Aug 9 2021, 11:27 AM

In addition to my feedback above, please drop the <concepts> changes from this patch (no longer necessary), as well as the changes in common with D80899 and D80902 (I'll return to these once three_way_comparable lands).

Please also ensure that what's left properly credits the original patch authors in the commit, preferably by making them the person that's named in git blame.

• Quuxplusone mentioned this in D103581: [libc++] [P1614] Implement std::compare_three_way_result[_t]..Aug 10 2021, 7:17 PM
• Quuxplusone mentioned this in D103478: [libc++][compare] Implement three_way_comparable[_with] concepts.Aug 11 2021, 4:42 PM
mumbleskates added a subscriber: mumbleskates.Aug 15 2021, 7:23 PM
mumbleskates added inline comments.
libcxx/include/__compare/cmp_alg.h
66 ↗(On Diff #363160)

I would hope that we can order them by union view of the data in memory if such a thing is allowed (or memcpy, if that's better) once we know that the sign and signaling bits are the same, because the specifics of the payload ordering are unspecified by totalOrder. Any way that we can look at the raw data in memory without UB should be sufficient.

mumbleskates added inline comments.Aug 16 2021, 5:57 PM
libcxx/include/__compare/cmp_alg.h
66 ↗(On Diff #363160)

Ah I see, there are literally no standard implementation for the isSignaling predicate for iec559 types in C++. However, it does look like ISO C has an issignaling macro as part of the Floating-point extensions part 1, which I gather was accepted into the C23 standard in 2019 (ISO/IEC TS 60559-1, of interest section 7.12.3.7). Complete implementation of C++ strong_order for iec559 floating point types might be considered to be blocked on the implementation of this part of the standard as that seems like the best place to get it.

Implementing this just for strong_order is messy, very complex, and generally inadvisable. (Even for binary floating point values, ignoring the existence of decimal floating point types, some platforms -- notably PA-RISC -- use the opposite interpretation for the signaling bit in IEC559 floating point types, even though it's in the same location.) Unless we can strongly declare that we don't support any platforms other than say ARM and x86 this seems like a no-go, and it just seems better to take the platform support directly from the llvm C standard implementation.

• Quuxplusone added inline comments.Aug 17 2021, 8:23 PM
libcxx/include/__compare/cmp_alg.h
66 ↗(On Diff #363160)

@mumbleskates: I doubt I understand your two comments. In case it's not already obvious: the IEEE 754 "total order" predicate is well-defined and we must implement std::strong_order consistently with it, on IEEE 754 platforms, because the Standard says so. (On other platforms, C++ doesn't care so much, because those platforms are dumb. :)) std::strong_order(x,y) is the way that C++20 exposes the "total order" predicate to end-users; there is no isolable floating-point-total-order library function for us to delegate to (because WG21 doesn't do software engineering).

Is there an isolable "llvm C standard implementation" we could be exploiting here — some kind of __builtin_totalorder we could use when it's available? That would be really cool.
I do think that this will eventually need to use either constexpr-friendly __builtin_memcpy, or else std::bit_cast; I just haven't gotten around to revisiting it.

A bit of googling turned up this solution which maybe just needs to be tweaked a tiny bit: https://stackoverflow.com/a/20154751/1424877

mumbleskates added inline comments.Aug 17 2021, 9:36 PM
libcxx/include/__compare/cmp_alg.h
66 ↗(On Diff #363160)

That general solution in the stackoverflow link works, but may only be correct for x86/ARM binary representation floating point types. (I don't know enough about the decimal types to know if they would also sort this way, but they are unsupported by by x86/ARM silicon.)

What it boils down to is that the *only* predicate we are missing, for any given iec559 type, is isSignaling: detecting whether a NaN is signaling or not. If we have that we can use it to complete the implementation here. Such a predicate does exist in standard C, but I believe it is not yet implemented in llvm's libc.

I know exactly how to do this on x86 and ARM with bit twiddling for pretty much any floating point type in the standard, but there are platforms with iec559 implementations where the signaling bit has the opposite meaning, and I think there might exist platforms where it is in a different place. Because signaling/non-signaling NaN implementation details are a property of the platform this immediately becomes a question of platform support; it's probably best to centralize this implementation knowledge as much as possible, but I don't know much about our approach to that in the llvm project.

• Quuxplusone updated this revision to Diff 367673.Aug 19 2021, 5:56 PM
• Quuxplusone edited the summary of this revision. (Show Details)

Rebased on main, to show what's left to do.
Tried a new bit-twiddling version of IEC559 totalOrder. Unfortunately I still don't know how to test it or how to make it constexpr. Fortunately, C++20 requires that it not be constexpr, AFAICT? See https://eel.is/c++draft/cmp#alg-1 which doesn't mention constexpr either positively or negatively.

Harbormaster completed remote builds in B120466: Diff 367673.Aug 19 2021, 6:51 PM
mumbleskates added inline comments.Aug 29 2021, 3:11 AM
libcxx/include/__compare/cmp_alg.h
49 ↗(On Diff #367673)

Fun cursed fact here, intel 80bit long doubles are also iec559. At least on my skylakex system they have sizeof() 16, have 6 bytes of padding at the end, and otherwise work mostly the same (sign bit at the top, 15 bits of exponent, 63 bits of mantissa in a 64 bit field wherein the MSB is always 1 except when it's sub-normal, and the next highest bit is used for 0=signaling/1=quiet NaN, as the highest bit of the real mantissa). Not completely sure what to do about that!

jloser added a subscriber: jloser.Aug 29 2021, 4:03 PM
jloser added inline comments.
libcxx/include/__compare/cmp_alg.h
45 ↗(On Diff #367673)

Should we use std::same_as and std::floating_point concepts instead? Same applies to other uses ofG type traits that are concepts now as well.

libcxx/test/std/utilities/function.objects/comparisons/compare_three_way.pass.cpp
26

Any reason to prefer this over just return true;? Similarly for the fallback overload (except return false; in that case).

libcxx/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
60

We can drop the empty string second argument if you care.

• Quuxplusone updated this revision to Diff 370834.Sep 5 2021, 6:37 PM
• Quuxplusone edited the summary of this revision. (Show Details)

Rebase on std::bit_cast (D75960), and use std::bit_cast in the implementation of std::strong_order.
Rebase on D103478 (which has been merged now).

Herald added a subscriber: arichardson. · View Herald TranscriptSep 5 2021, 6:37 PM
Harbormaster completed remote builds in B122710: Diff 370834.Sep 5 2021, 7:00 PM
• Quuxplusone updated this revision to Diff 370947.Sep 6 2021, 11:44 AM

Fix std::strong_order for floats, thanks to
https://stackoverflow.com/questions/59348310/how-to-implement-the-totalorder-predicate-for-floating-point-values
https://stackoverflow.com/questions/69068075/what-is-the-purpose-of-if-x-and-y-represent-the-same-floating-point-datum-i
https://quuxplusone.github.io/blog/2021/09/05/float-format/

Add std::weak_order and std::partial_order; they lack testing.

Drive-by fix some minor stuff.

Still unimplemented: std::strong_order_fallback and so on.

Harbormaster completed remote builds in B122787: Diff 370947.Sep 6 2021, 12:06 PM
• Quuxplusone updated this revision to Diff 370978.Sep 6 2021, 5:57 PM

Rebase; incorporate D109331 and further bugfixes to D75960.

Harbormaster completed remote builds in B122812: Diff 370978.Sep 6 2021, 6:19 PM
• Quuxplusone mentioned this in D75960: [libc++] Implement C++20's P0476r2: std::bit_cast.Sep 9 2021, 8:11 AM
• Quuxplusone added inline comments.Nov 18 2021, 4:42 PM
libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp
1

This one test file is the only part of D107036 that hasn't been superseded by D110738 + D111514.
@ldionne or whoever, do you think we care about this test file? Should I open a new PR for it (or repurpose this one)? or should I just close D107036 completely?

ldionne added inline comments.Nov 19 2021, 8:05 AM
libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp
1

I think this test is useful, and I would encourage splitting it into another PR to clear things up a bit. And then we can close this one as it has been superseded.

• Quuxplusone abandoned this revision.Dec 11 2021, 5:25 PM
• Quuxplusone mentioned this in D115588: [libcxx][test] Verify customization point object properties.

The last piece of this (the test) has been superseded by D115588.

jloser mentioned this in D115777: [libcxx][test] Verify customization point object properties.Dec 14 2021, 6:21 PM
• joe_loser mentioned this in rG8dbc7745e55f: [libcxx][test] Verify customization point object properties.Dec 21 2021, 7:13 AM

Revision Contents

PathSize
libcxx/
docs/
2 lines
Status/
4 lines
1 line
include/
6 lines
__bit/
37 lines
__compare/
41 lines
79 lines
142 lines
108 lines
__memory/
10 lines
__ranges/
2 lines
2 lines
__utility/
26 lines
6 lines
25 lines
4 lines
9 lines
1 line
2 lines
test/
libcxx/
diagnostics/
detail.headers/
bit/
16 lines
compare/
16 lines
16 lines
16 lines
16 lines
utility/
16 lines
5 lines
6 lines
utilities/
memory/
pointer.conversion/
8 lines
20 lines
20 lines
std/
language.support/
cmp/
cmp.alg/
448 lines
support.limits/
support.limits.general/
32 lines
32 lines
library/
description/
conventions/
type.descriptions/
customization.point.object/
97 lines
numerics/
bit/
bit.cast/
56 lines
258 lines
utilities/
function.objects/
comparisons/
67 lines
4 lines
memory/
pointer.conversion/
12 lines
22 lines
22 lines
utils/
1 line

Diff 370978

libcxx/docs/FeatureTestMacroTable.rst

Show First 20 Lines • Show All 184 Lines • ▼ Show 20 Lines.. table:: Current Status
``__cpp_lib_atomic_value_initialization`` ``201911L`` ``__cpp_lib_atomic_value_initialization`` ``201911L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_atomic_wait`` ``201907L`` ``__cpp_lib_atomic_wait`` ``201907L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_barrier`` ``201907L`` ``__cpp_lib_barrier`` ``201907L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_bind_front`` ``201907L`` ``__cpp_lib_bind_front`` ``201907L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_bit_cast`` *unimplemented* ``__cpp_lib_bit_cast`` ``201806L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_bitops`` *unimplemented* ``__cpp_lib_bitops`` *unimplemented*
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_bounded_array_traits`` ``201902L`` ``__cpp_lib_bounded_array_traits`` ``201902L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_char8_t`` ``201811L`` ``__cpp_lib_char8_t`` ``201811L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_concepts`` ``202002L`` ``__cpp_lib_concepts`` ``202002L``
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

libcxx/docs/Status/Cxx20Papers.csv

Show All 23 Lines
"`P0809R0 <https://wg21.link/P0809R0>`__","LWG","Comparing Unordered Containers","Jacksonville","|Nothing To Do|","" "`P0809R0 <https://wg21.link/P0809R0>`__","LWG","Comparing Unordered Containers","Jacksonville","|Nothing To Do|",""
"`P0858R0 <https://wg21.link/P0858R0>`__","LWG","Constexpr iterator requirements","Jacksonville","","" "`P0858R0 <https://wg21.link/P0858R0>`__","LWG","Constexpr iterator requirements","Jacksonville","",""
"`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","","" "`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","",""
"`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\ Should Not Shrink","Jacksonville","|Complete| [#note-P0966]_","12.0" "`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\ Should Not Shrink","Jacksonville","|Complete| [#note-P0966]_","12.0"
"","","","","","" "","","","","",""
"`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","","" "`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","",""
"`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|","13.0" "`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|","13.0"
"`P0475R1 <https://wg21.link/P0475R1>`__","LWG","LWG 2511: guaranteed copy elision for piecewise construction","Rapperswil","|Complete|","" "`P0475R1 <https://wg21.link/P0475R1>`__","LWG","LWG 2511: guaranteed copy elision for piecewise construction","Rapperswil","|Complete|",""
"`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","","" "`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","|Complete|","14.0"
"`P0528R3 <https://wg21.link/P0528R3>`__","CWG","The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange","Rapperswil","","" "`P0528R3 <https://wg21.link/P0528R3>`__","CWG","The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange","Rapperswil","",""
"`P0542R5 <https://wg21.link/P0542R5>`__","CWG","Support for contract based programming in C++","Rapperswil","*Removed in Cologne*","n/a" "`P0542R5 <https://wg21.link/P0542R5>`__","CWG","Support for contract based programming in C++","Rapperswil","*Removed in Cologne*","n/a"
"`P0556R3 <https://wg21.link/P0556R3>`__","LWG","Integral power-of-2 operations","Rapperswil","|Complete|","9.0" "`P0556R3 <https://wg21.link/P0556R3>`__","LWG","Integral power-of-2 operations","Rapperswil","|Complete|","9.0"
"`P0619R4 <https://wg21.link/P0619R4>`__","LWG","Reviewing Deprecated Facilities of C++17 for C++20","Rapperswil","|Partial| [#note-P0619]_","" "`P0619R4 <https://wg21.link/P0619R4>`__","LWG","Reviewing Deprecated Facilities of C++17 for C++20","Rapperswil","|Partial| [#note-P0619]_",""
"`P0646R1 <https://wg21.link/P0646R1>`__","LWG","Improving the Return Value of Erase-Like Algorithms","Rapperswil","|Complete|","10.0" "`P0646R1 <https://wg21.link/P0646R1>`__","LWG","Improving the Return Value of Erase-Like Algorithms","Rapperswil","|Complete|","10.0"
"`P0722R3 <https://wg21.link/P0722R3>`__","CWG","Efficient sized delete for variable sized classes","Rapperswil","|Complete|","9.0" "`P0722R3 <https://wg21.link/P0722R3>`__","CWG","Efficient sized delete for variable sized classes","Rapperswil","|Complete|","9.0"
"`P0758R1 <https://wg21.link/P0758R1>`__","LWG","Implicit conversion traits and utility functions","Rapperswil","|Complete|","" "`P0758R1 <https://wg21.link/P0758R1>`__","LWG","Implicit conversion traits and utility functions","Rapperswil","|Complete|",""
"`P0759R1 <https://wg21.link/P0759R1>`__","LWG","fpos Requirements","Rapperswil","|Complete|","11.0" "`P0759R1 <https://wg21.link/P0759R1>`__","LWG","fpos Requirements","Rapperswil","|Complete|","11.0"
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
"`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *","" "`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
"`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0" "`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
"`P2231 <https://wg21.link/P2231>`__","LWG","Missing constexpr in std::optional and std::variant","February 2021","|In progress|","13.0" "`P2231 <https://wg21.link/P2231>`__","LWG","Missing constexpr in std::optional and std::variant","February 2021","|In progress|","13.0"
"`P2325 <https://wg21.link/P2325>`__","LWG","Views should not be required to be default constructible","June 2021","|In progress|","" "`P2325 <https://wg21.link/P2325>`__","LWG","Views should not be required to be default constructible","June 2021","|In progress|",""
"`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","","" "`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","",""
"`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","","" "`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","",""
"`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","","" "`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","",""
"`P2328R1 <https://wg21.link/P2328R1>`__","LWG",join_view should join all views of ranges,"June 2021","","" "`P2328R1 <https://wg21.link/P2328R1>`__","LWG",join_view should join all views of ranges,"June 2021","",""
"`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","","" "`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""
No newline at end of file

libcxx/docs/UsingLibcxx.rst

Show First 20 Lines • Show All 332 Lines • ▼ Show 20 Lines
* ``remove_if`` * ``remove_if``
* ``remove`` * ``remove``
* ``search_n`` * ``search_n``
* ``search`` * ``search``
* ``unique`` * ``unique``
* ``upper_bound`` * ``upper_bound``
* ``lock_guard``'s constructors * ``lock_guard``'s constructors
* ``as_const`` * ``as_const``
* ``bit_cast``
* ``forward`` * ``forward``
* ``move`` * ``move``
* ``move_if_noexcept`` * ``move_if_noexcept``
* ``identity::operator()`` * ``identity::operator()``
* ``to_integer`` * ``to_integer``
* ``to_underlying`` * ``to_underlying``

libcxx/include/CMakeLists.txt

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Linesset(files
__algorithm/swap_ranges.h __algorithm/swap_ranges.h
__algorithm/transform.h __algorithm/transform.h
__algorithm/unique_copy.h __algorithm/unique_copy.h
__algorithm/unique.h __algorithm/unique.h
__algorithm/unwrap_iter.h __algorithm/unwrap_iter.h
__algorithm/upper_bound.h __algorithm/upper_bound.h
__availability __availability
__bit_reference __bit_reference
__bit/bit_cast.h
__bits __bits
__bsd_locale_defaults.h __bsd_locale_defaults.h
__bsd_locale_fallbacks.h __bsd_locale_fallbacks.h
__charconv/chars_format.h __charconv/chars_format.h
__charconv/from_chars_result.h __charconv/from_chars_result.h
__charconv/to_chars_result.h __charconv/to_chars_result.h
__compare/common_comparison_category.h __compare/common_comparison_category.h
__compare/compare_three_way.h
__compare/compare_three_way_result.h __compare/compare_three_way_result.h
__compare/ordering.h __compare/ordering.h
__compare/partial_order.h
__compare/strong_order.h
__compare/three_way_comparable.h __compare/three_way_comparable.h
__compare/weak_order.h
__concepts/arithmetic.h __concepts/arithmetic.h
__concepts/assignable.h __concepts/assignable.h
__concepts/boolean_testable.h __concepts/boolean_testable.h
__concepts/class_or_enum.h __concepts/class_or_enum.h
__concepts/common_reference_with.h __concepts/common_reference_with.h
__concepts/common_with.h __concepts/common_with.h
__concepts/constructible.h __concepts/constructible.h
__concepts/convertible_to.h __concepts/convertible_to.h
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Linesset(files
__utility/declval.h __utility/declval.h
__utility/exchange.h __utility/exchange.h
__utility/forward.h __utility/forward.h
__utility/in_place.h __utility/in_place.h
__utility/integer_sequence.h __utility/integer_sequence.h
__utility/move.h __utility/move.h
__utility/pair.h __utility/pair.h
__utility/piecewise_construct.h __utility/piecewise_construct.h
__utility/priority_tag.h
__utility/rel_ops.h __utility/rel_ops.h
__utility/swap.h __utility/swap.h
__utility/to_underlying.h __utility/to_underlying.h
__variant/monostate.h __variant/monostate.h
algorithm algorithm
any any
array array
atomic atomic
▲ Show 20 Lines • Show All 191 Lines • Show Last 20 Lines

libcxx/include/__bit/bit_cast.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___BIT_BIT_CAST_H
#define _LIBCPP___BIT_BIT_CAST_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17
template<class _ToType, class _FromType, class = _EnableIf<
sizeof(_ToType) == sizeof(_FromType) &&
is_trivially_copyable_v<_ToType> &&
is_trivially_copyable_v<_FromType>
>>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
constexpr _ToType bit_cast(_FromType const& __from) noexcept {
return __builtin_bit_cast(_ToType, __from);
}
#endif // _LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___BIT_BIT_CAST_H

libcxx/include/__compare/compare_three_way.h

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
#define _LIBCPP___COMPARE_COMPARE_THREE_WAY_H
#include <__config>
#include <__compare/three_way_comparable.h>
#include <__utility/forward.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
struct _LIBCPP_TEMPLATE_VIS compare_three_way
{
template<class _T1, class _T2>
requires three_way_comparable_with<_T1, _T2>
constexpr _LIBCPP_INLINE_VISIBILITY
auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u)))
{ return _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); }
using is_transparent = void;
};
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H

libcxx/include/__compare/partial_order.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_PARTIAL_ORDER
#define _LIBCPP___COMPARE_PARTIAL_ORDER
#include <__compare/compare_three_way.h>
#include <__compare/ordering.h>
#include <__compare/weak_order.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
// [cmp.alg]
namespace __partial_order {
struct __fn {
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<2>)
noexcept(noexcept( partial_ordering(partial_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( partial_ordering(partial_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return partial_ordering(partial_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<1>)
noexcept(noexcept( partial_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( partial_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return partial_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<0>)
noexcept(noexcept( partial_ordering(_VSTD::weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( partial_ordering(_VSTD::weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return partial_ordering(_VSTD::weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ep&& __e, _Fp&& __f) const
noexcept(noexcept( __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>()) ))
-> decltype( __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>()) )
{
return __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>());
}
};
} // namespace __partial_order
inline namespace __cpo {
inline constexpr auto partial_order = __partial_order::__fn{};
} // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_PARTIAL_ORDER

libcxx/include/__compare/strong_order.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_STRONG_ORDER
#define _LIBCPP___COMPARE_STRONG_ORDER
#include <__bit/bit_cast.h>
#include <__compare/compare_three_way.h>
#include <__compare/ordering.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <cmath>
#include <cstdint>
#include <limits>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_PUSH_MACROS
#include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
// [cmp.alg]
namespace __strong_order {
struct __fn {
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<2>)
noexcept(noexcept( strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return strong_ordering(strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp, class _Dp = decay_t<_Ep>>
requires is_same_v<_Dp, decay_t<_Fp>> && is_floating_point_v<_Dp>
_LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<1>) noexcept
{
if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int32_t)) {
int32_t __rx = _VSTD::bit_cast<int32_t>(__e);
int32_t __ry = _VSTD::bit_cast<int32_t>(__f);
__rx = (__rx < 0) ? (numeric_limits<int32_t>::min() - __rx - 1) : __rx;
__ry = (__ry < 0) ? (numeric_limits<int32_t>::min() - __ry - 1) : __ry;
return (__rx <=> __ry);
} else if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int64_t)) {
int64_t __rx = _VSTD::bit_cast<int64_t>(__e);
int64_t __ry = _VSTD::bit_cast<int64_t>(__f);
__rx = (__rx < 0) ? (numeric_limits<int64_t>::min() - __rx - 1) : __rx;
__ry = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry;
return (__rx <=> __ry);
} else if (__e < __f) {
return strong_ordering::less;
} else if (__e > __f) {
return strong_ordering::greater;
} else if (__e == __f) {
if constexpr (numeric_limits<_Dp>::radix == 2) {
return _VSTD::signbit(__f) <=> _VSTD::signbit(__e);
} else {
// This is bullet 3 of the IEEE754 algorithm, relevant
// only for decimal floating-point;
// see https://stackoverflow.com/questions/69068075/
if (__e == 0 || _VSTD::isinf(__e)) {
return _VSTD::signbit(__f) <=> _VSTD::signbit(__e);
} else {
int __eexp, __fexp;
(void)_VSTD::frexp(__e, &__eexp);
(void)_VSTD::frexp(__f, &__fexp);
return (__e < 0) ? (__eexp <=> __fexp) : (__fexp <=> __eexp);
}
}
} else {
// They're unordered, so one of them must be a NAN.
// The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
bool __e_is_nan = _VSTD::isnan(__e);
bool __f_is_nan = _VSTD::isnan(__f);
bool __e_is_negative = _VSTD::signbit(__e);
bool __f_is_negative = _VSTD::signbit(__f);
using _IntType = std::conditional_t<
sizeof(__e) == sizeof(int), int, std::conditional_t<
sizeof(__e) == sizeof(long), long, std::conditional_t<
sizeof(__e) == sizeof(long long), long long, void>>
>;
static_assert(!std::is_same_v<_IntType, void>, "std::strong_order is unimplemented for this floating-point type");
if (__e_is_nan && __f_is_nan) {
// Order by sign bit, then by "payload bits" (we'll just use bit_cast).
if (__e_is_negative != __f_is_negative) {
return (__f_is_negative <=> __e_is_negative);
} else {
return _VSTD::bit_cast<_IntType>(__e) <=> _VSTD::bit_cast<_IntType>(__f);
}
} else if (__e_is_nan) {
return __e_is_negative ? strong_ordering::less : strong_ordering::greater;
} else {
return __f_is_negative ? strong_ordering::greater : strong_ordering::less;
}
}
}
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<0>)
noexcept(noexcept( strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return strong_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ep&& __e, _Fp&& __f) const
noexcept(noexcept( __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>()) ))
-> decltype( __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>()) )
{
return __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<2>());
}
};
} // namespace __strong_order
inline namespace __cpo {
inline constexpr auto strong_order = __strong_order::__fn{};
} // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
#endif // _LIBCPP___COMPARE_STRONG_ORDER

libcxx/include/__compare/weak_order.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_WEAK_ORDER
#define _LIBCPP___COMPARE_WEAK_ORDER
#include <__compare/compare_three_way.h>
#include <__compare/ordering.h>
#include <__compare/strong_order.h>
#include <__config>
#include <__utility/forward.h>
#include <__utility/priority_tag.h>
#include <cmath>
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
// [cmp.alg]
namespace __weak_order {
struct __fn {
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<3>)
noexcept(noexcept( weak_ordering(weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( weak_ordering(weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return weak_ordering(weak_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp, class _Dp = decay_t<_Ep>>
requires is_same_v<_Dp, decay_t<_Fp>> && is_floating_point_v<_Dp>
_LIBCPP_HIDE_FROM_ABI static constexpr weak_ordering
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<2>) noexcept
{
std::partial_ordering __po = (__e <=> __f);
if (__po == std::partial_ordering::less) {
return std::weak_ordering::less;
} else if (__po == std::partial_ordering::equivalent) {
return std::weak_ordering::equivalent;
} else if (__po == std::partial_ordering::greater) {
return std::weak_ordering::greater;
} else {
// Otherwise, at least one of them is a NaN.
bool __e_is_nan = _VSTD::isnan(__e);
bool __f_is_nan = _VSTD::isnan(__f);
bool __e_is_negative = _VSTD::signbit(__e);
bool __f_is_negative = _VSTD::signbit(__f);
if (__e_is_nan && __f_is_nan) {
return (__f_is_negative <=> __e_is_negative);
} else if (__e_is_nan) {
return __e_is_negative ? weak_ordering::less : weak_ordering::greater;
} else {
return __f_is_negative ? weak_ordering::greater : weak_ordering::less;
}
}
}
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<1>)
noexcept(noexcept( weak_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( weak_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return weak_ordering(compare_three_way()(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp>
requires is_same_v<decay_t<_Ep>, decay_t<_Fp>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Ep&& __e, _Fp&& __f, _PriorityTag<0>)
noexcept(noexcept( weak_ordering(_VSTD::strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) ))
-> decltype( weak_ordering(_VSTD::strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f))) )
{
return weak_ordering(_VSTD::strong_order(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f)));
}
template<class _Ep, class _Fp>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ep&& __e, _Fp&& __f) const
noexcept(noexcept( __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<3>()) ))
-> decltype( __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<3>()) )
{
return __go(_VSTD::forward<_Ep>(__e), _VSTD::forward<_Fp>(__f), _PriorityTag<3>());
}
};
} // namespace __weak_order
inline namespace __cpo {
inline constexpr auto weak_order = __weak_order::__fn{};
} // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_WEAK_ORDER

libcxx/include/__memory/pointer_traits.h

Show First 20 Lines • Show All 167 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
_Tp* __to_address(_Tp* __p) _NOEXCEPT { _Tp* __to_address(_Tp* __p) _NOEXCEPT {
static_assert(!is_function<_Tp>::value, "_Tp is a function type"); static_assert(!is_function<_Tp>::value, "_Tp is a function type");
return __p; return __p;
} }
// enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers // enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers
template <class _Pointer, class = _EnableIf<!is_pointer<_Pointer>::value> > template <class _Pointer, class = _EnableIf<
!is_pointer<_Pointer>::value && !is_array<_Pointer>::value && !is_function<_Pointer>::value
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename decay<decltype(__to_address_helper<_Pointer>::__call(declval<const _Pointer&>()))>::type typename decay<decltype(__to_address_helper<_Pointer>::__call(declval<const _Pointer&>()))>::type
__to_address(const _Pointer& __p) _NOEXCEPT { __to_address(const _Pointer& __p) _NOEXCEPT {
return __to_address_helper<_Pointer>::__call(__p); return __to_address_helper<_Pointer>::__call(__p);
} }
template <class _Pointer, class> template <class _Pointer, class>
struct __to_address_helper { struct __to_address_helper {
Show All 9 Linesstruct __to_address_helper<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))> {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
static decltype(pointer_traits<_Pointer>::to_address(declval<const _Pointer&>())) static decltype(pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))
__call(const _Pointer& __p) _NOEXCEPT { __call(const _Pointer& __p) _NOEXCEPT {
return pointer_traits<_Pointer>::to_address(__p); return pointer_traits<_Pointer>::to_address(__p);
} }
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY constexpr
auto to_address(_Tp *__p) noexcept {
return _VSTD::__to_address(__p);
}
template <class _Pointer> template <class _Pointer>
inline _LIBCPP_INLINE_VISIBILITY constexpr inline _LIBCPP_INLINE_VISIBILITY constexpr
auto to_address(const _Pointer& __p) noexcept { auto to_address(const _Pointer& __p) noexcept {
return _VSTD::__to_address(__p); return _VSTD::__to_address(__p);
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_POINTER_TRAITS_H #endif // _LIBCPP___MEMORY_POINTER_TRAITS_H

libcxx/include/__ranges/data.h

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines struct __fn {
constexpr __ptr_to_object auto operator()(_Tp&& __t) const constexpr __ptr_to_object auto operator()(_Tp&& __t) const
noexcept(noexcept(_VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t))))) { noexcept(noexcept(_VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t))))) {
return _VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t))); return _VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t)));
} }
}; };
} // end namespace __data } // end namespace __data
inline namespace __cpo { inline namespace __cpo {
inline constexpr const auto data = __data::__fn{}; inline constexpr auto data = __data::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
// clang-format off // clang-format off
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_RANGES)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_DATA_H #endif // _LIBCPP___RANGES_DATA_H

libcxx/include/__ranges/size.h

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
return static_cast<ptrdiff_t>(ranges::size(__t)); return static_cast<ptrdiff_t>(ranges::size(__t));
else else
return static_cast<_Signed>(ranges::size(__t)); return static_cast<_Signed>(ranges::size(__t));
} }
}; };
} }
inline namespace __cpo { inline namespace __cpo {
inline constexpr const auto ssize = __ssize::__fn{}; inline constexpr auto ssize = __ssize::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
// clang-format off // clang-format off
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_RANGES)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_SIZE_H #endif // _LIBCPP___RANGES_SIZE_H

libcxx/include/__utility/priority_tag.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___UTILITY_PRIORITY_TAG_H
#define _LIBCPP___UTILITY_PRIORITY_TAG_H
#include <__config>
#include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
template<size_t _Ip> struct _PriorityTag : _PriorityTag<_Ip - 1> {};
template<> struct _PriorityTag<0> {};
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_PRIORITY_TAG_H

libcxx/include/bit

// -*- C++ -*- // -*- C++ -*-
//===------------------------------ bit ----------------------------------===// //===------------------------------ bit ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
#ifndef _LIBCPP_BIT #ifndef _LIBCPP_BIT
#define _LIBCPP_BIT #define _LIBCPP_BIT
/* /*
bit synopsis bit synopsis
namespace std { namespace std {
// [bit.cast], bit_cast
template<class To, class From>
constexpr To bit_cast(const From& from) noexcept; // C++20
// [bit.pow.two], integral powers of 2 // [bit.pow.two], integral powers of 2
template <class T> template <class T>
constexpr bool has_single_bit(T x) noexcept; // C++20 constexpr bool has_single_bit(T x) noexcept; // C++20
template <class T> template <class T>
constexpr T bit_ceil(T x); // C++20 constexpr T bit_ceil(T x); // C++20
template <class T> template <class T>
constexpr T bit_floor(T x) noexcept; // C++20 constexpr T bit_floor(T x) noexcept; // C++20
Show All 24 Lines enum class endian {
big = see below, // C++20 big = see below, // C++20
native = see below // C++20 native = see below // C++20
}; };
} // namespace std } // namespace std
*/ */
#include <__config> #include <__bit/bit_cast.h>
#include <__bits> // __libcpp_clz #include <__bits> // __libcpp_clz
#include <__config>
#include <__debug> #include <__debug>
#include <limits> #include <limits>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#if defined(__IBMCPP__) #if defined(__IBMCPP__)
#include "__support/ibm/support.h" #include "__support/ibm/support.h"
#endif #endif
▲ Show 20 Lines • Show All 275 Lines • Show Last 20 Lines

libcxx/include/compare

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines template<class T, class U, class Cat = partial_ordering>
concept three_way_comparable_with = see below; concept three_way_comparable_with = see below;
// [cmp.result], result of three-way comparison // [cmp.result], result of three-way comparison
template<class T, class U = T> struct compare_three_way_result; template<class T, class U = T> struct compare_three_way_result;
template<class T, class U = T> template<class T, class U = T>
using compare_three_way_result_t = typename compare_three_way_result<T, U>::type; using compare_three_way_result_t = typename compare_three_way_result<T, U>::type;
// [comparisons.three.way], class compare_three_way
struct compare_three_way;
// [cmp.alg], comparison algorithms // [cmp.alg], comparison algorithms
template<class T> constexpr strong_ordering strong_order(const T& a, const T& b); template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
template<class T> constexpr weak_ordering weak_order(const T& a, const T& b); template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
template<class T> constexpr partial_ordering partial_order(const T& a, const T& b); template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
// [cmp.partialord], Class partial_ordering // [cmp.partialord], Class partial_ordering
class partial_ordering { class partial_ordering {
public: public:
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines public:
friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept; friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept; friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept; friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
}; };
} }
*/ */
#include <__compare/common_comparison_category.h> #include <__compare/common_comparison_category.h>
#include <__compare/compare_three_way.h>
#include <__compare/compare_three_way_result.h> #include <__compare/compare_three_way_result.h>
#include <__compare/ordering.h> #include <__compare/ordering.h>
#include <__compare/partial_order.h>
#include <__compare/strong_order.h>
#include <__compare/three_way_comparable.h> #include <__compare/three_way_comparable.h>
#include <__compare/weak_order.h>
#include <__config> #include <__config>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
// [cmp.alg], comparison algorithms
// TODO: unimplemented
template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_COMPARE #endif // _LIBCPP_COMPARE

libcxx/include/functional

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Linesstruct greater_equal {
bool operator()(const T& x, const T& y) const; bool operator()(const T& x, const T& y) const;
}; };
template <class T> // <class T=void> in C++14 template <class T> // <class T=void> in C++14
struct less_equal { struct less_equal {
bool operator()(const T& x, const T& y) const; bool operator()(const T& x, const T& y) const;
}; };
// [comparisons.three.way], class compare_three_way
struct compare_three_way;
template <class T> // <class T=void> in C++14 template <class T> // <class T=void> in C++14
struct logical_and { struct logical_and {
bool operator()(const T& x, const T& y) const; bool operator()(const T& x, const T& y) const;
}; };
template <class T> // <class T=void> in C++14 template <class T> // <class T=void> in C++14
struct logical_or { struct logical_or {
bool operator()(const T& x, const T& y) const; bool operator()(const T& x, const T& y) const;
▲ Show 20 Lines • Show All 337 Lines • ▼ Show 20 Lines
POLICY: For non-variadic implementations, the number of arguments is limited POLICY: For non-variadic implementations, the number of arguments is limited
to 3. It is hoped that the need for non-variadic implementations to 3. It is hoped that the need for non-variadic implementations
will be minimal. will be minimal.
*/ */
#include <__algorithm/search.h> #include <__algorithm/search.h>
#include <__compare/compare_three_way.h>
#include <__config> #include <__config>
#include <__debug> #include <__debug>
#include <__functional/binary_function.h> // TODO: deprecate #include <__functional/binary_function.h> // TODO: deprecate
#include <__functional/binary_negate.h> #include <__functional/binary_negate.h>
#include <__functional/bind_back.h> #include <__functional/bind_back.h>
#include <__functional/bind_front.h> #include <__functional/bind_front.h>
#include <__functional/bind.h> #include <__functional/bind.h>
#include <__functional/binder1st.h> #include <__functional/binder1st.h>
Show All 33 Lines

libcxx/include/module.modulemap

Show First 20 Lines • Show All 329 Lines • ▼ Show 20 Linesmodule std [system] {
module barrier { module barrier {
requires cplusplus14 requires cplusplus14
header "barrier" header "barrier"
export * export *
} }
module bit { module bit {
header "bit" header "bit"
export * export *
module __bit {
module bit_cast { private header "__bit/bit_cast.h" }
}
} }
module bitset { module bitset {
header "bitset" header "bitset"
export string export string
export iosfwd export iosfwd
export * export *
} }
// No submodule for cassert. It fundamentally needs repeated, textual inclusion. // No submodule for cassert. It fundamentally needs repeated, textual inclusion.
Show All 17 Lines module codecvt {
export * export *
} }
module compare { module compare {
header "compare" header "compare"
export * export *
module __compare { module __compare {
module common_comparison_category { private header "__compare/common_comparison_category.h" } module common_comparison_category { private header "__compare/common_comparison_category.h" }
module compare_three_way { private header "__compare/compare_three_way.h" }
module compare_three_way_result { private header "__compare/compare_three_way_result.h" } module compare_three_way_result { private header "__compare/compare_three_way_result.h" }
module ordering { private header "__compare/ordering.h" } module ordering { private header "__compare/ordering.h" }
module partial_order { private header "__compare/partial_order.h" }
module strong_order { private header "__compare/strong_order.h" }
module three_way_comparable { private header "__compare/three_way_comparable.h" } module three_way_comparable { private header "__compare/three_way_comparable.h" }
module weak_order { private header "__compare/weak_order.h" }
} }
} }
module complex { module complex {
header "complex" header "complex"
export * export *
} }
module concepts { module concepts {
header "concepts" header "concepts"
▲ Show 20 Lines • Show All 431 Lines • ▼ Show 20 Lines module __utility {
module declval { private header "__utility/declval.h" } module declval { private header "__utility/declval.h" }
module exchange { private header "__utility/exchange.h" } module exchange { private header "__utility/exchange.h" }
module forward { private header "__utility/forward.h" } module forward { private header "__utility/forward.h" }
module in_place { private header "__utility/in_place.h" } module in_place { private header "__utility/in_place.h" }
module integer_sequence { private header "__utility/integer_sequence.h" } module integer_sequence { private header "__utility/integer_sequence.h" }
module move { private header "__utility/move.h" } module move { private header "__utility/move.h" }
module pair { private header "__utility/pair.h" } module pair { private header "__utility/pair.h" }
module piecewise_construct { private header "__utility/piecewise_construct.h" } module piecewise_construct { private header "__utility/piecewise_construct.h" }
module priority_tag { private header "__utility/priority_tag.h" }
module rel_ops { private header "__utility/rel_ops.h" } module rel_ops { private header "__utility/rel_ops.h" }
module swap { private header "__utility/swap.h" } module swap { private header "__utility/swap.h" }
module to_underlying { private header "__utility/to_underlying.h" } module to_underlying { private header "__utility/to_underlying.h" }
} }
} }
module valarray { module valarray {
header "valarray" header "valarray"
export initializer_list export initializer_list
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

libcxx/include/utility

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
#include <__utility/declval.h> #include <__utility/declval.h>
#include <__utility/exchange.h> #include <__utility/exchange.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/in_place.h> #include <__utility/in_place.h>
#include <__utility/integer_sequence.h> #include <__utility/integer_sequence.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.h>
#include <__utility/piecewise_construct.h> #include <__utility/piecewise_construct.h>
#include <__utility/priority_tag.h>
#include <__utility/rel_ops.h> #include <__utility/rel_ops.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <__utility/to_underlying.h> #include <__utility/to_underlying.h>
#include <compare> #include <compare>
#include <initializer_list> #include <initializer_list>
#include <version> #include <version>
#endif // _LIBCPP_UTILITY #endif // _LIBCPP_UTILITY

libcxx/include/version

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Lines
# endif # endif
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait) # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
# define __cpp_lib_atomic_wait 201907L # define __cpp_lib_atomic_wait 201907L
# endif # endif
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier) # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
# define __cpp_lib_barrier 201907L # define __cpp_lib_barrier 201907L
# endif # endif
# define __cpp_lib_bind_front 201907L # define __cpp_lib_bind_front 201907L
// # define __cpp_lib_bit_cast 201806L # define __cpp_lib_bit_cast 201806L
// # define __cpp_lib_bitops 201907L // # define __cpp_lib_bitops 201907L
# define __cpp_lib_bounded_array_traits 201902L # define __cpp_lib_bounded_array_traits 201902L
# if !defined(_LIBCPP_HAS_NO_CHAR8_T) # if !defined(_LIBCPP_HAS_NO_CHAR8_T)
# define __cpp_lib_char8_t 201811L # define __cpp_lib_char8_t 201811L
# endif # endif
# define __cpp_lib_concepts 202002L # define __cpp_lib_concepts 202002L
# define __cpp_lib_constexpr_algorithms 201806L # define __cpp_lib_constexpr_algorithms 201806L
// # define __cpp_lib_constexpr_complex 201711L // # define __cpp_lib_constexpr_complex 201711L
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

libcxx/test/libcxx/diagnostics/detail.headers/bit/bit_cast.module.verify.cpp

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__bit/bit_cast.h'}}
#include <__bit/bit_cast.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/compare_three_way.module.verify.cpp

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__compare/compare_three_way.h'}}
#include <__compare/compare_three_way.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/partial_order.module.verify.cpp

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__compare/partial_order.h'}}
#include <__compare/partial_order.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/strong_order.module.verify.cpp

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__compare/strong_order.h'}}
#include <__compare/strong_order.h>

libcxx/test/libcxx/diagnostics/detail.headers/compare/weak_order.module.verify.cpp

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__compare/weak_order.h'}}
#include <__compare/weak_order.h>

libcxx/test/libcxx/diagnostics/detail.headers/utility/priority_tag.module.verify.cpp

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__utility/priority_tag.h'}}
#include <__utility/priority_tag.h>

libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp

Show All 12 Lines
// This test intentionally leaks memory, so it is unsupported under ASAN. // This test intentionally leaks memory, so it is unsupported under ASAN.
// UNSUPPORTED: asan // UNSUPPORTED: asan
// All entities to which libc++ applies [[nodiscard]] as an extension should // All entities to which libc++ applies [[nodiscard]] as an extension should
// be tested here and in nodiscard_extensions.fail.cpp. They should also // be tested here and in nodiscard_extensions.fail.cpp. They should also
// be listed in `UsingLibcxx.rst` in the documentation for the extension. // be listed in `UsingLibcxx.rst` in the documentation for the extension.
#include <algorithm> #include <algorithm>
#include <bit> // bit_cast
#include <cstddef> // to_integer #include <cstddef> // to_integer
#include <functional> // identity #include <functional> // identity
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <utility> // to_underlying #include <utility> // to_underlying
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines
void test_nontemplate_cast_wrappers() void test_nontemplate_cast_wrappers()
{ {
#if TEST_STD_VER >= 17 #if TEST_STD_VER >= 17
std::byte b{42}; std::byte b{42};
std::to_integer<int>(b); std::to_integer<int>(b);
#endif #endif
#if TEST_STD_VER >= 20 #if TEST_STD_VER > 17
// std::bit_cast<unsigned int>(42); std::bit_cast<unsigned int>(42);
#endif #endif
#if TEST_STD_VER > 20 #if TEST_STD_VER > 20
enum E { Apple, Orange } e = Apple; enum E { Apple, Orange } e = Apple;
std::to_underlying(e); std::to_underlying(e);
#endif #endif
} }
Show All 9 Lines

libcxx/test/libcxx/diagnostics/nodiscard_extensions.verify.cpp

Show All 13 Lines
// All entities to which libc++ applies [[nodiscard]] as an extension should // All entities to which libc++ applies [[nodiscard]] as an extension should
// be tested here and in nodiscard_extensions.pass.cpp. They should also // be tested here and in nodiscard_extensions.pass.cpp. They should also
// be listed in `UsingLibcxx.rst` in the documentation for the extension. // be listed in `UsingLibcxx.rst` in the documentation for the extension.
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_NODISCARD // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_NODISCARD
#include <algorithm> #include <algorithm>
#include <bit> // bit_cast
#include <cstddef> // to_integer #include <cstddef> // to_integer
#include <functional> // identity #include <functional> // identity
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <utility> // to_underlying #include <utility> // to_underlying
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 294 Lines • ▼ Show 20 Lines
void test_nontemplate_cast_wrappers() void test_nontemplate_cast_wrappers()
{ {
#if TEST_STD_VER >= 17 #if TEST_STD_VER >= 17
std::byte b{42}; std::byte b{42};
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
std::to_integer<int>(b); std::to_integer<int>(b);
#endif #endif
#if TEST_STD_VER >= 20 #if TEST_STD_VER > 17
// std::bit_cast<unsigned int>(42); // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
std::bit_cast<unsigned int>(42);
#endif #endif
#if TEST_STD_VER > 20 #if TEST_STD_VER > 20
enum E { Apple, Orange } e = Apple; enum E { Apple, Orange } e = Apple;
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
std::to_underlying(e); std::to_underlying(e);
#endif #endif
} }
Show All 10 Lines

libcxx/test/libcxx/utilities/memory/pointer.conversion/to_address.pass.cpp

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 LinesTEST_CONSTEXPR_CXX14 bool test() {
P8::FancyPtrA<Holder<Incomplete> > p8a = p8_nil; P8::FancyPtrA<Holder<Incomplete> > p8a = p8_nil;
assert(std::__to_address(p8a) == p8_nil); assert(std::__to_address(p8a) == p8_nil);
ASSERT_SAME_TYPE(decltype(std::__to_address(p8a)), decltype(p8_nil)); ASSERT_SAME_TYPE(decltype(std::__to_address(p8a)), decltype(p8_nil));
P8::FancyPtrB<Holder<Incomplete> > p8b = p8_nil; P8::FancyPtrB<Holder<Incomplete> > p8b = p8_nil;
assert(std::__to_address(p8b) == p8_nil); assert(std::__to_address(p8b) == p8_nil);
ASSERT_SAME_TYPE(decltype(std::__to_address(p8b)), decltype(p8_nil)); ASSERT_SAME_TYPE(decltype(std::__to_address(p8b)), decltype(p8_nil));
int p9[2] = {};
assert(std::__to_address(p9) == p9);
ASSERT_SAME_TYPE(decltype(std::__to_address(p9)), int*);
const int p10[2] = {};
assert(std::__to_address(p10) == p10);
ASSERT_SAME_TYPE(decltype(std::__to_address(p10)), const int*);
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
#if TEST_STD_VER >= 14 #if TEST_STD_VER >= 14
static_assert(test(), ""); static_assert(test(), "");
#endif #endif
return 0; return 0;
} }

libcxx/test/libcxx/utilities/memory/pointer.conversion/to_address_on_funcptr.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <memory>
// template <class T> constexpr T* __to_address(T* p) noexcept;
// Mandates: T is not a function type.
#include <memory>
int (*pf)();
void test() {
(void)std::__to_address(pf); // expected-error@*:* {{is a function type}}
}

libcxx/test/libcxx/utilities/memory/pointer.conversion/to_address_on_function.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <memory>
// template <class T> constexpr T* __to_address(T* p) noexcept;
// Mandates: T is not a function type.
#include <memory>
int f();
void test() {
(void)std::__to_address(f); // expected-error@*:* {{is a function type}}
}

libcxx/test/std/language.support/cmp/cmp.alg/strong_order.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <compare>
// class strong_ordering
#include <compare>
#include <cassert>
#include <cmath>
#include <iterator> // std::size
#include <limits>
#include <type_traits>
#include <utility>
#include "test_macros.h"
template<class T, class U>
constexpr auto has_strong_order(T&& t, U&& u)
-> decltype(std::strong_order(static_cast<T&&>(t), static_cast<U&&>(u)), true)
{
return true;
}
constexpr bool has_strong_order(...) {
return false;
}
namespace N11 {
struct A {};
struct B {};
std::strong_ordering strong_order(const A&, const A&) { return std::strong_ordering::less; }
std::strong_ordering strong_order(const A&, const B&);
}
void test_1_1()
{
// If the decayed types of E and F differ, strong_order(E, F) is ill-formed.
static_assert( has_strong_order(1, 2));
static_assert(!has_strong_order(1, (short)2));
static_assert(!has_strong_order(1, 2.0));
static_assert(!has_strong_order(1.0f, 2.0));
static_assert( has_strong_order((int*)nullptr, (int*)nullptr));
static_assert(!has_strong_order((int*)nullptr, (const int*)nullptr));
static_assert(!has_strong_order((const int*)nullptr, (int*)nullptr));
static_assert( has_strong_order((const int*)nullptr, (const int*)nullptr));
N11::A a;
N11::B b;
static_assert( has_strong_order(a, a));
static_assert(!has_strong_order(a, b));
}
namespace N12 {
struct A {};
std::strong_ordering strong_order(A&, A&&) { return std::strong_ordering::less; }
std::strong_ordering strong_order(A&&, A&&) { return std::strong_ordering::equal; }
std::strong_ordering strong_order(const A&, const A&);
struct B {
friend std::weak_ordering strong_order(B&, B&);
};
struct Order {
explicit operator std::strong_ordering() const { return std::strong_ordering::less; }
};
struct C {
bool touched = false;
friend Order strong_order(C& lhs, C&) { lhs.touched = true; return Order(); }
};
}
void test_1_2()
{
// Otherwise, strong_ordering(strong_order(E, F))
// if it is a well-formed expression with overload resolution performed
// in a context that does not include a declaration of std::strong_order.
// Test that strong_order does not const-qualify the forwarded arguments.
N12::A a;
assert(std::strong_order(a, std::move(a)) == std::strong_ordering::less);
assert(std::strong_order(std::move(a), std::move(a)) == std::strong_ordering::equal);
// The type of strong_order(e,f) must be explicitly convertible to strong_order.
N12::B b;
static_assert(!has_strong_order(b, b));
N12::C c1, c2;
ASSERT_SAME_TYPE(decltype(std::strong_order(c1, c2)), std::strong_ordering);
assert(std::strong_order(c1, c2) == std::strong_ordering::less);
assert(c1.touched);
assert(!c2.touched);
}
template<class F>
constexpr bool test_1_3()
{
// Otherwise, if the decayed type T of E is a floating-point type,
// yields a value of type strong_ordering that is consistent with
// the ordering observed by T's comparison operators,
// and if numeric_limits<T>::is_iec559 is true, is additionally consistent with
// the totalOrder operation as specified in ISO/IEC/IEEE 60559.
static_assert(std::numeric_limits<F>::is_iec559);
ASSERT_SAME_TYPE(decltype(std::strong_order(F(0), F(0))), std::strong_ordering);
F v[] = {
-std::numeric_limits<F>::infinity(),
std::numeric_limits<F>::lowest(), // largest (finite) negative number
F(-1.0), F(-0.1),
-std::numeric_limits<F>::min(), // smallest (normal) negative number
F(-0.0), // negative zero
F(0.0),
std::numeric_limits<F>::min(), // smallest (normal) positive number
F(0.1), F(1.0), F(2.0), F(3.14),
std::numeric_limits<F>::max(), // largest (finite) positive number
std::numeric_limits<F>::infinity(),
};
static_assert(std::size(v) == 14);
// Sanity-check that array 'v' is indeed in the right order.
for (int i=0; i < 14; ++i) {
for (int j=0; j < 14; ++j) {
auto naturalOrder = (v[i] <=> v[j]);
if (v[i] == 0 && v[j] == 0) {
assert(naturalOrder == std::partial_ordering::equivalent);
} else {
assert(naturalOrder == std::partial_ordering::unordered || naturalOrder == (i <=> j));
}
}
}
assert(std::strong_order(v[0], v[0]) == std::strong_ordering::equal);
assert(std::strong_order(v[0], v[1]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[2]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[3]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[4]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[5]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[6]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[7]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[0], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[1], v[1]) == std::strong_ordering::equal);
assert(std::strong_order(v[1], v[2]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[3]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[4]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[5]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[6]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[7]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[1], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[2], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[2], v[2]) == std::strong_ordering::equal);
assert(std::strong_order(v[2], v[3]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[4]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[5]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[6]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[7]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[2], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[3], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[3], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[3], v[3]) == std::strong_ordering::equal);
assert(std::strong_order(v[3], v[4]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[5]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[6]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[7]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[3], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[4], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[4], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[4], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[4], v[4]) == std::strong_ordering::equal);
assert(std::strong_order(v[4], v[5]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[6]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[7]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[4], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[5], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[5], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[5], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[5], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[5], v[5]) == std::strong_ordering::equal);
assert(std::strong_order(v[5], v[6]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[7]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[5], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[6], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[6], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[6], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[6], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[6], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[6], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[6], v[6]) == std::strong_ordering::equal);
assert(std::strong_order(v[6], v[7]) == std::strong_ordering::less);
assert(std::strong_order(v[6], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[6], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[6], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[6], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[6], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[6], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[7], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[7], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[7], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[7], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[7], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[7], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[7], v[6]) == std::strong_ordering::greater);
assert(std::strong_order(v[7], v[7]) == std::strong_ordering::equal);
assert(std::strong_order(v[7], v[8]) == std::strong_ordering::less);
assert(std::strong_order(v[7], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[7], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[7], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[7], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[7], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[8], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[6]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[7]) == std::strong_ordering::greater);
assert(std::strong_order(v[8], v[8]) == std::strong_ordering::equal);
assert(std::strong_order(v[8], v[9]) == std::strong_ordering::less);
assert(std::strong_order(v[8], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[8], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[8], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[8], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[9], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[6]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[7]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[8]) == std::strong_ordering::greater);
assert(std::strong_order(v[9], v[9]) == std::strong_ordering::equal);
assert(std::strong_order(v[9], v[10]) == std::strong_ordering::less);
assert(std::strong_order(v[9], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[9], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[9], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[10], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[6]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[7]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[8]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[9]) == std::strong_ordering::greater);
assert(std::strong_order(v[10], v[10]) == std::strong_ordering::equal);
assert(std::strong_order(v[10], v[11]) == std::strong_ordering::less);
assert(std::strong_order(v[10], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[10], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[11], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[6]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[7]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[8]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[9]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[10]) == std::strong_ordering::greater);
assert(std::strong_order(v[11], v[11]) == std::strong_ordering::equal);
assert(std::strong_order(v[11], v[12]) == std::strong_ordering::less);
assert(std::strong_order(v[11], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[12], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[6]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[7]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[8]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[9]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[10]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[11]) == std::strong_ordering::greater);
assert(std::strong_order(v[12], v[12]) == std::strong_ordering::equal);
assert(std::strong_order(v[12], v[13]) == std::strong_ordering::less);
assert(std::strong_order(v[13], v[0]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[1]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[2]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[3]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[4]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[5]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[6]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[7]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[8]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[9]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[10]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[11]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[12]) == std::strong_ordering::greater);
assert(std::strong_order(v[13], v[13]) == std::strong_ordering::equal);
// There's no way to produce a specifically positive or negative NAN
// at compile-time, so the NAN-related tests must be runtime-only.
if (!std::is_constant_evaluated()) {
F nq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
F ns = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
F ps = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
F pq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
assert(std::strong_order(nq, nq) == std::strong_ordering::equal);
assert(std::strong_order(nq, ns) == std::strong_ordering::less);
for (int i=0; i < 14; ++i) {
assert(std::strong_order(nq, v[i]) == std::strong_ordering::less);
}
assert(std::strong_order(nq, ps) == std::strong_ordering::less);
assert(std::strong_order(nq, pq) == std::strong_ordering::less);
assert(std::strong_order(ns, nq) == std::strong_ordering::greater);
assert(std::strong_order(ns, ns) == std::strong_ordering::equal);
for (int i=0; i < 14; ++i) {
assert(std::strong_order(ns, v[i]) == std::strong_ordering::less);
}
assert(std::strong_order(ns, ps) == std::strong_ordering::less);
assert(std::strong_order(ns, pq) == std::strong_ordering::less);
assert(std::strong_order(ps, nq) == std::strong_ordering::greater);
assert(std::strong_order(ps, ns) == std::strong_ordering::greater);
for (int i=0; i < 14; ++i) {
assert(std::strong_order(ps, v[i]) == std::strong_ordering::greater);
}
assert(std::strong_order(ps, ps) == std::strong_ordering::equal);
assert(std::strong_order(ps, pq) == std::strong_ordering::less);
assert(std::strong_order(pq, nq) == std::strong_ordering::greater);
assert(std::strong_order(pq, ns) == std::strong_ordering::greater);
for (int i=0; i < 14; ++i) {
assert(std::strong_order(pq, v[i]) == std::strong_ordering::greater);
}
assert(std::strong_order(pq, ps) == std::strong_ordering::greater);
assert(std::strong_order(pq, pq) == std::strong_ordering::equal);
}
return true;
}
namespace N14 {
// Compare to N12::A.
struct A {};
bool operator==(const A&, const A&);
constexpr std::strong_ordering operator<=>(A&, A&&) { return std::strong_ordering::less; }
constexpr std::strong_ordering operator<=>(A&&, A&&) { return std::strong_ordering::equal; }
std::strong_ordering operator<=>(const A&, const A&);
static_assert(std::three_way_comparable<A>);
struct B {
std::strong_ordering operator<=>(const B&) const; // lacks operator==
};
static_assert(!std::three_way_comparable<B>);
struct C {
mutable bool touched = false;
bool operator==(const C&) const;
constexpr std::strong_ordering operator<=>(const C& rhs) const {
rhs.touched = true;
return std::strong_ordering::equal;
}
};
static_assert(std::three_way_comparable<C>);
}
constexpr bool test_1_4()
{
// Otherwise, strong_ordering(compare_three_way()(E, F)) if it is a well-formed expression.
// Test neither strong_order nor compare_three_way const-qualify the forwarded arguments.
N14::A a;
assert(std::strong_order(a, std::move(a)) == std::strong_ordering::less);
assert(std::strong_order(std::move(a), std::move(a)) == std::strong_ordering::equal);
N14::B b;
static_assert(!has_strong_order(b, b));
N14::C c1, c2;
assert(std::strong_order(c1, c2) == std::strong_ordering::equal);
assert(!c1.touched);
assert(c2.touched);
return true;
}
int main(int, char**)
{
test_1_1();
test_1_2();
test_1_3<float>();
test_1_3<double>();
// test_1_3<long double>();
test_1_4();
static_assert(test_1_3<float>());
static_assert(test_1_3<double>());
// static_assert(test_1_3<long double>());
static_assert(test_1_4());
return 0;
}

libcxx/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
# endif # endif
# ifdef __cpp_lib_int_pow2 # ifdef __cpp_lib_int_pow2
# error "__cpp_lib_int_pow2 should not be defined before c++20" # error "__cpp_lib_int_pow2 should not be defined before c++20"
# endif # endif
#elif TEST_STD_VER == 20 #elif TEST_STD_VER == 20
# if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_bit_cast # ifndef __cpp_lib_bit_cast
# error "__cpp_lib_bit_cast should be defined in c++20" # error "__cpp_lib_bit_cast should be defined in c++20"
# endif # endif
# if __cpp_lib_bit_cast != 201806L # if __cpp_lib_bit_cast != 201806L
# error "__cpp_lib_bit_cast should have the value 201806L in c++20" # error "__cpp_lib_bit_cast should have the value 201806L in c++20"
# endif # endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_bit_cast
# error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
# endif
# endif
# if !defined(_LIBCPP_VERSION) # if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_bitops # ifndef __cpp_lib_bitops
# error "__cpp_lib_bitops should be defined in c++20" # error "__cpp_lib_bitops should be defined in c++20"
# endif # endif
# if __cpp_lib_bitops != 201907L # if __cpp_lib_bitops != 201907L
# error "__cpp_lib_bitops should have the value 201907L in c++20" # error "__cpp_lib_bitops should have the value 201907L in c++20"
# endif # endif
Show All 14 Lines
# error "__cpp_lib_int_pow2 should be defined in c++20" # error "__cpp_lib_int_pow2 should be defined in c++20"
# endif # endif
# if __cpp_lib_int_pow2 != 202002L # if __cpp_lib_int_pow2 != 202002L
# error "__cpp_lib_int_pow2 should have the value 202002L in c++20" # error "__cpp_lib_int_pow2 should have the value 202002L in c++20"
# endif # endif
#elif TEST_STD_VER > 20 #elif TEST_STD_VER > 20
# if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_bit_cast # ifndef __cpp_lib_bit_cast
# error "__cpp_lib_bit_cast should be defined in c++2b" # error "__cpp_lib_bit_cast should be defined in c++2b"
# endif # endif
# if __cpp_lib_bit_cast != 201806L # if __cpp_lib_bit_cast != 201806L
# error "__cpp_lib_bit_cast should have the value 201806L in c++2b" # error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
# endif # endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_bit_cast
# error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
# endif
# endif
# if !defined(_LIBCPP_VERSION) # if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_bitops # ifndef __cpp_lib_bitops
# error "__cpp_lib_bitops should be defined in c++2b" # error "__cpp_lib_bitops should be defined in c++2b"
# endif # endif
# if __cpp_lib_bitops != 201907L # if __cpp_lib_bitops != 201907L
# error "__cpp_lib_bitops should have the value 201907L in c++2b" # error "__cpp_lib_bitops should have the value 201907L in c++2b"
# endif # endif
Show All 23 Lines

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
# ifndef __cpp_lib_bind_front # ifndef __cpp_lib_bind_front
# error "__cpp_lib_bind_front should be defined in c++20" # error "__cpp_lib_bind_front should be defined in c++20"
# endif # endif
# if __cpp_lib_bind_front != 201907L # if __cpp_lib_bind_front != 201907L
# error "__cpp_lib_bind_front should have the value 201907L in c++20" # error "__cpp_lib_bind_front should have the value 201907L in c++20"
# endif # endif
# if !defined(_LIBCPP_VERSION) # ifndef __cpp_lib_bit_cast
# ifndef __cpp_lib_bit_cast # error "__cpp_lib_bit_cast should be defined in c++20"
# error "__cpp_lib_bit_cast should be defined in c++20" # endif
# endif # if __cpp_lib_bit_cast != 201806L
# if __cpp_lib_bit_cast != 201806L # error "__cpp_lib_bit_cast should have the value 201806L in c++20"
# error "__cpp_lib_bit_cast should have the value 201806L in c++20"
# endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_bit_cast
# error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
# endif
# endif # endif
# if !defined(_LIBCPP_VERSION) # if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_bitops # ifndef __cpp_lib_bitops
# error "__cpp_lib_bitops should be defined in c++20" # error "__cpp_lib_bitops should be defined in c++20"
# endif # endif
# if __cpp_lib_bitops != 201907L # if __cpp_lib_bitops != 201907L
# error "__cpp_lib_bitops should have the value 201907L in c++20" # error "__cpp_lib_bitops should have the value 201907L in c++20"
▲ Show 20 Lines • Show All 1,130 Lines • ▼ Show 20 Lines
# ifndef __cpp_lib_bind_front # ifndef __cpp_lib_bind_front
# error "__cpp_lib_bind_front should be defined in c++2b" # error "__cpp_lib_bind_front should be defined in c++2b"
# endif # endif
# if __cpp_lib_bind_front != 201907L # if __cpp_lib_bind_front != 201907L
# error "__cpp_lib_bind_front should have the value 201907L in c++2b" # error "__cpp_lib_bind_front should have the value 201907L in c++2b"
# endif # endif
# if !defined(_LIBCPP_VERSION) # ifndef __cpp_lib_bit_cast
# ifndef __cpp_lib_bit_cast # error "__cpp_lib_bit_cast should be defined in c++2b"
# error "__cpp_lib_bit_cast should be defined in c++2b" # endif
# endif # if __cpp_lib_bit_cast != 201806L
# if __cpp_lib_bit_cast != 201806L # error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
# error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
# endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_bit_cast
# error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
# endif
# endif # endif
# if !defined(_LIBCPP_VERSION) # if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_bitops # ifndef __cpp_lib_bitops
# error "__cpp_lib_bitops should be defined in c++2b" # error "__cpp_lib_bitops should be defined in c++2b"
# endif # endif
# if __cpp_lib_bitops != 201907L # if __cpp_lib_bitops != 201907L
# error "__cpp_lib_bitops should have the value 201907L in c++2b" # error "__cpp_lib_bitops should have the value 201907L in c++2b"
▲ Show 20 Lines • Show All 987 Lines • Show Last 20 Lines

libcxx/test/std/library/description/conventions/type.descriptions/customization.point.object/cpo.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

This one test file is the only part of D107036 that hasn't been superseded by D110738 + D111514.
@ldionne or whoever, do you think we care about this test file? Should I open a new PR for it (or repurpose this one)? or should I just close D107036 completely?

Quuxplusone: This one test file is the only part of D107036 that hasn't been superseded by D110738 + D111514.
ldionneUnsubmitted
Not Done
ReplyInline Actions

I think this test is useful, and I would encourage splitting it into another PR to clear things up a bit. And then we can close this one as it has been superseded.

ldionne: I think this test is useful, and I would encourage splitting it into another PR to clear things…
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// [customization.point.object]
// [range.adaptor.object] "A range adaptor object is a customization point object..."
#include <compare>
#include <iterator>
#include <ranges>
#include <utility>
template<class CPO, class... Args>
constexpr bool test(CPO& o, Args&&...)
{
auto p = o;
using T = decltype(p);
// The type of a customization point object, ignoring cv-qualifiers, shall model semiregular.
static_assert(std::semiregular<T>);
// All instances of a specific customization point object type shall be equal.
// (However, they need not support operator==, so there's nothing to test here.)
// The type T of a customization point object, ignoring cv-qualifiers, shall model...
static_assert(std::invocable<T&, Args...>);
static_assert(std::invocable<const T&, Args...>);
static_assert(std::invocable<T, Args...>);
static_assert(std::invocable<const T, Args...>);
return true;
}
int main(int, char**)
{
int a[10];
// int arrays[10][10];
// std::pair<int, int> pairs[10];
// [iterator.cust]
static_assert(test(std::ranges::iter_move, a+0));
static_assert(test(std::ranges::iter_swap, a+0, a+1));
// [cmp.alg]
static_assert(test(std::strong_order, 1, 2));
static_assert(test(std::weak_order, 1, 2));
static_assert(test(std::partial_order, 1, 2));
// static_assert(test(std::compare_strong_order_fallback, 1, 2));
// static_assert(test(std::compare_weak_order_fallback, 1, 2));
// static_assert(test(std::compare_partial_order_fallback, 1, 2));
// [range.access]
static_assert(test(std::ranges::begin, a));
static_assert(test(std::ranges::end, a));
static_assert(test(std::ranges::cbegin, a));
static_assert(test(std::ranges::cend, a));
// static_assert(test(std::ranges::rbegin, a));
// static_assert(test(std::ranges::rend, a));
// static_assert(test(std::ranges::crbegin, a));
// static_assert(test(std::ranges::crend, a));
static_assert(test(std::ranges::size, a));
static_assert(test(std::ranges::ssize, a));
static_assert(test(std::ranges::empty, a));
static_assert(test(std::ranges::data, a));
// static_assert(test(std::ranges::cdata, a));
// [range.factories]
// views::empty<T> is not a CPO
// static_assert(test(std::views::single, 4));
static_assert(test(std::views::iota, 1));
static_assert(test(std::views::iota, 1, 10));
// ranges::istream_view<T> is not a CPO
// [range.adaptors]
static_assert(test(std::views::all, a));
// static_assert(test(std::views::filter, a, [](int x){ return x < 10; }));
static_assert(test(std::views::transform, a, [](int x){ return x + 1; }));
// static_assert(test(std::views::take, a, 10));
// static_assert(test(std::views::take_while, a, [](int x){ return x < 10; }));
// static_assert(test(std::views::drop, a, 10));
// static_assert(test(std::views::drop_while, a, [](int x){ return x < 10; }));
// static_assert(test(std::views::join, arrays));
// static_assert(test(std::views::lazy_split, a, 4));
// static_assert(test(std::views::split, a, 4));
static_assert(test(std::views::counted, a, 10));
// static_assert(test(std::views::common, a));
// static_assert(test(std::views::reverse, a));
// static_assert(test(std::views::elements<0>, pairs));
return 0;
}

libcxx/test/std/numerics/bit/bit.cast/bit_cast.compile.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts
// <bit>
//
// template<class To, class From>
// constexpr To bit_cast(const From& from) noexcept; // C++20
// This test makes sure that std::bit_cast fails when any of the following
// constraints are violated:
//
// (1.1) sizeof(To) == sizeof(From) is true;
// (1.2) is_trivially_copyable_v<To> is true;
// (1.3) is_trivially_copyable_v<From> is true.
#include <bit>
#include <concepts>
template<class To, class From>
concept bit_cast_is_valid = requires(From from) {
{ std::bit_cast<To>(from) } -> std::same_as<To>;
};
// Types are not the same size
namespace ns1 {
struct To { char a; };
struct From { char a; char b; };
static_assert(!bit_cast_is_valid<To, From>);
static_assert(!bit_cast_is_valid<char[2], From>); // makes bit_cast's return type invalid
static_assert(!bit_cast_is_valid<int(), From>); // duh, but might as well check
static_assert(bit_cast_is_valid<From, From>); // OK, right?
static_assert(!bit_cast_is_valid<From&, From>); // Not OK???
}
// To is not trivially copyable
namespace ns2 {
struct To { char a; To(const To&); };
struct From { char a; };
static_assert(!bit_cast_is_valid<To, From>);
}
// From is not trivially copyable
namespace ns3 {
struct To { char a; };
struct From { char a; From(const From&); };
static_assert(!bit_cast_is_valid<To, From>);
}

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <bit>
//
// template<class To, class From>
// constexpr To bit_cast(const From& from) noexcept; // C++20
#include <array>
#include <bit>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <limits>
// std::bit_cast does not preserve padding bits, so if T has
// padding bits then the results might not memcmp cleanly.
// Naively, std::has_unique_object_representations<T> would
// tell us whether T has no padding bits; but it turns out that
// std::has_unique_object_representations<float> is false,
// so let's just never trust its answer.
//
template<bool HasUniqueObjectRepresentations = true, class T>
void test_roundtrip_through_buffer(T from) {
struct Buffer { char buffer[sizeof(T)]; };
Buffer middle = std::bit_cast<Buffer>(from);
T to = std::bit_cast<T>(middle);
Buffer middle2 = std::bit_cast<Buffer>(to);
assert((from == to) == (from == from)); // because NaN
if constexpr (HasUniqueObjectRepresentations) {
assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
assert(std::memcmp(&middle, &to, sizeof(T)) == 0);
assert(std::memcmp(&middle, &middle2, sizeof(Buffer)) == 0);
}
}
template<bool HasUniqueObjectRepresentations = true, class T>
void test_roundtrip_through_nested_T(T from) {
struct Nested { T x; };
static_assert(sizeof(Nested) == sizeof(T));
Nested middle = std::bit_cast<Nested>(from);
T to = std::bit_cast<T>(middle);
Nested middle2 = std::bit_cast<Nested>(to);
assert((from == to) == (from == from)); // because NaN
if constexpr (HasUniqueObjectRepresentations) {
assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
assert(std::memcmp(&middle, &to, sizeof(T)) == 0);
assert(std::memcmp(&middle, &middle2, sizeof(T)) == 0);
}
}
template<class Intermediate, bool HasUniqueObjectRepresentations = true, class T>
void test_roundtrip_through(T from) {
static_assert(sizeof(Intermediate) == sizeof(T));
Intermediate middle = std::bit_cast<Intermediate>(from);
T to = std::bit_cast<T>(middle);
Intermediate middle2 = std::bit_cast<Intermediate>(to);
assert((from == to) == (from == from)); // because NaN
if constexpr (HasUniqueObjectRepresentations) {
assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
assert(std::memcmp(&to, &middle, sizeof(T)) == 0);
assert(std::memcmp(&middle, &middle2, sizeof(Intermediate)) == 0);
}
}
template <typename T>
constexpr std::array<T, 10> generate_signed_integral_values() {
return {std::numeric_limits<T>::min(),
std::numeric_limits<T>::min() + 1,
static_cast<T>(-2), static_cast<T>(-1),
static_cast<T>(0), static_cast<T>(1),
static_cast<T>(2), static_cast<T>(3),
std::numeric_limits<T>::max() - 1,
std::numeric_limits<T>::max()};
}
template <typename T>
constexpr std::array<T, 6> generate_unsigned_integral_values() {
return {static_cast<T>(0), static_cast<T>(1),
static_cast<T>(2), static_cast<T>(3),
std::numeric_limits<T>::max() - 1,
std::numeric_limits<T>::max()};
}
constexpr bool test() {
for (bool b : {false, true}) {
test_roundtrip_through_nested_T(b);
test_roundtrip_through_buffer(b);
test_roundtrip_through<char>(b);
}
for (char c : {'\0', 'a', 'b', 'c', 'd'}) {
test_roundtrip_through_nested_T(c);
test_roundtrip_through_buffer(c);
}
// Fundamental signed integer types
for (signed char i : generate_signed_integral_values<signed char>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
}
for (short i : generate_signed_integral_values<short>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
}
for (int i : generate_signed_integral_values<int>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<float>(i);
}
for (long i : generate_signed_integral_values<long>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
}
for (long long i : generate_signed_integral_values<long long>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<double>(i);
}
// Fundamental unsigned integer types
for (unsigned char i : generate_unsigned_integral_values<unsigned char>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
}
for (unsigned short i : generate_unsigned_integral_values<unsigned short>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
}
for (unsigned int i : generate_unsigned_integral_values<unsigned int>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<float>(i);
}
for (unsigned long i : generate_unsigned_integral_values<unsigned long>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
}
for (unsigned long long i : generate_unsigned_integral_values<unsigned long long>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<double>(i);
}
// Fixed width signed integer types
for (std::int32_t i : generate_signed_integral_values<std::int32_t>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<int>(i);
test_roundtrip_through<std::uint32_t>(i);
test_roundtrip_through<float>(i);
}
for (std::int64_t i : generate_signed_integral_values<std::int64_t>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<long long>(i);
test_roundtrip_through<std::uint64_t>(i);
test_roundtrip_through<double>(i);
}
// Fixed width unsigned integer types
for (std::uint32_t i : generate_unsigned_integral_values<std::uint32_t>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<int>(i);
test_roundtrip_through<std::int32_t>(i);
test_roundtrip_through<float>(i);
}
for (std::uint64_t i : generate_unsigned_integral_values<std::uint64_t>()) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<long long>(i);
test_roundtrip_through<std::int64_t>(i);
test_roundtrip_through<double>(i);
}
// Floating point types
for (float i : {0.0f, 1.0f, -1.0f, 10.0f, -10.0f, 1e10f, 1e-10f, 1e20f, 1e-20f, 2.71828f, 3.14159f,
std::nanf(""),
__builtin_nanf("0x55550001"), // NaN with a payload
std::numeric_limits<float>::signaling_NaN(),
std::numeric_limits<float>::quiet_NaN()}) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<int>(i);
}
for (double i : {0.0, 1.0, -1.0, 10.0, -10.0, 1e10, 1e-10, 1e100, 1e-100,
2.718281828459045,
3.141592653589793238462643383279502884197169399375105820974944,
std::nan(""),
std::numeric_limits<double>::signaling_NaN(),
std::numeric_limits<double>::quiet_NaN()}) {
test_roundtrip_through_nested_T(i);
test_roundtrip_through_buffer(i);
test_roundtrip_through<long long>(i);
}
for (long double i : {0.0l, 1.0l, -1.0l, 10.0l, -10.0l, 1e10l, 1e-10l, 1e100l, 1e-100l,
2.718281828459045l,
3.141592653589793238462643383279502884197169399375105820974944l,
std::nanl(""),
std::numeric_limits<long double>::signaling_NaN(),
std::numeric_limits<long double>::quiet_NaN()}) {
// Note that x86's "long double" has 80 value bits and 48 padding bits.
test_roundtrip_through_nested_T<false>(i);
test_roundtrip_through_buffer<false>(i);
#ifndef _LIBCPP_HAS_NO_INT128
test_roundtrip_through<__int128_t, false>(i);
test_roundtrip_through<__uint128_t, false>(i);
#endif
}
return true;
}
// TODO: There doesn't seem to be a way to perform non-trivial correctness
// tests inside constexpr.
constexpr bool basic_constexpr_test() {
struct Nested { char buffer[sizeof(int)]; };
int from = 3;
Nested middle = std::bit_cast<Nested>(from);
int to = std::bit_cast<int>(middle);
assert(from == to);
return true;
}
int main(int, char**) {
test();
static_assert(basic_constexpr_test());
return 0;
}

libcxx/test/std/utilities/function.objects/comparisons/compare_three_way.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <compare>
// <functional>
// compare_three_way
#include <compare>
#include <cassert>
#include <type_traits>
#include "pointer_comparison_test_helper.h"
template<class T, class U>
constexpr auto test_sfinae(T t, U u)
-> decltype(std::compare_three_way()(t, u), std::true_type{})
{ return std::true_type{}; }
jloserUnsubmitted
Not Done
ReplyInline Actions

Any reason to prefer this over just return true;? Similarly for the fallback overload (except return false; in that case).

jloser: Any reason to prefer this over just `return true;`? Similarly for the fallback overload (except…
constexpr auto test_sfinae(...)
{ return std::false_type{}; }
struct NotThreeWayComparable {
std::strong_ordering operator<=>(const NotThreeWayComparable&) const;
};
ASSERT_SAME_TYPE(std::compare_three_way_result_t<NotThreeWayComparable>, std::strong_ordering);
static_assert(!std::three_way_comparable<NotThreeWayComparable>); // it lacks operator==
constexpr bool test()
{
ASSERT_SAME_TYPE(decltype(std::compare_three_way()(1, 1)), std::strong_ordering);
assert(std::compare_three_way()(1, 1) == std::strong_ordering::equal);
assert(std::compare_three_way()(1, 2) == std::strong_ordering::less);
assert(std::compare_three_way()(2, 1) == std::strong_ordering::greater);
ASSERT_SAME_TYPE(decltype(std::compare_three_way()(1.0, 1.0)), std::partial_ordering);
assert(std::compare_three_way()(1.0, 1.0) == std::partial_ordering::equivalent);
assert(std::compare_three_way()(1.0, 2.0) == std::partial_ordering::less);
assert(std::compare_three_way()(2.0, 1.0) == std::partial_ordering::greater);
// Try heterogeneous comparison.
ASSERT_SAME_TYPE(decltype(std::compare_three_way()(42.0, 42)), std::partial_ordering);
assert(std::compare_three_way()(42.0, 42) == std::partial_ordering::equivalent);
return true;
}
int main(int, char**)
{
test();
static_assert(test());
do_pointer_comparison_test(std::compare_three_way());
static_assert(test_sfinae(1, 2));
static_assert(!test_sfinae(1, nullptr));
static_assert(!test_sfinae(NotThreeWayComparable(), NotThreeWayComparable()));
return 0;
}

libcxx/test/std/utilities/function.objects/comparisons/transparent.pass.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linesint main(int, char**)
static_assert ( is_transparent<std::greater<void>>::value, "" ); static_assert ( is_transparent<std::greater<void>>::value, "" );
static_assert ( is_transparent<std::greater<>>::value, "" ); static_assert ( is_transparent<std::greater<>>::value, "" );
static_assert ( !is_transparent<std::greater_equal<int>>::value, "" ); static_assert ( !is_transparent<std::greater_equal<int>>::value, "" );
static_assert ( !is_transparent<std::greater_equal<std::string>>::value, "" ); static_assert ( !is_transparent<std::greater_equal<std::string>>::value, "" );
static_assert ( is_transparent<std::greater_equal<void>>::value, "" ); static_assert ( is_transparent<std::greater_equal<void>>::value, "" );
static_assert ( is_transparent<std::greater_equal<>>::value, "" ); static_assert ( is_transparent<std::greater_equal<>>::value, "" );
#if TEST_STD_VER > 17
static_assert( is_transparent<std::compare_three_way>::value, "" );
jloserUnsubmitted
Not Done
ReplyInline Actions

We can drop the empty string second argument if you care.

jloser: We can drop the empty string second argument if you care.
#endif
return 0; return 0;
} }

libcxx/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Linesconstexpr bool test() {
P8::FancyPtrA<Holder<Incomplete> > p8a = p8_nil; P8::FancyPtrA<Holder<Incomplete> > p8a = p8_nil;
assert(std::to_address(p8a) == p8_nil); assert(std::to_address(p8a) == p8_nil);
ASSERT_SAME_TYPE(decltype(std::to_address(p8a)), decltype(p8_nil)); ASSERT_SAME_TYPE(decltype(std::to_address(p8a)), decltype(p8_nil));
P8::FancyPtrB<Holder<Incomplete> > p8b = p8_nil; P8::FancyPtrB<Holder<Incomplete> > p8b = p8_nil;
assert(std::to_address(p8b) == p8_nil); assert(std::to_address(p8b) == p8_nil);
ASSERT_SAME_TYPE(decltype(std::to_address(p8b)), decltype(p8_nil)); ASSERT_SAME_TYPE(decltype(std::to_address(p8b)), decltype(p8_nil));
int p9[2] = {};
assert(std::to_address(p9) == p9);
ASSERT_SAME_TYPE(decltype(std::to_address(p9)), int*);
const int p10[2] = {};
assert(std::to_address(p10) == p10);
ASSERT_SAME_TYPE(decltype(std::to_address(p10)), const int*);
int (*p11)() = nullptr;
assert(std::to_address(&p11) == &p11);
ASSERT_SAME_TYPE(decltype(std::to_address(&p11)), int(**)());
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
static_assert(test()); static_assert(test());
return 0; return 0;
} }

libcxx/test/std/utilities/memory/pointer.conversion/to_address_on_funcptr.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <memory>
// UNSUPPORTED: c++03, c++11, c++14, c++17
// template <class T> constexpr T* to_address(T* p) noexcept;
// Mandates: T is not a function type.
#include <memory>
int (*pf)();
void test() {
(void)std::to_address(pf); // expected-error@*:* {{is a function type}}
}

libcxx/test/std/utilities/memory/pointer.conversion/to_address_on_function.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <memory>
// UNSUPPORTED: c++03, c++11, c++14, c++17
// template <class T> constexpr T* to_address(T* p) noexcept;
// Mandates: T is not a function type.
#include <memory>
int f();
void test() {
(void)std::to_address(f); // expected-error@*:* {{is a function type}}
}

libcxx/utils/generate_feature_test_macro_components.py

Show First 20 Lines • Show All 150 Lines • ▼ Show 20 Linesfeature_test_macros = [ add_version_header(x) for x in [
}, { }, {
"name": "__cpp_lib_bind_front", "name": "__cpp_lib_bind_front",
"values": { "c++20": 201907 }, "values": { "c++20": 201907 },
"headers": ["functional"], "headers": ["functional"],
}, { }, {
"name": "__cpp_lib_bit_cast", "name": "__cpp_lib_bit_cast",
"values": { "c++20": 201806 }, "values": { "c++20": 201806 },
"headers": ["bit"], "headers": ["bit"],
"unimplemented": True,
}, { }, {
"name": "__cpp_lib_bitops", "name": "__cpp_lib_bitops",
"values": { "c++20": 201907 }, "values": { "c++20": 201907 },
"headers": ["bit"], "headers": ["bit"],
"unimplemented": True, "unimplemented": True,
}, { }, {
"name": "__cpp_lib_bool_constant", "name": "__cpp_lib_bool_constant",
"values": { "c++17": 201505 }, "values": { "c++17": 201505 },
▲ Show 20 Lines • Show All 950 Lines • Show Last 20 Lines