This is an archive of the discontinued LLVM Phabricator instance.

Differential D158133

[libc++][Modules] Simplify the __std_clang_module header generation
ClosedPublic

Authored by iana on Aug 16 2023, 5:03 PM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rGa9167c2e475a: [libc++][Modules] Simplify the __std_clang_module header generation
Summary

Post review feedback on D157364. Don't section the __std_clang_module header by macro, put the headers in alphabetical order and repeat the macro guards. Restore header_information.header_restrictions.

Diff Detail

Event Timeline

iana created this revision.Aug 16 2023, 5:03 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 16 2023, 5:03 PM
Herald added subscribers: ributzka, arichardson. · View Herald Transcript
iana requested review of this revision.Aug 16 2023, 5:03 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 16 2023, 5:03 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: libcxx-commits, wangpc. · View Herald Transcript
Harbormaster completed remote builds in B253080: Diff 550939.Aug 16 2023, 5:18 PM
ldionne accepted this revision.Aug 17 2023, 6:42 AM
This revision is now accepted and ready to land.Aug 17 2023, 6:42 AM
ldionne added a comment.Aug 17 2023, 6:42 AM

LGTM with green CI.

iana updated this revision to Diff 551203.Aug 17 2023, 11:29 AM

Fix the formatting

iana updated this revision to Diff 551205.Aug 17 2023, 11:31 AM

Regenerate the header

Harbormaster completed remote builds in B253265: Diff 551205.Aug 17 2023, 5:53 PM
Closed by commit rGa9167c2e475a: [libc++][Modules] Simplify the __std_clang_module header generation (authored by iana). · Explain WhyAug 17 2023, 10:35 PM
This revision was automatically updated to reflect the committed changes.
iana added a commit: rGa9167c2e475a: [libc++][Modules] Simplify the __std_clang_module header generation.

Revision Contents

PathSize
libcxx/
include/
118 lines
utils/
34 lines
libcxx/
86 lines

Diff 551385

libcxx/include/__std_clang_module

Show All 24 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#include <algorithm> #include <algorithm>
#include <any> #include <any>
#include <array> #include <array>
#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
# include <atomic>
#endif
#if !defined(_LIBCPP_HAS_NO_THREADS)
# include <barrier>
#endif
#include <bit> #include <bit>
#include <bitset> #include <bitset>
#include <cassert> #include <cassert>
#include <ccomplex> #include <ccomplex>
#include <cctype> #include <cctype>
#include <cerrno> #include <cerrno>
#include <cfenv> #include <cfenv>
#include <cfloat> #include <cfloat>
#include <charconv> #include <charconv>
#include <chrono> #include <chrono>
#include <cinttypes> #include <cinttypes>
#include <ciso646> #include <ciso646>
#include <climits> #include <climits>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <clocale>
#endif
#include <cmath> #include <cmath>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <codecvt>
#endif
#include <compare> #include <compare>
#include <complex.h> #include <complex.h>
#include <complex> #include <complex>
#include <concepts> #include <concepts>
#include <condition_variable> #include <condition_variable>
#include <coroutine> #include <coroutine>
#include <csetjmp> #include <csetjmp>
#include <csignal> #include <csignal>
#include <cstdarg> #include <cstdarg>
#include <cstdbool> #include <cstdbool>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <ctgmath> #include <ctgmath>
#include <ctime> #include <ctime>
#include <ctype.h> #include <ctype.h>
#include <cuchar> #include <cuchar>
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwchar>
#endif
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwctype>
#endif
#include <deque> #include <deque>
#include <errno.h> #include <errno.h>
#include <exception> #include <exception>
#include <execution> #include <execution>
#include <expected> #include <expected>
#include <experimental/deque> #include <experimental/deque>
#include <experimental/forward_list> #include <experimental/forward_list>
#include <experimental/iterator> #include <experimental/iterator>
#include <experimental/list> #include <experimental/list>
#include <experimental/map> #include <experimental/map>
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <experimental/propagate_const> #include <experimental/propagate_const>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <experimental/regex>
#endif
#include <experimental/set> #include <experimental/set>
#include <experimental/simd> #include <experimental/simd>
#include <experimental/string> #include <experimental/string>
#include <experimental/type_traits> #include <experimental/type_traits>
#include <experimental/unordered_map> #include <experimental/unordered_map>
#include <experimental/unordered_set> #include <experimental/unordered_set>
#include <experimental/utility> #include <experimental/utility>
#include <experimental/vector> #include <experimental/vector>
#include <fenv.h> #include <fenv.h>
#include <filesystem> #include <filesystem>
#include <float.h> #include <float.h>
#include <format> #include <format>
#include <forward_list> #include <forward_list>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <fstream>
#endif
#include <functional> #include <functional>
#if !defined(_LIBCPP_HAS_NO_THREADS)
# include <future>
#endif
#include <initializer_list> #include <initializer_list>
#include <inttypes.h> #include <inttypes.h>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <iomanip>
#endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <ios>
#endif
#include <iosfwd> #include <iosfwd>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <iostream>
#endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <istream>
#endif
#include <iterator> #include <iterator>
#if !defined(_LIBCPP_HAS_NO_THREADS)
# include <latch>
#endif
#include <limits.h> #include <limits.h>
#include <limits> #include <limits>
#include <list> #include <list>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale.h>
#endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <locale>
#endif
#include <map> #include <map>
#include <math.h> #include <math.h>
#include <mdspan> #include <mdspan>
#include <memory> #include <memory>
#include <memory_resource> #include <memory_resource>
#include <mutex> #include <mutex>
#include <new> #include <new>
#include <numbers> #include <numbers>
#include <numeric> #include <numeric>
#include <optional> #include <optional>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <ostream>
#endif
#include <print> #include <print>
#include <queue> #include <queue>
#include <random> #include <random>
#include <ranges> #include <ranges>
#include <ratio> #include <ratio>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <regex>
#endif
#include <scoped_allocator> #include <scoped_allocator>
#if !defined(_LIBCPP_HAS_NO_THREADS)
# include <semaphore>
#endif
#include <set> #include <set>
#include <setjmp.h> #include <setjmp.h>
#if !defined(_LIBCPP_HAS_NO_THREADS)
# include <shared_mutex>
#endif
#include <source_location> #include <source_location>
#include <span> #include <span>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <sstream>
#endif
#include <stack> #include <stack>
#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
# include <stdatomic.h>
#endif
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <stdexcept> #include <stdexcept>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#if !defined(_LIBCPP_HAS_NO_THREADS)
# include <stop_token>
#endif
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <streambuf>
#endif
#include <string.h> #include <string.h>
#include <string> #include <string>
#include <string_view> #include <string_view>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
# include <strstream>
#endif
#include <system_error> #include <system_error>
#include <tgmath.h> #include <tgmath.h>
#if !defined(_LIBCPP_HAS_NO_THREADS)
# include <thread>
#endif
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <typeindex> #include <typeindex>
#include <typeinfo> #include <typeinfo>
#include <uchar.h> #include <uchar.h>
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
#include <utility> #include <utility>
#include <valarray> #include <valarray>
#include <variant> #include <variant>
#include <vector> #include <vector>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
# include <atomic>
# include <stdatomic.h>
#endif
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
# include <clocale>
# include <codecvt>
# include <experimental/regex>
# include <fstream>
# include <iomanip>
# include <ios>
# include <iostream>
# include <istream>
# include <locale.h>
# include <locale>
# include <ostream>
# include <regex>
# include <sstream>
# include <streambuf>
# include <strstream>
#endif
#ifndef _LIBCPP_HAS_NO_THREADS
# include <barrier>
# include <future>
# include <latch>
# include <semaphore>
# include <shared_mutex>
# include <stop_token>
# include <thread>
#endif
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include <cwchar>
# include <cwctype>
# include <wchar.h> # include <wchar.h>
#endif
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <wctype.h> # include <wctype.h>
#endif #endif

