maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/version

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

386 lines
24 KiB
Plaintext
Raw Normal View History

[libc++] Revert the part of my b82683b that affected <version>. This reverts part of commit b82683b2eb3601f6e8970861b94ad7b37393aa90. I hadn't intended to remove the `// -*- C++ -*-` comment line from `libcxx/include/version`, only from the generated tests. Thanks to Raul Tambre for the catch.
2021-10-02 00:59:24 +08:00
// -*- C++ -*-
[libc++][NFC] Remove header name from <version>
2021-10-05 01:34:26 +08:00
//===----------------------------------------------------------------------===//
Implement P0754R2: The <version> header. llvm-svn: 329075
2018-04-03 23:48:24 +08:00
//
Update more file headers across all of the LLVM projects in the monorepo to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
2019-01-19 18:56:40 +08:00
// 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
Implement P0754R2: The <version> header. llvm-svn: 329075
2018-04-03 23:48:24 +08:00
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_VERSIONH
#define _LIBCPP_VERSIONH
/*
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
version synopsis
Implement P0754R2: The <version> header. llvm-svn: 329075
2018-04-03 23:48:24 +08:00
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
Macro name Value Headers
[libc++] Implement P1425R4 (Iterator pair constructors for std::stack and std::queue) Implement P1425R4 Reviewed By: Quuxplusone, #libc, Mordante Spies: Mordante, jloser, libcxx-commits, arichardson Differential Revision: https://reviews.llvm.org/D115977
2022-01-06 19:36:07 +08:00
__cpp_lib_adaptor_iterator_pair_constructor 202106L <queue> <stack>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_addressof_constexpr 201603L <memory>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_allocate_at_least 202106L <memory>
[libc++] Alphabetize generate_feature_test_macro_components.py. NFCI. For ease of comparing our list with the official SD-6 list, which is alphabetized. https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#library-feature-test-macros This also alphabetizes the lists of headers in which the macros are defined, which harmlessly alters many comments in <version>. Also drive-by-fix some trivial flake8 warnings.
2021-01-08 07:04:41 +08:00
__cpp_lib_allocator_traits_is_always_equal 201411L <deque> <forward_list> <list>
<map> <memory> <scoped_allocator>
<set> <string> <unordered_map>
<unordered_set> <vector>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_any 201606L <any>
__cpp_lib_apply 201603L <tuple>
[libc++] Alphabetize generate_feature_test_macro_components.py. NFCI. For ease of comparing our list with the official SD-6 list, which is alphabetized. https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#library-feature-test-macros This also alphabetizes the lists of headers in which the macros are defined, which harmlessly alters many comments in <version>. Also drive-by-fix some trivial flake8 warnings.
2021-01-08 07:04:41 +08:00
__cpp_lib_array_constexpr 201811L <array> <iterator>
[libc++] Complete overhaul of constexpr support in std::array This commit adds missing support for constexpr in std::array under all standard modes up to and including C++20. It also transforms the <array> tests to check for constexpr-friendliness under the right standard modes. Fixes https://llvm.org/PR40124 Fixes rdar://57522096 Supersedes https://reviews.llvm.org/D60666 Differential Revision: https://reviews.llvm.org/D80452
2020-05-22 21:59:48 +08:00
201603L // C++17
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_as_const 201510L <utility>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_associative_heterogeneous_erasure 202110L <map> <set> <unordered_map>
<unordered_set>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_assume_aligned 201811L <memory>
Update atomic feature macros, synopsis, signatures to match C++20. Improve test coverage for non-lock-free atomics.
2020-09-10 01:00:09 +08:00
__cpp_lib_atomic_flag_test 201907L <atomic>
__cpp_lib_atomic_float 201711L <atomic>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_atomic_is_always_lock_free 201603L <atomic>
Update atomic feature macros, synopsis, signatures to match C++20. Improve test coverage for non-lock-free atomics.
2020-09-10 01:00:09 +08:00
__cpp_lib_atomic_lock_free_type_aliases 201907L <atomic>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_atomic_ref 201806L <atomic>
Update atomic feature macros, synopsis, signatures to match C++20. Improve test coverage for non-lock-free atomics.
2020-09-10 01:00:09 +08:00
__cpp_lib_atomic_shared_ptr 201711L <atomic>
__cpp_lib_atomic_value_initialization 201911L <atomic> <memory>
__cpp_lib_atomic_wait 201907L <atomic>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_barrier 201907L <barrier>
__cpp_lib_bind_front 201907L <functional>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_bit_cast 201806L <bit>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_bitops 201907L <bit>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_bool_constant 201505L <type_traits>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_bounded_array_traits 201902L <type_traits>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_boyer_moore_searcher 201603L <functional>
__cpp_lib_byte 201603L <cstddef>
[libc++] Implement P1272R4 (std::byteswap) Implement P1274R4 Reviewed By: Quuxplusone, Mordante, #libc Spies: jloser, lebedev.ri, mgorny, libcxx-commits, arichardson Differential Revision: https://reviews.llvm.org/D114074
2021-11-22 07:22:55 +08:00
__cpp_lib_byteswap 202110L <bit>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_char8_t 201811L <atomic> <filesystem> <istream>
<limits> <locale> <ostream>
<string> <string_view>
__cpp_lib_chrono 201611L <chrono>
__cpp_lib_chrono_udls 201304L <chrono>
__cpp_lib_clamp 201603L <algorithm>
__cpp_lib_complex_udls 201309L <complex>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_concepts 202002L <concepts>
__cpp_lib_constexpr_algorithms 201806L <algorithm>
__cpp_lib_constexpr_complex 201711L <complex>
[libc++] Implement C++20's P0784 (More constexpr containers) This commit adds std::construct_at, and marks various members of std::allocator_traits and std::allocator as constexpr. It also adds tests and turns the existing tests into hybrid constexpr/runtime tests. Thanks to Richard Smith for initial work on this, and to Michael Park for D69803, D69132 and D69134, which are superseded by this patch. Differential Revision: https://reviews.llvm.org/D68364
2020-09-18 00:06:13 +08:00
__cpp_lib_constexpr_dynamic_alloc 201907L <memory>
[libc++] [P1065] Constexpr invoke, reference_wrapper, mem_fn, not_fn, default_searcher. This completes the implementation of P1065 "constexpr INVOKE": http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1065r2.html This doesn't yet complete the implementation of P1032 "Misc constexpr bits," http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html but it does complete all of the <functional> bits, which means that we can now set `__cpp_lib_constexpr_functional` for C++20. This could use more constexpr tests for `std::reference_wrapper<T>`, but the existing tests are extremely non-constexpr-friendly and so I don't want to get into that rabbit-hole today. Differential Revision: https://reviews.llvm.org/D93815
2020-12-26 03:48:39 +08:00
__cpp_lib_constexpr_functional 201907L <functional>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_constexpr_iterator 201811L <iterator>
__cpp_lib_constexpr_memory 201811L <memory>
[libc++] P1645 constexpr for <numeric> Implements P1645: constexpr for <numeric> algorithms Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D90569
2020-11-28 21:50:53 +08:00
__cpp_lib_constexpr_numeric 201911L <numeric>
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
__cpp_lib_constexpr_string 201811L <string>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_constexpr_string_view 201811L <string_view>
__cpp_lib_constexpr_tuple 201811L <tuple>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_constexpr_typeinfo 202106L <typeinfo>
Add constexpr to pair Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D80558
2020-09-03 03:20:33 +08:00
__cpp_lib_constexpr_utility 201811L <utility>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_constexpr_vector 201907L <vector>
__cpp_lib_coroutine 201902L <coroutine>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_destroying_delete 201806L <new>
__cpp_lib_enable_shared_from_this 201603L <memory>
[libc++] [P1612] Add missing feature-test macro __cpp_lib_endian. Thanks to Marek Kurdej for the patch. Differential Revision: https://reviews.llvm.org/D70221
2019-11-14 21:54:23 +08:00
__cpp_lib_endian 201907L <bit>
[libc++] Alphabetize generate_feature_test_macro_components.py. NFCI. For ease of comparing our list with the official SD-6 list, which is alphabetized. https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#library-feature-test-macros This also alphabetizes the lists of headers in which the macros are defined, which harmlessly alters many comments in <version>. Also drive-by-fix some trivial flake8 warnings.
2021-01-08 07:04:41 +08:00
__cpp_lib_erase_if 202002L <deque> <forward_list> <list>
<map> <set> <string>
<unordered_map> <unordered_set> <vector>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_exchange_function 201304L <utility>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_execution 201902L <execution>
201603L // C++17
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_filesystem 201703L <filesystem>
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
__cpp_lib_format 202106L <format>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_gcd_lcm 201606L <numeric>
__cpp_lib_generic_associative_lookup 201304L <map> <set>
__cpp_lib_generic_unordered_lookup 201811L <unordered_map> <unordered_set>
__cpp_lib_hardware_interference_size 201703L <new>
__cpp_lib_has_unique_object_representations 201606L <type_traits>
__cpp_lib_hypot 201603L <cmath>
__cpp_lib_incomplete_container_elements 201505L <forward_list> <list> <vector>
[libcxx] Implement P1956 rename low-level bit functions Implements P1956: On the names of low-level bit manipulation functions. Users may use older versions of libc++ or other standard libraries with the old names. In order to keep compatibility the old functions are kept, but marked as deprecated. The patch also adds a new config macro `_LIBCPP_DEPRECATED_MSG`. Do you prefer a this is a separate patch? Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D90551
2020-11-24 21:50:49 +08:00
__cpp_lib_int_pow2 202002L <bit>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_integer_comparison_functions 202002L <utility>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_integer_sequence 201304L <utility>
__cpp_lib_integral_constant_callable 201304L <type_traits>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_interpolate 201902L <cmath> <numeric>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_invoke 201411L <functional>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_invoke_r 202106L <functional>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_is_aggregate 201703L <type_traits>
__cpp_lib_is_constant_evaluated 201811L <type_traits>
__cpp_lib_is_final 201402L <type_traits>
__cpp_lib_is_invocable 201703L <type_traits>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_is_layout_compatible 201907L <type_traits>
__cpp_lib_is_nothrow_convertible 201806L <type_traits>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_is_null_pointer 201309L <type_traits>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_is_pointer_interconvertible 201907L <type_traits>
[libc++] Add basic support for -std=c++2b. * Add feature test macros. * Add buildbot configuration generic-cxx2b that uses clang-tot. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D94227
2021-01-09 01:40:42 +08:00
__cpp_lib_is_scoped_enum 202011L <type_traits>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_is_swappable 201603L <type_traits>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_jthread 201911L <stop_token> <thread>
__cpp_lib_latch 201907L <latch>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_launder 201606L <new>
__cpp_lib_list_remove_return_type 201806L <forward_list> <list>
__cpp_lib_logical_traits 201510L <type_traits>
__cpp_lib_make_from_tuple 201606L <tuple>
__cpp_lib_make_reverse_iterator 201402L <iterator>
__cpp_lib_make_unique 201304L <memory>
__cpp_lib_map_try_emplace 201411L <map>
[libc++] Implement <numbers> Summary: Constants have 33 significant decimal digits for IEEE 754 128-bit floating-point numbers. Reviewers: ldionne, #libc, EricWF, zoecarver, curdeius Reviewed By: ldionne, #libc, curdeius Differential Revision: https://reviews.llvm.org/D77505
2020-06-19 15:13:33 +08:00
__cpp_lib_math_constants 201907L <numbers>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_math_special_functions 201603L <cmath>
__cpp_lib_memory_resource 201603L <memory_resource>
[libc++] Implement P0798R8 (Monadic operations for std::optional) Implement P0798R8 Reviewed By: #libc, ldionne, Quuxplusone Spies: tcanens, Quuxplusone, ldionne, Wmbat, arichardson, Mordante, libcxx-commits Differential Revision: https://reviews.llvm.org/D113408
2021-12-16 03:54:24 +08:00
__cpp_lib_monadic_optional 202110L <optional>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_move_only_function 202110L <functional>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_node_extract 201606L <map> <set> <unordered_map>
<unordered_set>
[libc++] Alphabetize generate_feature_test_macro_components.py. NFCI. For ease of comparing our list with the official SD-6 list, which is alphabetized. https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#library-feature-test-macros This also alphabetizes the lists of headers in which the macros are defined, which harmlessly alters many comments in <version>. Also drive-by-fix some trivial flake8 warnings.
2021-01-08 07:04:41 +08:00
__cpp_lib_nonmember_container_access 201411L <array> <deque> <forward_list>
<iterator> <list> <map>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
<regex> <set> <string>
<unordered_map> <unordered_set> <vector>
__cpp_lib_not_fn 201603L <functional>
__cpp_lib_null_iterators 201304L <iterator>
__cpp_lib_optional 201606L <optional>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_out_ptr 202106L <memory>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_parallel_algorithm 201603L <algorithm> <numeric>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_polymorphic_allocator 201902L <memory>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_quoted_string_io 201304L <iomanip>
__cpp_lib_ranges 201811L <algorithm> <functional> <iterator>
<memory> <ranges>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_ranges_starts_ends_with 202106L <algorithm>
__cpp_lib_ranges_zip 202110L <ranges> <tuple> <utility>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_raw_memory_algorithms 201606L <memory>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_remove_cvref 201711L <type_traits>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_result_of_sfinae 201210L <functional> <type_traits>
__cpp_lib_robust_nonmodifying_seq_ops 201304L <algorithm>
__cpp_lib_sample 201603L <algorithm>
__cpp_lib_scoped_lock 201703L <mutex>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_semaphore 201907L <semaphore>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_shared_mutex 201505L <shared_mutex>
__cpp_lib_shared_ptr_arrays 201611L <memory>
__cpp_lib_shared_ptr_weak_type 201606L <memory>
__cpp_lib_shared_timed_mutex 201402L <shared_mutex>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_shift 201806L <algorithm>
__cpp_lib_smart_ptr_for_overwrite 202002L <memory>
__cpp_lib_source_location 201907L <source_location>
[libcxx][span] Implement P1976R2 This resolves the NB comment about the construction of a fixed-size span from a dynamic range. Differential Revision: https://reviews.llvm.org/D74577
2020-05-13 21:50:06 +08:00
__cpp_lib_span 202002L <span>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_spanstream 202106L <spanstream>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_ssize 201902L <iterator>
[libc++] Add basic support for -std=c++2b. * Add feature test macros. * Add buildbot configuration generic-cxx2b that uses clang-tot. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D94227
2021-01-09 01:40:42 +08:00
__cpp_lib_stacktrace 202011L <stacktrace>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_starts_ends_with 201711L <string> <string_view>
[libc++] Add basic support for -std=c++2b. * Add feature test macros. * Add buildbot configuration generic-cxx2b that uses clang-tot. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D94227
2021-01-09 01:40:42 +08:00
__cpp_lib_stdatomic_h 202011L <stdatomic.h>
__cpp_lib_string_contains 202011L <string> <string_view>
[libc++] Implement P1072R10 (std::basic_string::resize_and_overwrite) Reviewed By: Quuxplusone, #libc, Mordante Spies: mzeren-vmw, ckennelly, arichardson, ldionne, Mordante, libcxx-commits, Quuxplusone Differential Revision: https://reviews.llvm.org/D113013
2022-01-07 04:43:26 +08:00
__cpp_lib_string_resize_and_overwrite 202110L <string>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_string_udls 201304L <string>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_string_view 201803L <string> <string_view>
201606L // C++17
__cpp_lib_syncbuf 201803L <syncstream>
__cpp_lib_three_way_comparison 201907L <compare>
__cpp_lib_to_address 201711L <memory>
Reland [libc++] [P0325] Implement to_array from LFTS with updates. Fixed expected errors and notes. Summary: This patch implements https://wg21.link/P0325. Reviewers: EricWF, mclow.lists, ldionne, lichray Reviewed By: ldionne, lichray Subscribers: lichray, dexonsmith, zoecarver, christof, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D69882
2020-01-30 20:27:35 +08:00
__cpp_lib_to_array 201907L <array>
[libc++] Fix feature test macro for __cpp_lib_to_chars We would have been defining it in <utility> instead of <charconv>. For the time being, this doesn't change anything since we don't implement the feature test macro anyways. Also, as a fly-by, this removes obsolete feature test macro tests. There was a brief time back in the days when we wrote feature test macro tests manually. In particular, we had test files for __cpp_lib_to_chars and __cpp_lib_memory_resource. Since we now have a principled way of generating these tests with scripts, this commit removes the obsolete (and empty) tests for these two feature test macros. Differential Revision: https://reviews.llvm.org/D114243
2021-11-19 22:52:28 +08:00
__cpp_lib_to_chars 201611L <charconv>
[libc++] [C++2b] [P1682] Add to_underlying. * https://wg21.link/P1682 Reviewed By: ldionne, Mordante, #libc Differential Revision: https://reviews.llvm.org/D97365
2021-03-05 16:19:39 +08:00
__cpp_lib_to_underlying 202102L <utility>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_transformation_trait_aliases 201304L <type_traits>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_transparent_operators 201510L <functional> <memory>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
201210L // C++14
__cpp_lib_tuple_element_t 201402L <tuple>
[libc++] Alphabetize generate_feature_test_macro_components.py. NFCI. For ease of comparing our list with the official SD-6 list, which is alphabetized. https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#library-feature-test-macros This also alphabetizes the lists of headers in which the macros are defined, which harmlessly alters many comments in <version>. Also drive-by-fix some trivial flake8 warnings.
2021-01-08 07:04:41 +08:00
__cpp_lib_tuples_by_type 201304L <tuple> <utility>
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
__cpp_lib_type_identity 201806L <type_traits>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_type_trait_variable_templates 201510L <type_traits>
__cpp_lib_uncaught_exceptions 201411L <exception>
__cpp_lib_unordered_map_try_emplace 201411L <unordered_map>
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
__cpp_lib_unwrap_ref 201811L <functional>
[libc++] [C++2b] [P2162] Allow inheritance from std::variant. This patch changes the variant even in pre-C++2b. It should not break anything, only allow use cases that didn't work previously. Notes: `__as_variant` is used in `__visitation::__variant::__visit_alt`, but I haven't used it in `__visitation::__variant::__visit_alt_at`. That's because it is used only in `__visit_value_at`, which in turn is always used on variant specializations (that's in comparison operators). * https://wg21.link/P2162 Reviewed By: ldionne, #libc, Quuxplusone Differential Revision: https://reviews.llvm.org/D97394
2021-03-26 01:09:11 +08:00
__cpp_lib_variant 202102L <variant>
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
__cpp_lib_void_t 201411L <type_traits>
Update the synopsis for <version>. NFC llvm-svn: 341990
2018-09-12 04:51:54 +08:00
Implement P0754R2: The <version> header. llvm-svn: 329075
2018-04-03 23:48:24 +08:00
*/
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
[libc++] Turn off clang-format for auto-generated version header. NFC.
2021-02-19 21:10:12 +08:00
// clang-format off
Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955 llvm-svn: 342073
2018-09-13 03:41:40 +08:00
#if _LIBCPP_STD_VER > 11
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_chrono_udls 201304L
# define __cpp_lib_complex_udls 201309L
# define __cpp_lib_exchange_function 201304L
# define __cpp_lib_generic_associative_lookup 201304L
# define __cpp_lib_integer_sequence 201304L
# define __cpp_lib_integral_constant_callable 201304L
# define __cpp_lib_is_final 201402L
# define __cpp_lib_is_null_pointer 201309L
# define __cpp_lib_make_reverse_iterator 201402L
# define __cpp_lib_make_unique 201304L
# define __cpp_lib_null_iterators 201304L
# define __cpp_lib_quoted_string_io 201304L
# define __cpp_lib_result_of_sfinae 201210L
# define __cpp_lib_robust_nonmodifying_seq_ops 201304L
[libc++] Make feature-test macros consistent with availability macros Before this patch, feature-test macros didn't take special availability markup into account, which means that feature-test macros can sometimes appear to "lie". For example, if you compile in C++20 mode and target macOS 10.13, the __cpp_lib_filesystem feature-test macro will be provided even though the <filesystem> declarations are marked as unavailable. This patch fixes that. rdar://68142369 Differential Revision: https://reviews.llvm.org/D94983
2021-01-20 02:04:01 +08:00
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)
Fix feature test macros for atomics/mutexes without threading llvm-svn: 351291
2019-01-16 10:10:28 +08:00
# define __cpp_lib_shared_timed_mutex 201402L
# endif
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_string_udls 201304L
# define __cpp_lib_transformation_trait_aliases 201304L
# define __cpp_lib_transparent_operators 201210L
# define __cpp_lib_tuple_element_t 201402L
# define __cpp_lib_tuples_by_type 201304L
Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955 llvm-svn: 342073
2018-09-13 03:41:40 +08:00
#endif
#if _LIBCPP_STD_VER > 14
[libc++] Remove workarounds for missing __builtin_addressof All supported compilers implement __builtin_addressof. Even MSVC implements addressof as a simple call to __builtin_addressof, so it would work if we were to port libc++ to that compiler. Differential Revision: https://reviews.llvm.org/D107905
2021-08-11 22:34:51 +08:00
# define __cpp_lib_addressof_constexpr 201603L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_allocator_traits_is_always_equal 201411L
# define __cpp_lib_any 201606L
# define __cpp_lib_apply 201603L
# define __cpp_lib_array_constexpr 201603L
# define __cpp_lib_as_const 201510L
[libc++] Enable <atomic> when threads are disabled std::atomic is, for the most part, just a thin veneer on top of compiler builtins. Hence, it should be available even when threads are not available on the system, and in fact there has been requests for such support. This patch: - Moves __libcpp_thread_poll_with_backoff to its own header so it can be used in <atomic> when threads are disabled. - Adds a dummy backoff policy for atomic polling that doesn't know about threads. - Adjusts the <atomic> feature-test macros so they are provided even when threads are disabled. - Runs the <atomic> tests when threads are disabled. rdar://77873569 Differential Revision: https://reviews.llvm.org/D114109
2021-11-17 23:59:31 +08:00
# define __cpp_lib_atomic_is_always_lock_free 201603L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_bool_constant 201505L
// # define __cpp_lib_boyer_moore_searcher 201603L
# define __cpp_lib_byte 201603L
# define __cpp_lib_chrono 201611L
# define __cpp_lib_clamp 201603L
# define __cpp_lib_enable_shared_from_this 201603L
// # define __cpp_lib_execution 201603L
[libc++] Make feature-test macros consistent with availability macros Before this patch, feature-test macros didn't take special availability markup into account, which means that feature-test macros can sometimes appear to "lie". For example, if you compile in C++20 mode and target macOS 10.13, the __cpp_lib_filesystem feature-test macro will be provided even though the <filesystem> declarations are marked as unavailable. This patch fixes that. rdar://68142369 Differential Revision: https://reviews.llvm.org/D94983
2021-01-20 02:04:01 +08:00
# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
# define __cpp_lib_filesystem 201703L
# endif
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_gcd_lcm 201606L
[libc++] Mark __cpp_lib_hardware_interference_size as unimplemented. This fxes bug PR41423. Summary: As described in the bug report: The commit a8b9f59e8caf378d56e8bfcecdb22184cdabf42d "Implement feature test macros using a script" added test features macros for libc++. Among others, it added `__cpp_lib_hardware_interference_size`. However, there is nothing like std::hardware_constructive_interference_size nor std::hardware_destructive_interference_size, that should be in header <new>. * https://bugs.llvm.org/show_bug.cgi?id=41423 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D80431
2020-05-23 20:31:05 +08:00
// # define __cpp_lib_hardware_interference_size 201703L
[libc++] Remove _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS All supported compilers have implemented __has_unique_object_representations for a while, so it's reasonable to remove the workaround. Differential Revision: https://reviews.llvm.org/D107834
2021-08-10 23:35:27 +08:00
# define __cpp_lib_has_unique_object_representations 201606L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_hypot 201603L
# define __cpp_lib_incomplete_container_elements 201505L
Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955 llvm-svn: 342073
2018-09-13 03:41:40 +08:00
# define __cpp_lib_invoke 201411L
[libc++] Remove _LIBCPP_HAS_NO_IS_AGGREGATE All supported compilers have been supporting __is_aggregate for a long time now, so it's reasonable to remove this workaround. Differential Revision: https://reviews.llvm.org/D107833
2021-08-11 00:44:20 +08:00
# define __cpp_lib_is_aggregate 201703L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_is_invocable 201703L
# define __cpp_lib_is_swappable 201603L
# define __cpp_lib_launder 201606L
# define __cpp_lib_logical_traits 201510L
# define __cpp_lib_make_from_tuple 201606L
# define __cpp_lib_map_try_emplace 201411L
// # define __cpp_lib_math_special_functions 201603L
// # define __cpp_lib_memory_resource 201603L
Second half of C++17's splicing maps and sets This commit adds a merge member function to all the map and set containers, which splices nodes from the source container. This completes support for P0083r3. Differential revision: https://reviews.llvm.org/D48896 llvm-svn: 345744
2018-11-01 01:31:35 +08:00
# define __cpp_lib_node_extract 201606L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_nonmember_container_access 201411L
# define __cpp_lib_not_fn 201603L
# define __cpp_lib_optional 201606L
// # define __cpp_lib_parallel_algorithm 201603L
# define __cpp_lib_raw_memory_algorithms 201606L
# define __cpp_lib_sample 201603L
# define __cpp_lib_scoped_lock 201703L
[libc++] Make feature-test macros consistent with availability macros Before this patch, feature-test macros didn't take special availability markup into account, which means that feature-test macros can sometimes appear to "lie". For example, if you compile in C++20 mode and target macOS 10.13, the __cpp_lib_filesystem feature-test macro will be provided even though the <filesystem> declarations are marked as unavailable. This patch fixes that. rdar://68142369 Differential Revision: https://reviews.llvm.org/D94983
2021-01-20 02:04:01 +08:00
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)
Fix feature test macros for atomics/mutexes without threading llvm-svn: 351291
2019-01-16 10:10:28 +08:00
# define __cpp_lib_shared_mutex 201505L
# endif
[libc++] Implement missing feature-test macro __cpp_lib_shared_ptr_arrays This was forgotten when we implemented support for arrays in std::shared_ptr in https://reviews.llvm.org/D62259.
2020-12-09 04:45:57 +08:00
# define __cpp_lib_shared_ptr_arrays 201611L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_shared_ptr_weak_type 201606L
# define __cpp_lib_string_view 201606L
// # define __cpp_lib_to_chars 201611L
# undef __cpp_lib_transparent_operators
# define __cpp_lib_transparent_operators 201510L
# define __cpp_lib_type_trait_variable_templates 201510L
# define __cpp_lib_uncaught_exceptions 201411L
# define __cpp_lib_unordered_map_try_emplace 201411L
[libc++] [C++2b] [P2162] Allow inheritance from std::variant. This patch changes the variant even in pre-C++2b. It should not break anything, only allow use cases that didn't work previously. Notes: `__as_variant` is used in `__visitation::__variant::__visit_alt`, but I haven't used it in `__visitation::__variant::__visit_alt_at`. That's because it is used only in `__visit_value_at`, which in turn is always used on variant specializations (that's in comparison operators). * https://wg21.link/P2162 Reviewed By: ldionne, #libc, Quuxplusone Differential Revision: https://reviews.llvm.org/D97394
2021-03-26 01:09:11 +08:00
# define __cpp_lib_variant 202102L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_void_t 201411L
Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955 llvm-svn: 342073
2018-09-13 03:41:40 +08:00
#endif
#if _LIBCPP_STD_VER > 17
[libc++] Complete overhaul of constexpr support in std::array This commit adds missing support for constexpr in std::array under all standard modes up to and including C++20. It also transforms the <array> tests to check for constexpr-friendliness under the right standard modes. Fixes https://llvm.org/PR40124 Fixes rdar://57522096 Supersedes https://reviews.llvm.org/D60666 Differential Revision: https://reviews.llvm.org/D80452
2020-05-22 21:59:48 +08:00
# undef __cpp_lib_array_constexpr
# define __cpp_lib_array_constexpr 201811L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
// # define __cpp_lib_assume_aligned 201811L
[libc++] Enable <atomic> when threads are disabled std::atomic is, for the most part, just a thin veneer on top of compiler builtins. Hence, it should be available even when threads are not available on the system, and in fact there has been requests for such support. This patch: - Moves __libcpp_thread_poll_with_backoff to its own header so it can be used in <atomic> when threads are disabled. - Adds a dummy backoff policy for atomic polling that doesn't know about threads. - Adjusts the <atomic> feature-test macros so they are provided even when threads are disabled. - Runs the <atomic> tests when threads are disabled. rdar://77873569 Differential Revision: https://reviews.llvm.org/D114109
2021-11-17 23:59:31 +08:00
# define __cpp_lib_atomic_flag_test 201907L
// # define __cpp_lib_atomic_float 201711L
# define __cpp_lib_atomic_lock_free_type_aliases 201907L
// # define __cpp_lib_atomic_ref 201806L
// # define __cpp_lib_atomic_shared_ptr 201711L
# define __cpp_lib_atomic_value_initialization 201911L
# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
Update atomic feature macros, synopsis, signatures to match C++20. Improve test coverage for non-lock-free atomics.
2020-09-10 01:00:09 +08:00
# define __cpp_lib_atomic_wait 201907L
# endif
[libc++] Make feature-test macros consistent with availability macros Before this patch, feature-test macros didn't take special availability markup into account, which means that feature-test macros can sometimes appear to "lie". For example, if you compile in C++20 mode and target macOS 10.13, the __cpp_lib_filesystem feature-test macro will be provided even though the <filesystem> declarations are marked as unavailable. This patch fixes that. rdar://68142369 Differential Revision: https://reviews.llvm.org/D94983
2021-01-20 02:04:01 +08:00
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
# define __cpp_lib_barrier 201907L
# endif
[libc++] Add bind_front function (P0356R5). Implementes [[ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0356r5.html | P0356R5 ]]. Adds `bind_front` to `functional`. Reviewed By: ldionne, #libc, Quuxplusone Differential Revision: https://reviews.llvm.org/D60368
2021-03-03 08:17:22 +08:00
# define __cpp_lib_bind_front 201907L
[libc++] Implement C++20's P0476R2: std::bit_cast Thanks to Arthur O'Dwyer for fixing up some of the tests. Differential Revision: https://reviews.llvm.org/D75960
2020-05-29 02:28:38 +08:00
# define __cpp_lib_bit_cast 201806L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
// # define __cpp_lib_bitops 201907L
# define __cpp_lib_bounded_array_traits 201902L
[libc++] s/_LIBCPP_NO_HAS_CHAR8_T/_LIBCPP_HAS_NO_CHAR8_T/g This was raised in D94511. Differential Revision: https://reviews.llvm.org/D100736
2021-04-19 09:47:08 +08:00
# if !defined(_LIBCPP_HAS_NO_CHAR8_T)
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
# define __cpp_lib_char8_t 201811L
# endif
[libcxx] adds __cpp_lib_concepts feature-test macro Also adjusts C++20 status paper to indicate full concepts support. Depends on D96477, D99817. Differential Revision: https://reviews.llvm.org/D99805
2021-04-03 02:07:31 +08:00
# define __cpp_lib_concepts 202002L
[libc++] [P0879] constexpr std::sort This completes libc++'s implementation of P0879 "Constexpr for swap and swap related functions." http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0879r0.html For the feature-macro adjustment, see https://cplusplus.github.io/LWG/issue3256 Differential Revision: https://reviews.llvm.org/D93661
2020-12-21 04:21:42 +08:00
# define __cpp_lib_constexpr_algorithms 201806L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
// # define __cpp_lib_constexpr_complex 201711L
[libc++] Implement C++20's P0784 (More constexpr containers) This commit adds std::construct_at, and marks various members of std::allocator_traits and std::allocator as constexpr. It also adds tests and turns the existing tests into hybrid constexpr/runtime tests. Thanks to Richard Smith for initial work on this, and to Michael Park for D69803, D69132 and D69134, which are superseded by this patch. Differential Revision: https://reviews.llvm.org/D68364
2020-09-18 00:06:13 +08:00
# define __cpp_lib_constexpr_dynamic_alloc 201907L
Re-enable __cpp_lib_constexpr_functional. I accidentally disabled this feature-test macro in my D93830, due to a rebasing conflict. It had been enabled by my D93815, and should have remained enabled.
2021-01-09 06:28:19 +08:00
# define __cpp_lib_constexpr_functional 201907L
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
# define __cpp_lib_constexpr_iterator 201811L
[libc++] Mark __cpp_lib_constexpr_memory as being implemented
2021-02-16 04:26:29 +08:00
# define __cpp_lib_constexpr_memory 201811L
[libc++] P1645 constexpr for <numeric> Implements P1645: constexpr for <numeric> algorithms Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D90569
2020-11-28 21:50:53 +08:00
# define __cpp_lib_constexpr_numeric 201911L
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
# define __cpp_lib_constexpr_string 201811L
# define __cpp_lib_constexpr_string_view 201811L
# define __cpp_lib_constexpr_tuple 201811L
Add constexpr to pair Reviewed By: #libc, ldionne Differential Revision: https://reviews.llvm.org/D80558
2020-09-03 03:20:33 +08:00
# define __cpp_lib_constexpr_utility 201811L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
// # define __cpp_lib_constexpr_vector 201907L
[libcxx] [Coroutine] Conform Coroutine Implementation Since coroutine is merged in C++ standard and the support for coroutine seems relatively stable. It's the time to move the implementation of coroutine out of the experimental directory and the std::experimental namespace. This patch creates header <coroutine> with conformed implementation with C++ standard. To avoid breaking user's code too fast, the <experimental/coroutine> header is remained. Note that <experimental/coroutine> is deprecated and it would be removed in LLVM15. Reviewed By: Quuxplusone, ldionne Differential Revision: https://reviews.llvm.org/D109433
2021-11-16 14:05:34 +08:00
# define __cpp_lib_coroutine 201902L
P0722R3: Implement library support for destroying delete Summary: This provides the `std::destroying_delete_t` declaration in C++2a and after. (Even when the compiler doesn't support the language feature). However, the feature test macro `__cpp_lib_destroying_delete` is only defined when we have both language support and C++2a. Reviewers: ldionne, ckennelly, serge-sans-paille, EricWF Reviewed By: EricWF Subscribers: dexonsmith, riccibruno, christof, jwakely, jdoerfert, mclow.lists, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D55840 llvm-svn: 361572
2019-05-24 07:46:44 +08:00
# if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
# define __cpp_lib_destroying_delete 201806L
# endif
[libc++] [P1612] Add missing feature-test macro __cpp_lib_endian. Thanks to Marek Kurdej for the patch. Differential Revision: https://reviews.llvm.org/D70221
2019-11-14 21:54:23 +08:00
# define __cpp_lib_endian 201907L
[libc++][P1115][C++20] Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if. Summary: This patch adds return type to std::erase and std::erase_if functions. Also: * Update __cpp_lib_erase_if to 202002L. * Fix synopsis in unordered_map. * Fix generate_feature_test_macro_components.py script. Reviewers: EricWF, mclow.lists, ldionne, #libc Reviewed By: ldionne, #libc Subscribers: broadwaylamb, zoecarver, dexonsmith, ldionne, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D75905
2020-05-02 19:58:03 +08:00
# define __cpp_lib_erase_if 202002L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
# undef __cpp_lib_execution
// # define __cpp_lib_execution 201902L
[libc++][format] Adds availability macros for std::format. This prevents std::format to be available until there's an ABI stable version. (This only impacts the Apple platform.) Depends on D102703 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D102705
2021-05-19 02:00:22 +08:00
# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format)
[libc++][format][1/6] Reduce binary size. This removes the `format_args_t` from `<format>` and adjusts the type of the `format_args` for the `vformat_to` overloads. The `format_context` uses a `back_insert_iterator<string>` therefore the new `output_iterator` function uses a `string` as its temporary storage buffer. This isn't ideal. The next patches in this series will improve this. These improvements make it easy to also improve `format_to_n` and `formatted_size`. This addresses P2216 `6. Binary size`. P2216 `5. Compile-time checks` are not part of this change. Implements parts of: - P2216 std::format improvements Depends on D103670 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D110494
2021-09-04 19:26:58 +08:00
// # define __cpp_lib_format 202106L
[libc++][format] Adds availability macros for std::format. This prevents std::format to be available until there's an ABI stable version. (This only impacts the Apple platform.) Depends on D102703 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D102705
2021-05-19 02:00:22 +08:00
# endif
[libc++] Implement P0919R3: heterogenous lookup for unordered containers Implement heterogenous lookup for unordered containers, including the refinement from P1690R1. Differential Revision: https://reviews.llvm.org/D87171
2020-11-10 20:49:55 +08:00
# define __cpp_lib_generic_unordered_lookup 201811L
[libcxx] Implement P1956 rename low-level bit functions Implements P1956: On the names of low-level bit manipulation functions. Users may use older versions of libc++ or other standard libraries with the old names. In order to keep compatibility the old functions are kept, but marked as deprecated. The patch also adds a new config macro `_LIBCPP_DEPRECATED_MSG`. Do you prefer a this is a separate patch? Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D90551
2020-11-24 21:50:49 +08:00
# define __cpp_lib_int_pow2 202002L
[libc++] [C++20] [P0586] Implement safe integral comparisons * https://wg21.link/P0586 Reviewed By: #libc, curdeius, Quuxplusone Differential Revision: https://reviews.llvm.org/D94511
2021-04-20 07:18:34 +08:00
# if !defined(_LIBCPP_HAS_NO_CONCEPTS)
# define __cpp_lib_integer_comparison_functions 202002L
# endif
Implement midpoint for floating point types. Reviewed as https://reviews.llvm.org/D61014. llvm-svn: 359184
2019-04-25 20:11:43 +08:00
# define __cpp_lib_interpolate 201902L
[libcxx] Remove _LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED All supported compilers should support _LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED so this can be removed. Reviewed By: ldionne, #libc, Quuxplusone Differential Revision: https://reviews.llvm.org/D107239
2021-08-02 02:01:51 +08:00
# define __cpp_lib_is_constant_evaluated 201811L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
// # define __cpp_lib_is_layout_compatible 201907L
# define __cpp_lib_is_nothrow_convertible 201806L
// # define __cpp_lib_is_pointer_interconvertible 201907L
# if !defined(_LIBCPP_HAS_NO_THREADS)
// # define __cpp_lib_jthread 201911L
# endif
[libc++] Make feature-test macros consistent with availability macros Before this patch, feature-test macros didn't take special availability markup into account, which means that feature-test macros can sometimes appear to "lie". For example, if you compile in C++20 mode and target macOS 10.13, the __cpp_lib_filesystem feature-test macro will be provided even though the <filesystem> declarations are marked as unavailable. This patch fixes that. rdar://68142369 Differential Revision: https://reviews.llvm.org/D94983
2021-01-20 02:04:01 +08:00
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
# define __cpp_lib_latch 201907L
# endif
[libc++] [P0646] Add feature-test macro for __cpp_lib_list_remove_return_type. Summary: The return type modification has already been implemented in rL364840 and rL365290. Reviewers: ldionne, mclow.lists, EricWF, #libc! Reviewed By: ldionne Subscribers: christof, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D70275
2019-11-15 06:20:24 +08:00
# define __cpp_lib_list_remove_return_type 201806L
[libcxx] updates the feature-test macro generator D97015 didn't correctly update `generate_feature_test_macro_components.py`. Reviewed By: ldionne, Quuxplusone, #libc, Mordante Differential Revision: https://reviews.llvm.org/D97904
2021-03-18 02:11:31 +08:00
# if !defined(_LIBCPP_HAS_NO_CONCEPTS)
[libc++] Require concepts support for <numbers> Similar to <concepts>, we need to protect the header and test against inclusion and being run if concepts aren't supported by the compiler. Differential Revision: https://reviews.llvm.org/D82171
2020-06-19 22:36:44 +08:00
# define __cpp_lib_math_constants 201907L
# endif
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
// # define __cpp_lib_polymorphic_allocator 201902L
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
// # define __cpp_lib_ranges 201811L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
# define __cpp_lib_remove_cvref 201711L
[libc++] Make feature-test macros consistent with availability macros Before this patch, feature-test macros didn't take special availability markup into account, which means that feature-test macros can sometimes appear to "lie". For example, if you compile in C++20 mode and target macOS 10.13, the __cpp_lib_filesystem feature-test macro will be provided even though the <filesystem> declarations are marked as unavailable. This patch fixes that. rdar://68142369 Differential Revision: https://reviews.llvm.org/D94983
2021-01-20 02:04:01 +08:00
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
# define __cpp_lib_semaphore 201907L
# endif
[libc++] Implement [P0769] "Add shift to algorithm" (shift_left, shift_right) I believe this is a complete implementation of std::shift_left and std::shift_right from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0769r2.pdf Some test cases copied-with-modification from D60027. Differential Revision: https://reviews.llvm.org/D93819
2020-12-26 14:39:03 +08:00
# define __cpp_lib_shift 201806L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
// # define __cpp_lib_smart_ptr_for_overwrite 202002L
// # define __cpp_lib_source_location 201907L
[libcxx][span] Implement P1976R2 This resolves the NB comment about the construction of a fixed-size span from a dynamic range. Differential Revision: https://reviews.llvm.org/D74577
2020-05-13 21:50:06 +08:00
# define __cpp_lib_span 202002L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
# define __cpp_lib_ssize 201902L
# define __cpp_lib_starts_ends_with 201711L
# undef __cpp_lib_string_view
# define __cpp_lib_string_view 201803L
// # define __cpp_lib_syncbuf 201803L
// # define __cpp_lib_three_way_comparison 201907L
# define __cpp_lib_to_address 201711L
[libcxx][span] Implement P1976R2 This resolves the NB comment about the construction of a fixed-size span from a dynamic range. Differential Revision: https://reviews.llvm.org/D74577
2020-05-13 21:50:06 +08:00
# define __cpp_lib_to_array 201907L
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
# define __cpp_lib_type_identity 201806L
[libc++] Update generate_feature_test_macro_components.py to match SD-6. It's still a little confusing because in many cases C++17 and C++20 have different values, and libc++ implements the C++17 behavior but not the C++20 behavior; 'unimplemented' can't represent that scenario. Ultimately we probably ought to completely redesign the script to be in terms of paper numbers, rather than language revisions, and make it generate the CSV files like "Cxx2aStatusPaperStatus.csv" as well. Most newly added macros are unimplemented. I've marked a few as implemented, though, based on my reading of the code; for example I was pretty sure `__cpp_lib_latch` is implemented since we have `<latch>`. Differential Revision: https://reviews.llvm.org/D93830
2021-01-08 07:21:07 +08:00
# define __cpp_lib_unwrap_ref 201811L
Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955 llvm-svn: 342073
2018-09-13 03:41:40 +08:00
#endif
[libc++] Add basic support for -std=c++2b. * Add feature test macros. * Add buildbot configuration generic-cxx2b that uses clang-tot. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D94227
2021-01-09 01:40:42 +08:00
#if _LIBCPP_STD_VER > 20
[libc++] Implement P1425R4 (Iterator pair constructors for std::stack and std::queue) Implement P1425R4 Reviewed By: Quuxplusone, #libc, Mordante Spies: Mordante, jloser, libcxx-commits, arichardson Differential Revision: https://reviews.llvm.org/D115977
2022-01-06 19:36:07 +08:00
# define __cpp_lib_adaptor_iterator_pair_constructor 202106L
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
// # define __cpp_lib_allocate_at_least 202106L
// # define __cpp_lib_associative_heterogeneous_erasure 202110L
[libc++] Implement P1272R4 (std::byteswap) Implement P1274R4 Reviewed By: Quuxplusone, Mordante, #libc Spies: jloser, lebedev.ri, mgorny, libcxx-commits, arichardson Differential Revision: https://reviews.llvm.org/D114074
2021-11-22 07:22:55 +08:00
# define __cpp_lib_byteswap 202110L
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
// # define __cpp_lib_constexpr_typeinfo 202106L
// # define __cpp_lib_invoke_r 202106L
[libc++] [C++2b] [P1048] Add is_scoped_enum and is_scoped_enum_v. * https://wg21.link/p1048 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D94409
2021-01-13 00:06:58 +08:00
# define __cpp_lib_is_scoped_enum 202011L
[libc++] Implement P0798R8 (Monadic operations for std::optional) Implement P0798R8 Reviewed By: #libc, ldionne, Quuxplusone Spies: tcanens, Quuxplusone, ldionne, Wmbat, arichardson, Mordante, libcxx-commits Differential Revision: https://reviews.llvm.org/D113408
2021-12-16 03:54:24 +08:00
# define __cpp_lib_monadic_optional 202110L
[libc++] [P0887] Add newest feature-test macros; mark `type_identity` as implemented. `__cpp_lib_type_identity` was implemented way back in cf49ccd0 (Clang 8), probably before the feature-test macro had been settled on. `__cpp_lib_string_resize_and_overwrite` will be added by D113013 so I didn't add it here. Fixes #46605. Differential Revision: https://reviews.llvm.org/D116433
2021-12-31 12:28:12 +08:00
// # define __cpp_lib_move_only_function 202110L
// # define __cpp_lib_out_ptr 202106L
// # define __cpp_lib_ranges_starts_ends_with 202106L
// # define __cpp_lib_ranges_zip 202110L
// # define __cpp_lib_spanstream 202106L
[libc++] Add basic support for -std=c++2b. * Add feature test macros. * Add buildbot configuration generic-cxx2b that uses clang-tot. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D94227
2021-01-09 01:40:42 +08:00
// # define __cpp_lib_stacktrace 202011L
// # define __cpp_lib_stdatomic_h 202011L
[libc++][P1679] add string contains C++23 string contains implementation and tests Paper: https://wg21.link/P1679R3 Standard (string): https://eel.is/c++draft/string.contains Standard (string_view): https://eel.is/c++draft/string.view.ops#lib:contains,basic_string_view Differential Revision: https://reviews.llvm.org/D93912
2021-01-20 03:33:30 +08:00
# define __cpp_lib_string_contains 202011L
[libc++] Implement P1072R10 (std::basic_string::resize_and_overwrite) Reviewed By: Quuxplusone, #libc, Mordante Spies: mzeren-vmw, ckennelly, arichardson, ldionne, Mordante, libcxx-commits, Quuxplusone Differential Revision: https://reviews.llvm.org/D113013
2022-01-07 04:43:26 +08:00
# define __cpp_lib_string_resize_and_overwrite 202110L
[libc++] [C++2b] [P1682] Add to_underlying. * https://wg21.link/P1682 Reviewed By: ldionne, Mordante, #libc Differential Revision: https://reviews.llvm.org/D97365
2021-03-05 16:19:39 +08:00
# define __cpp_lib_to_underlying 202102L
[libc++] Add basic support for -std=c++2b. * Add feature test macros. * Add buildbot configuration generic-cxx2b that uses clang-tot. Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D94227
2021-01-09 01:40:42 +08:00
#endif
[libc++] Turn off clang-format for auto-generated version header. NFC.
2021-02-19 21:10:12 +08:00
// clang-format on
Implement feature test macros using a script. Summary: This patch implements all the feature test macros libc++ currently supports, as specified by the standard or cppreference prior to C++2a. The tests and `<version>` header are generated using a script. The script contains a table of each feature test macro, the headers it should be accessible from, and its values of each dialect of C++. When a new feature test macro is added or needed, the table should be updated and the script re-run. Reviewers: mclow.lists, jfb, serge-sans-paille Reviewed By: mclow.lists Subscribers: arphaman, jfb, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D56750 llvm-svn: 351286
2019-01-16 09:37:43 +08:00
#endif // _LIBCPP_VERSIONH