Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-04-12 11:23:33 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
llvm-capstone/libcxx/utils/generate_feature_test_macro_components.py
Mark de Wever 88622aabf1 [libc++][format] Implements formatter thread::id. 
Since stacktrace header is WIP and it's not sure that will be done
before LLVM17 update the documentation. When the header is implemented
implementing the formatter is trivial, so that can be done quickly
afterwards.

Implements parts of:
 - P2693R1 Formatting thread::id and stacktrace

Reviewed By: #libc, ldionne

Differential Revision: https://reviews.llvm.org/D144331
2023-04-08 16:39:34 +02:00

1234 lines
39 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python
import os
from builtins import range
from functools import reduce
def get_libcxx_paths():
utils_path = os.path.dirname(os.path.abspath(__file__))
script_name = os.path.basename(__file__)
assert os.path.exists(utils_path)
src_root = os.path.dirname(utils_path)
include_path = os.path.join(src_root, 'include')
assert os.path.exists(include_path)
docs_path = os.path.join(src_root, 'docs')
assert os.path.exists(docs_path)
macro_test_path = os.path.join(src_root, 'test', 'std', 'language.support',
'support.limits', 'support.limits.general')
assert os.path.exists(macro_test_path)
assert os.path.exists(os.path.join(macro_test_path, 'version.version.compile.pass.cpp'))
return script_name, src_root, include_path, docs_path, macro_test_path
script_name, source_root, include_path, docs_path, macro_test_path = get_libcxx_paths()
def has_header(h):
h_path = os.path.join(include_path, h)
return os.path.exists(h_path)
def add_version_header(tc):
tc["headers"].append("version")
return tc
# ================ ============================================================
# Field Description
# ================ ============================================================
# name The name of the feature-test macro.
# values A dict whose keys are C++ versions and whose values are the
# value of the feature-test macro for that C++ version.
# (TODO: This isn't a very clean model for feature-test
# macros affected by multiple papers.)
# headers An array with the headers that should provide the
# feature-test macro.
# test_suite_guard An optional string field. When this field is provided,
# `libcxx_guard` must also be provided. This field is used
# only to generate the unit tests for the feature-test macros.
# It can't depend on macros defined in <__config> because the
# `test/std/` parts of the test suite are intended to be
# portable to any C++ standard library implementation, not
# just libc++. It may depend on
# * macros defined by the compiler itself, or
# * macros generated by CMake.
# In some cases we add also depend on macros defined in <__availability>.
# libcxx_guard An optional string field. When this field is provided,
# `test_suite_guard` must also be provided. This field is used
# only to guard the feature-test macro in <version>. It may
# be the same as `test_suite_guard`, or it may depend on
# macros defined in <__config>.
# unimplemented An optional Boolean field with the value `True`. This field
# is only used when a feature isn't fully implemented. Once
# you've fully implemented the feature, you should remove
# this field.
# ================ ============================================================
feature_test_macros = [ add_version_header(x) for x in [
{
"name": "__cpp_lib_adaptor_iterator_pair_constructor",
"values": { "c++2b": 202106 },
"headers": ["queue", "stack"],
}, {
"name": "__cpp_lib_addressof_constexpr",
"values": { "c++17": 201603 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_allocate_at_least",
"values": { "c++2b": 202106 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_allocator_traits_is_always_equal",
"values": { "c++17": 201411 },
"headers": ["deque", "forward_list", "list", "map", "memory", "scoped_allocator", "set", "string", "unordered_map", "unordered_set", "vector"],
}, {
"name": "__cpp_lib_any",
"values": { "c++17": 201606 },
"headers": ["any"],
}, {
"name": "__cpp_lib_apply",
"values": { "c++17": 201603 },
"headers": ["tuple"],
}, {
"name": "__cpp_lib_array_constexpr",
"values": { "c++17": 201603, "c++20": 201811 },
"headers": ["array", "iterator"],
}, {
"name": "__cpp_lib_as_const",
"values": { "c++17": 201510 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_associative_heterogeneous_erasure",
"values": { "c++2b": 202110 },
"headers": ["map", "set", "unordered_map", "unordered_set"],
"unimplemented": True,
}, {
"name": "__cpp_lib_assume_aligned",
"values": { "c++20": 201811 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_atomic_flag_test",
"values": { "c++20": 201907 },
"headers": ["atomic"],
}, {
"name": "__cpp_lib_atomic_float",
"values": { "c++20": 201711 },
"headers": ["atomic"],
"unimplemented": True,
}, {
"name": "__cpp_lib_atomic_is_always_lock_free",
"values": { "c++17": 201603 },
"headers": ["atomic"],
}, {
"name": "__cpp_lib_atomic_lock_free_type_aliases",
"values": { "c++20": 201907 },
"headers": ["atomic"],
}, {
"name": "__cpp_lib_atomic_ref",
"values": { "c++20": 201806 },
"headers": ["atomic"],
"unimplemented": True,
}, {
"name": "__cpp_lib_atomic_shared_ptr",
"values": { "c++20": 201711 },
"headers": ["atomic"],
"unimplemented": True,
}, {
"name": "__cpp_lib_atomic_value_initialization",
"values": { "c++20": 201911 },
"headers": ["atomic", "memory"],
}, {
"name": "__cpp_lib_atomic_wait",
"values": { "c++20": 201907 },
"headers": ["atomic"],
"test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
"libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
}, {
"name": "__cpp_lib_barrier",
"values": { "c++20": 201907 },
"headers": ["barrier"],
"test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
}, {
"name": "__cpp_lib_bind_back",
"values": { "c++2b": 202202 },
"headers": ["functional"],
"unimplemented": True,
}, {
"name": "__cpp_lib_bind_front",
"values": { "c++20": 201907 },
"headers": ["functional"],
}, {
"name": "__cpp_lib_bit_cast",
"values": { "c++20": 201806 },
"headers": ["bit"],
}, {
"name": "__cpp_lib_bitops",
"values": { "c++20": 201907 },
"headers": ["bit"],
"unimplemented": True,
}, {
"name": "__cpp_lib_bool_constant",
"values": { "c++17": 201505 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_bounded_array_traits",
"values": { "c++20": 201902 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_boyer_moore_searcher",
"values": { "c++17": 201603 },
"headers": ["functional"],
}, {
"name": "__cpp_lib_byte",
"values": { "c++17": 201603 },
"headers": ["cstddef"],
}, {
"name": "__cpp_lib_byteswap",
"values": { "c++2b": 202110 },
"headers": ["bit"],
}, {
"name": "__cpp_lib_char8_t",
"values": { "c++20": 201907 },
"headers": ["atomic", "filesystem", "istream", "limits", "locale", "ostream", "string", "string_view"],
"test_suite_guard": "defined(__cpp_char8_t)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_CHAR8_T)",
}, {
"name": "__cpp_lib_chrono",
"values": { "c++17": 201611 },
"headers": ["chrono"],
}, {
"name": "__cpp_lib_chrono_udls",
"values": { "c++14": 201304 },
"headers": ["chrono"],
}, {
"name": "__cpp_lib_clamp",
"values": { "c++17": 201603 },
"headers": ["algorithm"],
}, {
"name": "__cpp_lib_complex_udls",
"values": { "c++14": 201309 },
"headers": ["complex"],
}, {
"name": "__cpp_lib_concepts",
"values": { "c++20": 202002 },
"headers": ["concepts"],
}, {
"name": "__cpp_lib_constexpr_algorithms",
"values": { "c++20": 201806 },
"headers": ["algorithm", "utility"],
}, {
"name": "__cpp_lib_constexpr_bitset",
"values": { "c++2b": 202207 },
"headers": ["bitset"],
}, {
"name": "__cpp_lib_constexpr_charconv",
"values": { "c++2b": 202207 },
"headers": ["charconv"],
}, {
"name": "__cpp_lib_constexpr_cmath",
"values": { "c++2b": 202202 },
"headers": ["cmath", "cstdlib"],
"unimplemented": True,
}, {
"name": "__cpp_lib_constexpr_complex",
"values": { "c++20": 201711 },
"headers": ["complex"],
}, {
"name": "__cpp_lib_constexpr_dynamic_alloc",
"values": { "c++20": 201907 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_constexpr_functional",
"values": { "c++20": 201907 },
"headers": ["functional"],
}, {
"name": "__cpp_lib_constexpr_iterator",
"values": { "c++20": 201811 },
"headers": ["iterator"],
}, {
"name": "__cpp_lib_constexpr_memory",
"values": { "c++20": 201811, "c++2b": 202202 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_constexpr_numeric",
"values": { "c++20": 201911 },
"headers": ["numeric"],
}, {
"name": "__cpp_lib_constexpr_string",
"values": { "c++20": 201907 },
"headers": ["string"],
}, {
"name": "__cpp_lib_constexpr_string_view",
"values": { "c++20": 201811 },
"headers": ["string_view"],
}, {
"name": "__cpp_lib_constexpr_tuple",
"values": { "c++20": 201811 },
"headers": ["tuple"],
}, {
"name": "__cpp_lib_constexpr_typeinfo",
"values": { "c++2b": 202106 },
"headers": ["typeinfo"],
}, {
"name": "__cpp_lib_constexpr_utility",
"values": { "c++20": 201811 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_constexpr_vector",
"values": { "c++20": 201907 },
"headers": ["vector"],
}, {
"name": "__cpp_lib_coroutine",
"values": { "c++20": 201902 },
"headers": ["coroutine"],
}, {
"name": "__cpp_lib_destroying_delete",
"values": { "c++20": 201806 },
"headers": ["new"],
"test_suite_guard": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
"libcxx_guard": "_LIBCPP_STD_VER >= 20 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
}, {
"name": "__cpp_lib_enable_shared_from_this",
"values": { "c++17": 201603 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_endian",
"values": { "c++20": 201907 },
"headers": ["bit"],
}, {
"name": "__cpp_lib_erase_if",
"values": { "c++20": 202002 },
"headers": ["deque", "forward_list", "list", "map", "set", "string", "unordered_map", "unordered_set", "vector"],
}, {
"name": "__cpp_lib_exchange_function",
"values": { "c++14": 201304 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_execution",
"values": { "c++17": 201603, "c++20": 201902 },
"headers": ["execution"],
"unimplemented": True,
}, {
"name": "__cpp_lib_expected",
"values": { "c++2b": 202202 },
"headers": ["expected"],
}, {
"name": "__cpp_lib_filesystem",
"values": { "c++17": 201703 },
"headers": ["filesystem"],
"test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_FILESYSTEM)",
"libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_FILESYSTEM)"
}, {
"name": "__cpp_lib_format",
"values": {
# "c++20": 201907 Not implemented P1361R2 Integration of chrono with text formatting
# "c++20": 202106 Fully implemented
# "c++20": 202110 Not implemented P2372R3 Fixing locale handling in chrono formatters
"c++20": 202106,
# "c++23": 202207, Not implemented P2419R2 Clarify handling of encodings in localized formatting of chrono types
},
"headers": ["format"],
"test_suite_guard": "!defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)",
"unimplemented": True,
}, {
"name": "__cpp_lib_formatters",
"values": { "c++2b": 202302 },
"headers": ["stacktrace", "thread"],
"test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)",
"libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)",
"unimplemented": True,
}, {
"name": "__cpp_lib_forward_like",
"values": { "c++2b": 202207 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_gcd_lcm",
"values": { "c++17": 201606 },
"headers": ["numeric"],
}, {
"name": "__cpp_lib_generic_associative_lookup",
"values": { "c++14": 201304 },
"headers": ["map", "set"],
}, {
"name": "__cpp_lib_generic_unordered_lookup",
"values": { "c++20": 201811 },
"headers": ["unordered_map", "unordered_set"],
}, {
"name": "__cpp_lib_hardware_interference_size",
"values": { "c++17": 201703 },
"test_suite_guard": "defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)",
"libcxx_guard": "defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)",
"headers": ["new"],
}, {
"name": "__cpp_lib_has_unique_object_representations",
"values": { "c++17": 201606 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_hypot",
"values": { "c++17": 201603 },
"headers": ["cmath"],
}, {
"name": "__cpp_lib_incomplete_container_elements",
"values": { "c++17": 201505 },
"headers": ["forward_list", "list", "vector"],
}, {
"name": "__cpp_lib_int_pow2",
"values": { "c++20": 202002 },
"headers": ["bit"],
}, {
"name": "__cpp_lib_integer_comparison_functions",
"values": { "c++20": 202002 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_integer_sequence",
"values": { "c++14": 201304 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_integral_constant_callable",
"values": { "c++14": 201304 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_interpolate",
"values": { "c++20": 201902 },
"headers": ["cmath", "numeric"],
}, {
"name": "__cpp_lib_invoke",
"values": { "c++17": 201411 },
"headers": ["functional"],
}, {
"name": "__cpp_lib_invoke_r",
"values": { "c++2b": 202106 },
"headers": ["functional"],
}, {
"name": "__cpp_lib_is_aggregate",
"values": { "c++17": 201703 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_is_constant_evaluated",
"values": { "c++20": 201811 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_is_final",
"values": { "c++14": 201402 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_is_invocable",
"values": { "c++17": 201703 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_is_layout_compatible",
"values": { "c++20": 201907 },
"headers": ["type_traits"],
"unimplemented": True,
}, {
"name": "__cpp_lib_is_nothrow_convertible",
"values": { "c++20": 201806 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_is_null_pointer",
"values": { "c++14": 201309 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_is_pointer_interconvertible",
"values": { "c++20": 201907 },
"headers": ["type_traits"],
"unimplemented": True,
}, {
"name": "__cpp_lib_is_scoped_enum",
"values": { "c++2b": 202011 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_is_swappable",
"values": { "c++17": 201603 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_jthread",
"values": { "c++20": 201911 },
"headers": ["stop_token", "thread"],
"test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
"unimplemented": True,
}, {
"name": "__cpp_lib_latch",
"values": { "c++20": 201907 },
"headers": ["latch"],
"test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
}, {
"name": "__cpp_lib_launder",
"values": { "c++17": 201606 },
"headers": ["new"],
}, {
"name": "__cpp_lib_list_remove_return_type",
"values": { "c++20": 201806 },
"headers": ["forward_list", "list"],
}, {
"name": "__cpp_lib_logical_traits",
"values": { "c++17": 201510 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_make_from_tuple",
"values": { "c++17": 201606 },
"headers": ["tuple"],
}, {
"name": "__cpp_lib_make_reverse_iterator",
"values": { "c++14": 201402 },
"headers": ["iterator"],
}, {
"name": "__cpp_lib_make_unique",
"values": { "c++14": 201304 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_map_try_emplace",
"values": { "c++17": 201411 },
"headers": ["map"],
}, {
"name": "__cpp_lib_math_constants",
"values": { "c++20": 201907 },
"headers": ["numbers"],
}, {
"name": "__cpp_lib_math_special_functions",
"values": { "c++17": 201603 },
"headers": ["cmath"],
"unimplemented": True,
}, {
"name": "__cpp_lib_memory_resource",
"values": { "c++17": 201603 },
"headers": ["memory_resource"],
}, {
"name": "__cpp_lib_move_iterator_concept",
"values": { "c++20": 202207 },
"headers": ["iterator"],
}, {
"name": "__cpp_lib_move_only_function",
"values": { "c++2b": 202110 },
"headers": ["functional"],
"unimplemented": True,
}, {
"name": "__cpp_lib_node_extract",
"values": { "c++17": 201606 },
"headers": ["map", "set", "unordered_map", "unordered_set"],
}, {
"name": "__cpp_lib_nonmember_container_access",
"values": { "c++17": 201411 },
"headers": ["array", "deque", "forward_list", "iterator", "list", "map", "regex", "set", "string", "unordered_map", "unordered_set", "vector"],
}, {
"name": "__cpp_lib_not_fn",
"values": { "c++17": 201603 },
"headers": ["functional"],
}, {
"name": "__cpp_lib_null_iterators",
"values": { "c++14": 201304 },
"headers": ["iterator"],
}, {
"name": "__cpp_lib_optional",
"values": { "c++17": 201606, "c++2b": 202110 },
"headers": ["optional"],
}, {
"name": "__cpp_lib_out_ptr",
"values": { "c++2b": 202106 },
"headers": ["memory"],
"unimplemented": True,
}, {
"name": "__cpp_lib_parallel_algorithm",
"values": { "c++17": 201603 },
"headers": ["algorithm", "numeric"],
"unimplemented": True,
}, {
"name": "__cpp_lib_polymorphic_allocator",
"values": { "c++20": 201902 },
"headers": ["memory_resource"],
}, {
"name": "__cpp_lib_quoted_string_io",
"values": { "c++14": 201304 },
"headers": ["iomanip"],
}, {
"name": "__cpp_lib_ranges",
"values": { "c++20": 202106 },
"headers": ["algorithm", "functional", "iterator", "memory", "ranges"],
}, {
"name": "__cpp_lib_ranges_as_rvalue",
"values": { "c++2b": 202207 },
"headers": ["ranges"],
}, {
"name": "__cpp_lib_ranges_chunk",
"values": { "c++2b": 202202 },
"headers": ["ranges"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ranges_chunk_by",
"values": { "c++2b": 202202 },
"headers": ["ranges"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ranges_iota",
"values": { "c++2b": 202202 },
"headers": ["numeric"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ranges_join_with",
"values": { "c++2b": 202202 },
"headers": ["ranges"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ranges_slide",
"values": { "c++2b": 202202 },
"headers": ["ranges"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ranges_starts_ends_with",
"values": { "c++2b": 202106 },
"headers": ["algorithm"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ranges_to_container",
"values": { "c++2b": 202202 },
"headers": ["deque", "forward_list", "list", "map", "priority_queue", "queue", "set", "stack", "string", "unordered_map", "unordered_set", "vector"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ranges_zip",
"values": { "c++2b": 202110 },
"headers": ["ranges", "tuple", "utility"],
"unimplemented": True,
}, {
"name": "__cpp_lib_raw_memory_algorithms",
"values": { "c++17": 201606 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_reference_from_temporary",
"values": { "c++2b": 202202 },
"headers": ["type_traits"],
"unimplemented": True,
}, {
"name": "__cpp_lib_remove_cvref",
"values": { "c++20": 201711 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_result_of_sfinae",
"values": { "c++14": 201210 },
"headers": ["functional", "type_traits"],
}, {
"name": "__cpp_lib_robust_nonmodifying_seq_ops",
"values": { "c++14": 201304 },
"headers": ["algorithm"],
}, {
"name": "__cpp_lib_sample",
"values": { "c++17": 201603 },
"headers": ["algorithm"],
}, {
"name": "__cpp_lib_scoped_lock",
"values": { "c++17": 201703 },
"headers": ["mutex"],
}, {
"name": "__cpp_lib_semaphore",
"values": { "c++20": 201907 },
"headers": ["semaphore"],
"test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)",
}, {
"name": "__cpp_lib_shared_mutex",
"values": { "c++17": 201505 },
"headers": ["shared_mutex"],
"test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX)",
}, {
"name": "__cpp_lib_shared_ptr_arrays",
"values": { "c++17": 201611, "c++20": 201707 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_shared_ptr_weak_type",
"values": { "c++17": 201606 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_shared_timed_mutex",
"values": { "c++14": 201402 },
"headers": ["shared_mutex"],
"test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX)",
"libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX)",
}, {
"name": "__cpp_lib_shift",
"values": { "c++20": 201806 },
"headers": ["algorithm"],
}, {
"name": "__cpp_lib_smart_ptr_for_overwrite",
"values": { "c++20": 202002 },
"headers": ["memory"],
"unimplemented": True,
}, {
"name": "__cpp_lib_source_location",
"values": { "c++20": 201907 },
"headers": ["source_location"],
"test_suite_guard": "__has_builtin(__builtin_source_location) && !(defined(TEST_APPLE_CLANG_VER) && TEST_APPLE_CLANG_VER <= 1403)",
"libcxx_guard": "__has_builtin(__builtin_source_location) && !(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER <= 1403)",
}, {
"name": "__cpp_lib_span",
"values": { "c++20": 202002 },
"headers": ["span"],
}, {
"name": "__cpp_lib_spanstream",
"values": { "c++2b": 202106 },
"headers": ["spanstream"],
"unimplemented": True,
}, {
"name": "__cpp_lib_ssize",
"values": { "c++20": 201902 },
"headers": ["iterator"],
}, {
"name": "__cpp_lib_stacktrace",
"values": { "c++2b": 202011 },
"headers": ["stacktrace"],
"unimplemented": True,
}, {
"name": "__cpp_lib_starts_ends_with",
"values": { "c++20": 201711 },
"headers": ["string", "string_view"],
}, {
"name": "__cpp_lib_stdatomic_h",
"values": { "c++2b": 202011 },
"headers": ["stdatomic.h"],
}, {
"name": "__cpp_lib_string_contains",
"values": { "c++2b": 202011 },
"headers": ["string", "string_view"],
}, {
"name": "__cpp_lib_string_resize_and_overwrite",
"values": { "c++2b": 202110 },
"headers": ["string"],
}, {
"name": "__cpp_lib_string_udls",
"values": { "c++14": 201304 },
"headers": ["string"],
}, {
"name": "__cpp_lib_string_view",
"values": { "c++17": 201606, "c++20": 201803 },
"headers": ["string", "string_view"],
}, {
"name": "__cpp_lib_syncbuf",
"values": { "c++20": 201803 },
"headers": ["syncstream"],
"unimplemented": True,
}, {
"name": "__cpp_lib_three_way_comparison",
"values": { "c++20": 201907 },
"headers": ["compare"],
"unimplemented": True,
}, {
"name": "__cpp_lib_to_address",
"values": { "c++20": 201711 },
"headers": ["memory"],
}, {
"name": "__cpp_lib_to_array",
"values": { "c++20": 201907 },
"headers": ["array"],
}, {
"name": "__cpp_lib_to_chars",
"values": { "c++17": 201611 },
"headers": ["charconv"],
"unimplemented": True,
}, {
"name": "__cpp_lib_to_underlying",
"values": { "c++2b": 202102 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_transformation_trait_aliases",
"values": { "c++14": 201304 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_transparent_operators",
"values": { "c++14": 201210, "c++17": 201510 },
"headers": ["functional", "memory"],
}, {
"name": "__cpp_lib_tuple_element_t",
"values": { "c++14": 201402 },
"headers": ["tuple"],
}, {
"name": "__cpp_lib_tuples_by_type",
"values": { "c++14": 201304 },
"headers": ["tuple", "utility"],
}, {
"name": "__cpp_lib_type_identity",
"values": { "c++20": 201806 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_type_trait_variable_templates",
"values": { "c++17": 201510 },
"headers": ["type_traits"],
}, {
"name": "__cpp_lib_uncaught_exceptions",
"values": { "c++17": 201411 },
"headers": ["exception"],
}, {
"name": "__cpp_lib_unordered_map_try_emplace",
"values": { "c++17": 201411 },
"headers": ["unordered_map"],
}, {
"name": "__cpp_lib_unreachable",
"values": { "c++2b": 202202 },
"headers": ["utility"],
}, {
"name": "__cpp_lib_unwrap_ref",
"values": { "c++20": 201811 },
"headers": ["functional"],
}, {
"name": "__cpp_lib_variant",
"values": { "c++17": 202102 },
"headers": ["variant"],
}, {
"name": "__cpp_lib_void_t",
"values": { "c++17": 201411 },
"headers": ["type_traits"],
}
]]
assert feature_test_macros == sorted(feature_test_macros, key=lambda tc: tc["name"])
assert all(tc["headers"] == sorted(tc["headers"]) for tc in feature_test_macros)
assert all(("libcxx_guard" in tc) == ("test_suite_guard" in tc) for tc in feature_test_macros)
assert all(all(key in ["name", "values", "headers", "libcxx_guard", "test_suite_guard", "unimplemented"] for key in tc.keys()) for tc in feature_test_macros)
# Map from each header to the Lit annotations that should be used for
# tests that include that header.
#
# For example, when threads are not supported, any test that includes
# <thread> should be marked as UNSUPPORTED, because including <thread>
# is a hard error in that case.
lit_markup = {
"barrier": ["UNSUPPORTED: no-threads"],
"filesystem": ["UNSUPPORTED: no-filesystem"],
"format": ["UNSUPPORTED: libcpp-has-no-incomplete-format"],
"iomanip": ["UNSUPPORTED: no-localization"],
"ios": ["UNSUPPORTED: no-localization"],
"iostream": ["UNSUPPORTED: no-localization"],
"istream": ["UNSUPPORTED: no-localization"],
"latch": ["UNSUPPORTED: no-threads"],
"locale": ["UNSUPPORTED: no-localization"],
"mutex": ["UNSUPPORTED: no-threads"],
"ostream": ["UNSUPPORTED: no-localization"],
"regex": ["UNSUPPORTED: no-localization"],
"semaphore": ["UNSUPPORTED: no-threads"],
"shared_mutex": ["UNSUPPORTED: no-threads"],
"stdatomic.h": ["UNSUPPORTED: no-threads"],
"thread": ["UNSUPPORTED: no-threads"],
}
def get_std_dialects():
std_dialects = ['c++14', 'c++17', 'c++20', 'c++2b']
return list(std_dialects)
def get_first_std(d):
for s in get_std_dialects():
if s in d.keys():
return s
return None
def get_last_std(d):
rev_dialects = get_std_dialects()
rev_dialects.reverse()
for s in rev_dialects:
if s in d.keys():
return s
return None
def get_std_before(d, std):
std_dialects = get_std_dialects()
candidates = std_dialects[0:std_dialects.index(std)]
candidates.reverse()
for cand in candidates:
if cand in d.keys():
return cand
return None
def get_value_before(d, std):
new_std = get_std_before(d, std)
if new_std is None:
return None
return d[new_std]
def get_for_std(d, std):
# This catches the C++11 case for which there should be no defined feature
# test macros.
std_dialects = get_std_dialects()
if std not in std_dialects:
return None
# Find the value for the newest C++ dialect between C++14 and std
std_list = list(std_dialects[0:std_dialects.index(std)+1])
std_list.reverse()
for s in std_list:
if s in d.keys():
return d[s]
return None
def get_std_number(std):
return std.replace('c++', '')
"""
Functions to produce the <version> header
"""
def produce_macros_definition_for_std(std):
result = ""
indent = 55
for tc in feature_test_macros:
if std not in tc["values"]:
continue
inner_indent = 1
if 'test_suite_guard' in tc.keys():
result += "# if %s\n" % tc["libcxx_guard"]
inner_indent += 2
if get_value_before(tc["values"], std) is not None:
assert 'test_suite_guard' not in tc.keys()
result += "# undef %s\n" % tc["name"]
line = "#%sdefine %s" % ((" " * inner_indent), tc["name"])
line += " " * (indent - len(line))
line += " %sL" % tc["values"][std]
if 'unimplemented' in tc.keys():
line = "// " + line
result += line
result += "\n"
if 'test_suite_guard' in tc.keys():
result += "# endif\n"
return result.strip()
def produce_macros_definitions():
macro_definition_template = """#if _LIBCPP_STD_VER >= {std_number}
{macro_definition}
#endif"""
macros_definitions = []
for std in get_std_dialects():
macros_definitions.append(
macro_definition_template.format(std_number=get_std_number(std).replace('2b', '23'),
macro_definition=produce_macros_definition_for_std(std)))
return '\n\n'.join(macros_definitions)
def chunks(l, n):
"""Yield successive n-sized chunks from l."""
for i in range(0, len(l), n):
yield l[i:i + n]
def produce_version_synopsis():
indent = 56
header_indent = 56 + len("20XXYYL ")
result = ""
def indent_to(s, val):
if len(s) >= val:
return s
s += " " * (val - len(s))
return s
line = indent_to("Macro name", indent) + "Value"
line = indent_to(line, header_indent) + "Headers"
result += line + "\n"
for tc in feature_test_macros:
prev_defined_std = get_last_std(tc["values"])
line = "{name: <{indent}}{value}L ".format(name=tc['name'], indent=indent,
value=tc["values"][prev_defined_std])
headers = list(tc["headers"])
headers.remove("version")
for chunk in chunks(headers, 3):
line = indent_to(line, header_indent)
chunk = ['<%s>' % header for header in chunk]
line += ' '.join(chunk)
result += line
result += "\n"
line = ""
while True:
prev_defined_std = get_std_before(tc["values"], prev_defined_std)
if prev_defined_std is None:
break
result += "%s%sL // %s\n" % (indent_to("", indent), tc["values"][prev_defined_std],
prev_defined_std.replace("c++", "C++"))
return result
def produce_version_header():
template="""// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_VERSIONH
#define _LIBCPP_VERSIONH
/*
version synopsis
{synopsis}
*/
#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
// clang-format off
{cxx_macros}
// clang-format on
#endif // _LIBCPP_VERSIONH
"""
version_str = template.format(
synopsis=produce_version_synopsis().strip(),
cxx_macros=produce_macros_definitions())
version_header_path = os.path.join(include_path, 'version')
with open(version_header_path, 'w', newline='\n') as f:
f.write(version_str)
"""
Functions to produce test files
"""
test_types = {
"undefined": """
# ifdef {name}
# error "{name} should not be defined before {std_first}"
# endif
""",
"test_suite_guard": """
# if {test_suite_guard}
# ifndef {name}
# error "{name} should be defined in {std}"
# endif
# if {name} != {value}
# error "{name} should have the value {value} in {std}"
# endif
# else
# ifdef {name}
# error "{name} should not be defined when the requirement '{test_suite_guard}' is not met!"
# endif
# endif
""",
"unimplemented": """
# if !defined(_LIBCPP_VERSION)
# ifndef {name}
# error "{name} should be defined in {std}"
# endif
# if {name} != {value}
# error "{name} should have the value {value} in {std}"
# endif
# else // _LIBCPP_VERSION
# ifdef {name}
# error "{name} should not be defined because it is unimplemented in libc++!"
# endif
# endif
""",
"defined": """
# ifndef {name}
# error "{name} should be defined in {std}"
# endif
# if {name} != {value}
# error "{name} should have the value {value} in {std}"
# endif
"""
}
def generate_std_test(test_list, std):
result = ""
for tc in test_list:
val = get_for_std(tc["values"], std)
if val is not None:
val = "%sL" % val
if val is None:
result += test_types["undefined"].format(name=tc["name"], std_first=get_first_std(tc["values"]))
elif 'unimplemented' in tc.keys():
result += test_types["unimplemented"].format(name=tc["name"], value=val, std=std)
elif "test_suite_guard" in tc.keys():
result += test_types["test_suite_guard"].format(name=tc["name"], value=val, std=std, test_suite_guard=tc["test_suite_guard"])
else:
result += test_types["defined"].format(name=tc["name"], value=val, std=std)
return result.strip()
def generate_std_tests(test_list):
std_tests_template = """#if TEST_STD_VER < {first_std_number}
{pre_std_test}
{other_std_tests}
#elif TEST_STD_VER > {penultimate_std_number}
{last_std_test}
#endif // TEST_STD_VER > {penultimate_std_number}"""
std_dialects = get_std_dialects()
assert not get_std_number(std_dialects[-1]).isnumeric()
other_std_tests = []
for std in std_dialects[:-1]:
other_std_tests.append('#elif TEST_STD_VER == ' + get_std_number(std))
other_std_tests.append(generate_std_test(test_list, std))
std_tests = std_tests_template.format(first_std_number=get_std_number(std_dialects[0]),
pre_std_test=generate_std_test(test_list, 'c++11'),
other_std_tests='\n\n'.join(other_std_tests),
penultimate_std_number=get_std_number(std_dialects[-2]),
last_std_test=generate_std_test(test_list, std_dialects[-1]))
return std_tests
def generate_synopsis(test_list):
max_name_len = max([len(tc["name"]) for tc in test_list])
indent = max_name_len + 8
def mk_line(prefix, suffix):
return "{prefix: <{max_len}}{suffix}\n".format(prefix=prefix, suffix=suffix,
max_len=indent)
result = ""
result += mk_line("/* Constant", "Value")
for tc in test_list:
prefix = " %s" % tc["name"]
for std in [s for s in get_std_dialects() if s in tc["values"].keys()]:
result += mk_line(prefix, "%sL [%s]" % (tc["values"][std], std.replace("c++", "C++")))
prefix = ""
result += "*/"
return result
def produce_tests():
headers = set([h for tc in feature_test_macros for h in tc["headers"]])
for h in headers:
test_list = [tc for tc in feature_test_macros if h in tc["headers"]]
if not has_header(h):
for tc in test_list:
assert 'unimplemented' in tc.keys()
continue
markup = '\n'.join('// ' + tag for tag in lit_markup.get(h, []))
test_body = \
"""//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// WARNING: This test was generated by {script_name}
// and should not be edited manually.
//
// clang-format off
{markup}
// <{header}>
// Test the feature test macros defined by <{header}>
{synopsis}
#include <{header}>
#include "test_macros.h"
{cxx_tests}
""".format(script_name=script_name,
header=h,
markup=('\n{}\n'.format(markup) if markup else ''),
synopsis=generate_synopsis(test_list),
cxx_tests=generate_std_tests(test_list))
test_name = "{header}.version.compile.pass.cpp".format(header=h)
out_path = os.path.join(macro_test_path, test_name)
with open(out_path, 'w', newline='\n') as f:
f.write(test_body)
"""
Produce documentation for the feature test macros
"""
def make_widths(grid):
widths = []
for i in range(0, len(grid[0])):
cell_width = 2 + max(reduce(lambda x,y: x+y, [[len(row[i])] for row in grid], []))
widths += [cell_width]
return widths
def create_table(grid, indent):
indent_str = ' '*indent
col_widths = make_widths(grid)
result = [indent_str + add_divider(col_widths, 2)]
header_flag = 2
for row_i in range(0, len(grid)):
row = grid[row_i]
line = indent_str + ' '.join([pad_cell(row[i], col_widths[i]) for i in range(0, len(row))])
result.append(line.rstrip())
is_cxx_header = row[0].startswith('**')
if row_i == len(grid) - 1:
header_flag = 2
separator = indent_str + add_divider(col_widths, 1 if is_cxx_header else header_flag)
result.append(separator.rstrip())
header_flag = 0
return '\n'.join(result)
def add_divider(widths, header_flag):
if header_flag == 2:
return ' '.join(['='*w for w in widths])
if header_flag == 1:
return '-'.join(['-'*w for w in widths])
else:
return ' '.join(['-'*w for w in widths])
def pad_cell(s, length, left_align=True):
padding = ((length - len(s)) * ' ')
return s + padding
def get_status_table():
table = [["Macro Name", "Value"]]
for std in get_std_dialects():
table += [["**" + std.replace("c++", "C++ ") + "**", ""]]
for tc in feature_test_macros:
if std not in tc["values"].keys():
continue
value = "``%sL``" % tc["values"][std]
if 'unimplemented' in tc.keys():
value = '*unimplemented*'
table += [["``%s``" % tc["name"], value]]
return table
def produce_docs():
doc_str = """.. _FeatureTestMacroTable:
==========================
Feature Test Macro Support
==========================
.. contents::
:local:
Overview
========
This file documents the feature test macros currently supported by libc++.
.. _feature-status:
Status
======
.. table:: Current Status
:name: feature-status-table
:widths: auto
{status_tables}
""".format(status_tables=create_table(get_status_table(), 4))
table_doc_path = os.path.join(docs_path, 'FeatureTestMacroTable.rst')
with open(table_doc_path, 'w', newline='\n') as f:
f.write(doc_str)
def main():
produce_version_header()
produce_tests()
produce_docs()
if __name__ == '__main__':
main()
Reference in New Issue View Git Blame Copy Permalink