libcxx/utils/generate_std_clang_module_header.py

# ===----------------------------------------------------------------------===## # ===----------------------------------------------------------------------===##
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
# #
# ===----------------------------------------------------------------------===## # ===----------------------------------------------------------------------===##
import operator import operator
import os.path import os.path
import libcxx.header_information import libcxx.header_information
public_headers = libcxx.header_information.public_headers header_restrictions = libcxx.header_information.header_restrictions
header_include_requirements = libcxx.header_information.header_include_requirements
always_available_headers = frozenset(public_headers).difference(
*header_include_requirements.values()
)
libcxx_include_directory = os.path.join( libcxx_include_directory = os.path.join(
os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "include" os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "include"
) )
with open( with open(
os.path.join(libcxx_include_directory, "__std_clang_module"), "w" os.path.join(libcxx_include_directory, "__std_clang_module"), "w"
) as std_clang_module_header: ) as std_clang_module_header:
std_clang_module_header.write( std_clang_module_header.write(
Show All 26 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
""" """
) )
# Include the angle brackets in sorting so that <a.h> sorts before <a> # Include the angle brackets in sorting so that <a.h> sorts before <a>
# like check-format wants. # like check-format wants.
for include in sorted([f"<{header}>" for header in always_available_headers]): for include, header in sorted([(f"<{header}>", header) for header in libcxx.header_information.public_headers]):
header_restriction = header_restrictions.get(header)
if header_restriction:
std_clang_module_header.write(f"#if {header_restriction}\n")
std_clang_module_header.write(f"#include {include}\n") std_clang_module_header.write(f"# include {include}\n")
std_clang_module_header.write(f"#endif\n")
for requirements, headers in sorted(
header_include_requirements.items(), key=operator.itemgetter(0)
):
std_clang_module_header.write("\n")
if len(requirements) == 1:
std_clang_module_header.write("#ifndef ")
std_clang_module_header.write(requirements[0])
else: else:
std_clang_module_header.write("#if")
for index, requirement in enumerate(requirements):
if index > 0:
std_clang_module_header.write(" &&")
std_clang_module_header.write(f" !defined({requirement})")
std_clang_module_header.write("\n")
for include in sorted([f"<{header}>" for header in headers]):
std_clang_module_header.write(f"# include {include}\n") std_clang_module_header.write(f"#include {include}\n")
std_clang_module_header.write("#endif\n")

libcxx/utils/libcxx/header_information.py

# ===----------------------------------------------------------------------===## # ===----------------------------------------------------------------------===##
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
# #
# ===----------------------------------------------------------------------===## # ===----------------------------------------------------------------------===##
import os, pathlib import os, pathlib
header_restrictions = {
# headers with #error directives
"atomic": "!defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)",
"stdatomic.h": "!defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)",
# headers with #error directives
"ios": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"locale.h": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
# transitive includers of the above headers
"clocale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"codecvt": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"experimental/regex": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"fstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"iomanip": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"iostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"istream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"locale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"ostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"regex": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"sstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"streambuf": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
"strstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
# headers with #error directives
"barrier": "!defined(_LIBCPP_HAS_NO_THREADS)",
"future": "!defined(_LIBCPP_HAS_NO_THREADS)",
"latch": "!defined(_LIBCPP_HAS_NO_THREADS)",
"semaphore": "!defined(_LIBCPP_HAS_NO_THREADS)",
"shared_mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
"stop_token": "!defined(_LIBCPP_HAS_NO_THREADS)",
"thread": "!defined(_LIBCPP_HAS_NO_THREADS)",
# headers with #error directives
"wchar.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
"wctype.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
# transitive includers of the above headers
"cwchar": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
"cwctype": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
}
lit_header_restrictions = { lit_header_restrictions = {
"barrier": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17", "barrier": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
"clocale": "// UNSUPPORTED: no-localization", "clocale": "// UNSUPPORTED: no-localization",
"codecvt": "// UNSUPPORTED: no-localization", "codecvt": "// UNSUPPORTED: no-localization",
"coroutine": "// UNSUPPORTED: c++03, c++11, c++14, c++17", "coroutine": "// UNSUPPORTED: c++03, c++11, c++14, c++17",
"cwchar": "// UNSUPPORTED: no-wide-characters", "cwchar": "// UNSUPPORTED: no-wide-characters",
"cwctype": "// UNSUPPORTED: no-wide-characters", "cwctype": "// UNSUPPORTED: no-wide-characters",
"experimental/deque": "// UNSUPPORTED: c++03", "experimental/deque": "// UNSUPPORTED: c++03",
Show All 33 Lineslit_header_restrictions = {
"stop_token": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17", "stop_token": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
"streambuf": "// UNSUPPORTED: no-localization", "streambuf": "// UNSUPPORTED: no-localization",
"strstream": "// UNSUPPORTED: no-localization", "strstream": "// UNSUPPORTED: no-localization",
"thread": "// UNSUPPORTED: no-threads, c++03", "thread": "// UNSUPPORTED: no-threads, c++03",
"wchar.h": "// UNSUPPORTED: no-wide-characters", "wchar.h": "// UNSUPPORTED: no-wide-characters",
"wctype.h": "// UNSUPPORTED: no-wide-characters", "wctype.h": "// UNSUPPORTED: no-wide-characters",
} }
header_include_requirements = {
("_LIBCPP_HAS_NO_ATOMIC_HEADER",): (
# headers with #error directives
"atomic",
# transitive includers of the above headers
"stdatomic.h",
),
("_LIBCPP_HAS_NO_LOCALIZATION",): (
# headers with #error directives
"ios",
"locale.h",
# transitive includers of the above headers
"clocale",
"codecvt",
"experimental/regex",
"fstream",
"iomanip",
"iostream",
"istream",
"locale",
"ostream",
"regex",
"sstream",
"streambuf",
"strstream",
),
("_LIBCPP_HAS_NO_THREADS",): (
# headers with #error directives
"barrier",
"future",
"latch",
"semaphore",
"shared_mutex",
"stop_token",
"thread",
),
("_LIBCPP_HAS_NO_WIDE_CHARACTERS",): (
# headers with #error directives
"wchar.h",
"wctype.h",
# transitive includers of the above headers
"cwchar",
"cwctype",
),
}
# This table was produced manually, by grepping the TeX source of the Standard's # This table was produced manually, by grepping the TeX source of the Standard's
# library clauses for the string "#include". Each header's synopsis contains # library clauses for the string "#include". Each header's synopsis contains
# explicit "#include" directives for its mandatory inclusions. # explicit "#include" directives for its mandatory inclusions.
# For example, [algorithm.syn] contains "#include <initializer_list>". # For example, [algorithm.syn] contains "#include <initializer_list>".
mandatory_inclusions = { mandatory_inclusions = {
"algorithm": ["initializer_list"], "algorithm": ["initializer_list"],
"array": ["compare", "initializer_list"], "array": ["compare", "initializer_list"],
"bitset": ["iosfwd", "string"], "bitset": ["iosfwd", "string"],
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines