[Draft][libc++][modules] Adds std module.

[Mordante]

Summary

Implements parts of

• P2465R3 Standard Library Modules std and std.compat

This patch is based on work by @ChuanqiXu.

This patch not intended to be landed is this form, it's intended to get
a feeling of modules in libc++ and improve upon it. This patch will be
used to discuss the further approach regarding modules in libc++.

[EricWF]

Cool deal. Thanks for working on this.

[ldionne]

libcxx/stdmodules/std-format.cppm

13

Well, if nobody like synopsis in headers, we can also remove them :-). Let's chat about that.

To be clear, you are not opposed to keeping the synopsis comment in test files that describes what we're testing, right? I think those are definitely useful and we should not stop those.

Pinging @var-const @huixie90 for thoughts. If folks agree, I don't want to impose it on people.

FWIW I do agree that storing those in the .cppm files results in something less readable than I thought it would.

[ldionne]

Pinging @iana @Bigcheese for awareness since they are working on Modules.

[philnik]

libcxx/stdmodules/std-format.cppm

13

Well, if nobody like synopsis in headers, we can also remove them :-). Let's chat about that.

To be clear, you are not opposed to keeping the synopsis comment in test files that describes what we're testing, right? I think those are definitely useful and we should not stop those.

I'm not sure they are always super useful, but they are definitely in enough cases that it would probably be a bad idea to remove them. They are also much easier to maintain and less error-prone.

[Mordante]

In D144994#4176269, @EricWF wrote:

Cool deal. Thanks for working on this.

Thanks!

In D144994#4173764, @ChuanqiXu wrote:

One of the issues in libc++ is that vendors can decide to disable filesystem header. Since parts of that library are in the dylib the std module can't provide what's in filesystem. Does your method also have that feature?

I disabled the filesystem header directly in the downstream... so I don't have a lot experience in this.

Thanks for the information!

I think we can discuss that and see whether it's a blocker for landing the patch or not. For now I still have issues with ranges (which I have not started to investigate). I have been experimenting with running the test-suite for the modular build. So I will have some more information on that later today, probably on Discord.

Yeah, it is always good to have more experience. And I didn't expect that we can convert all headers and pass all the tests in one shot. It is good enough for me to have a std module which contains a lot of headers and can pass a lot of tests.

I also didn't expect that, but we need to look at when we're comfortable with shipping something. Since libc++ is a system library on some platforms we need to consider that carefully. Obviously there are other non-official ways to ship things too.

It seems quite some tests fail due to using size_t instead of std::size_t and similar C-types. I'm working on patches to use the qualified name instead.

libcxx/stdmodules/std-format.cppm

13

Well, if nobody like synopsis in headers, we can also remove them :-). Let's chat about that.

To be clear, you are not opposed to keeping the synopsis comment in test files that describes what we're testing, right? I think those are definitely useful and we should not stop those.

Pinging @var-const @huixie90 for thoughts. If folks agree, I don't want to impose it on people.

FWIW I do agree that storing those in the .cppm files results in something less readable than I thought it would.

+1 for discussing the synopsis. But let's take it to Discord or a libc++ meeting.

[Mordante]

Various improvements.

• Incorporates D145596 CMake 3.26 fix.
• Removes new tests libc++ certainly doesn't want to duplicate all their tests for modules. (The final solution still is unknown.)
• Adds the std.compat module.
• Propagate some libc++ configuration flags to the modules
• Prepared a CI job, this is not used yet since the CI does not have CMake 3.26 and Ninja 1.11 yet.
• Update the test transformation script and did initial tried it locally.
• Small fixes to the module file.
• Added a few now module files.

[aaronmondal]

libcxx/docs/Modules.rst

83

Ah yes this fails due to template (mis)deduction with lambdas if I remember correctly. This works around it but it was decided some time ago that this shouldn't be changed in libc++ due to "work around compiler bug" not being a good reason for a change.

diff --git a/libcxx/include/__compare/synth_three_way.h b/libcxx/include/__compare/synth_three_way.h
index fa8cbda79ba2..a6df1b936c72 100644
--- a/libcxx/include/__compare/synth_three_way.h
+++ b/libcxx/include/__compare/synth_three_way.h
@@ -25,8 +25,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [expos.only.func]
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way =
-  []<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
+template<class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way(const _Tp& __t, const _Up& __u)
     requires requires {
       { __t < __u } -> __boolean_testable;
       { __u < __t } -> __boolean_testable;

libcxx/stdmodules/std-string_view.cppm

47

[h-vetinari]

libcxx/docs/Modules.rst

66

But we need to find the "proper" location to store them. Since this is something new this probably needs some involvement of our packagers. I don't expect the Linux Standard Base has an entry for C++20 modules.

As mentioned already, I think there are strong parallels with distributing headers. The bare minimum should be that they are automatically discoverable by the toolchain that produced them (should be somewhere under INSTALL_PREFIX obviously), but ideally it's in a standard location that's uniform across toolchains (again, relative to a PREFIX), like the headers and libs are too. I'm not sure if SG21 has had discussions about this, or if CMake has already thought about this.

Personally, I think the best might be a separate folder like $PREFIX/something_module_related/foo.cppm, but I wouldn't care much or at all if it's under $PREFIX/include/something_module_related/foo.cppm or $PREFIX/lib/<libname>/foo.cppm, etc., as long as it's discoverable and works.

CC @mgorny as another packager & @ben.boeckel for the CMake side.

[ChuanqiXu]

libcxx/docs/Modules.rst

66

I'm not sure if SG21 has had discussions about this, or if CMake has already thought about this.

As far as I know, sg15 has discussed this for a long time. (If I recall this correctly,) sg15 don't get the final consensus yet. But @ruoso has already made a lot of proposals. We can look at them later.

Personally, I think the best might be a separate folder like $PREFIX/something_module_related/foo.cppm, but I wouldn't care much or at all if it's under $PREFIX/include/something_module_related/foo.cppm or $PREFIX/lib/<libname>/foo.cppm, etc., as long as it's discoverable and works.

I think we need to discuss this in the discourse. Because the patch is going to be a large patch and the topic about distribution is another big topic. It looks not good to discuss two big things in the same page. The direction may be lost.

libcxx/stdmodules/std-compat.cppm

1

std.compat.cppm may be a better name. Since std-compat.cppm looks like a partition of the std module to me.

[ChuanqiXu]

libcxx/docs/Modules.rst

66

I created https://discourse.llvm.org/t/rfc-about-the-default-location-for-std-modules/69191 and let's discuss this there.

libcxx/stdmodules/CMakeLists.txt.in

71–75

This is what I did in the downstream. I imaged that we will merge this one with libc++.so in the upstream. But maybe I am wrong.
I feel we need to give it another name like libc++-modules. Otherwise it may be conflict with the std modules provided by libstdc++ later.

[ben.boeckel]

libcxx/CMakeLists.txt

108–111

This help string has embedded newlines and indentation (though I see other options do this…). I don't think the UI editors show the help well in this case (testing with ccmake seems to bear this out).

422

Somewhere under libdir would be good unless we know these files are actually arch-independent.

libcxx/docs/Modules.rst

25–26

Note that buildsystems should handle this. I don't know how viable the "just run the compiler by hand" is in the long-term…

43

You cannot ship the P1689 *output*, but it needs to be generated by anything *consuming* it so that the collation step can know to add the right flags (-fmodule-file=…) to the consuming TU compilation.

51–54

Nor should there be IMO. Note that a single build tree may need *multiple* compilations of the module, so I don't think a single "scanning output" is suitable to ship.

66

Personally, I think the best might be a separate folder like $PREFIX/something_module_related/foo.cppm, but I wouldn't care much or at all if it's under $PREFIX/include/something_module_related/foo.cppm or $PREFIX/lib/<libname>/foo.cppm, etc., as long as it's discoverable and works.

Note that libstdc++ is also going to ship std.cppm (possibly with a different extension), so the libname being part of the path sounds best to me. I'll jump in over on Discourse.

71

"not used as a compile flag" perhaps?

116

IMO, no.

162–164

Is this intended to be a stable interface? IMO, support for std modules needs to come from CMake because this is going to be different for every compiler otherwise.

libcxx/stdmodules/CMakeLists.txt

44

Instead we need to focus on distributing .cppm files and offer the tools for the user to create the .pcm files for their project. This is something I will investigate further.

I think this is more the job of CMake since asking users to do

cmake
if (<is_clang>)
  setup_clang_libcpp()
elseif (<is_gcc>)
  setup_gcc_libstdcpp()
elseif (<is_msvc>)
  setup_msvc_stl()
endif ()

is awfully narrow IMO. Highly related question: what do you expect to happen in the case of clang with libstdc++ (as many distros end up doing)?

libcxx/stdmodules/CMakeLists.txt.in

7

3.26 should have this.

9

This UUID changes…regularly. There will probably need to be a table to do this "properly".

10

This is specific to CMake's test suite and shouldn't be relevant.

[ldionne]

libcxx/stdmodules/std-cstddef.cppm

13

Would this make sense to avoid users having to define all the config site macros? #include <__config_site>

[tahonermann]

libcxx/stdmodules/std-cstddef.cppm

13

Named modules don't export/leak macros when imported, so the addition of the #include would have no effect on importers of the module.

[Mordante]

libcxx/CMakeLists.txt

108–111

Yes I indeed copied this from the other scripts. Are there better ways in CMake to have multi-line options?

422

This is used for the .cppm source files so they are arch independent.

libcxx/docs/Modules.rst

66

I'm not sure if SG21 has had discussions about this, or if CMake has already thought about this.

As far as I know, sg15 has discussed this for a long time. (If I recall this correctly,) sg15 don't get the final consensus yet. But @ruoso has already made a lot of proposals. We can look at them later.

Do you have a paper number?

Personally, I think the best might be a separate folder like $PREFIX/something_module_related/foo.cppm, but I wouldn't care much or at all if it's under $PREFIX/include/something_module_related/foo.cppm or $PREFIX/lib/<libname>/foo.cppm, etc., as long as it's discoverable and works.

I think we need to discuss this in the discourse. Because the patch is going to be a large patch and the topic about distribution is another big topic. It looks not good to discuss two big things in the same page. The direction may be lost.

I agree, this list is mainly added for documentation so we know what the status is. It was not intended to be used for discussions during the review.

162–164

I agree this is not the way users should use it. But without build system support this is how it works now.
So I feel this is "good enough" for early adapters. However when we (libc++) know how we want to distribute it
we should reach out to build system vendors and ask them to add proper support in their tools.

I'm not even sure what direction we want to take. For the experimental library we have a Clang flag which
automatically link that library. Do we want to do something similar here or leave it entirely in the hands
of the build system?

libcxx/stdmodules/CMakeLists.txt

44

I agree this is narrow and not great. However this patch's main focus it to be able to get modules working in libc++ in the first place.
We definitely need to think about the distribution in a user-friendly way.

I'm not sure whether libc++ needs to consider the configuration of Clang + libstdc++. Do you have something specific in mind?
I expect there need to be things done on the Clang side.

libcxx/stdmodules/CMakeLists.txt.in

7

Thanks for the information! I see it landed recently in CMake.

9

Is there a public available table for these UUIDs? The last time I needed the one for CMake 3.25 I looked in the CMake git history.

libcxx/stdmodules/std-cstddef.cppm

13

The goal is not to leak the macros, but to use the macros to conditionally export symbols. For example in the next file in the patch I use #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS to avoid exporting wide character functions when the user configured libc++ without wide character support.

When building the BMI we need to know the configuration of libc++. In a similar fashion we need to disable symbols based on the language version used. For now there are some examples for C++20 vs C++23. Not that we have decided that we want to back port this feature, but we will need this for C++23 vs C++26.

[ben.boeckel]

libcxx/docs/Modules.rst

162–164

I think that some build-system agnostic data (similar to the MSVC STL JSON file linked to on Discourse is best). I don't think every compiler trying to chase umpteen build tool integrations (as compilers tend to be *far* harder to upgrade in the Real World than build system tools IME).

ISO C++'s SG15 is the best place for communication IMO.

libcxx/stdmodules/CMakeLists.txt.in

9

The UUID is only documented in the CMake repository's Help/dev/experimental.rst file.

[Mordante]

Adds more modules.

This mostely completes the modules. These modules have been compile
tested but nothing more. They also do not take disabled libc++ parts
into account.

Updates the documentation.

[ldionne]

libcxx/test/libcxx/language.support/support.types/cstddef.compile.pass.cpp

1

IMO it would make sense to split this test like this:

/////////////////////////////////////////////////////////////////////////////
// cstddef.compile.pass.cpp
#include <cstddef>
#include "test_macros.h"

using PtrdiffT = ::ptrdiff_t;
using SizeT = ::size_t;
#if TEST_STD_VER >= 11
using MaxAlignT = ::max_align_t;
#endif

// Supported in C++03 mode too for backwards compatibility with previous versions of libc++
using NullptrT = ::nullptr_t;

// Also ensure that we provide std::nullptr_t in C++03 mode, which is an extension too.
using StdNullptrT = std::nullptr_t;
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// cstddef.std.module.verify.cpp
// REQUIRES: modules-build (????)
import std;

#include "test_macros.h"

using PtrdiffT = ::ptrdiff_t; // expected-error {{no ptrdiff_t in global namespace}}
using SizeT = ::size_t; // expected-error {{no size_t in global namespace}}

[ etc... ]
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// cstddef.stdcompat.module.compile.pass.cpp
import std.compat;

#include "test_macros.h"

using PtrdiffT = ::ptrdiff_t;
using SizeT = ::size_t;

[ etc... ]
/////////////////////////////////////////////////////////////////////////////

This one would be split up manually since it is extremely relevant to test this with C++23 modules.

However, many other tests are not as useful to test with/without modules. As we discussed, we could perhaps run use_modules_in_test.py on the fly to create a modularized version of the test that we wouldn't check into source control.

[Mordante]

Minor improvements

Ran the tests using the compat module with the tests converted using
the test conversion script. After some minor fixes 222 tests fail and
need triaging. (This are more tests than before, but now the tests use
less headers since most headers are now available as module.)

• Improved the conversion script
  • Imports are moved the the end.
  • Modularized header #ifndefs are grouped.
  • Disables tests using deprecated features. These use a compiler switch that doesn't work with modules.
• Updated the documentation.
• Minor module fixes.

[Mordante]

Updated due to Discourse discussion and minor improvements.

• Use the installation location as proposed on Discourse. This adds a proof-of-concept installer.
• Add CI jobs to test modules with parts disabled.
• Fix modules to work with no localization or no wide characters. Other configurations are errors.
• Adds a few empty modules, their headers export nothing.
• Improve the algorithm module.

[tschuett]

libcxx/docs/Modules.rst

105

C++20

137

I believe this is confusing. I thought that you want to store everything underneath c++? Additionally you use the same path for includes and modules.

[aaronmondal]

libcxx/docs/Modules.rst

137

Typo? Should probably be "Includes are stored in <prefix>/include/c++/v1, modules in <prefix>/modules/c++/v1".

I think this makes sense. Modules can't be #included anyways so there is a need for them to live in an include/ directory. And for those using a different ABIs this leaves the possibility to have

.../include/c++/v1
.../include/c++/v2
.../modules/c++/v1
.../modules/c++/v2

or similar to clearly differentiate the headers/module interfaces.

[tschuett]

There was objection against using /usr/modules on discourse. I assumed that libc++ owns /usr/include/c++ and hides everything under there.

[ruoso]

libcxx/docs/Modules.rst

137

$PREFIX/modules is a new path that doesn't exist in the Filesystem Hierarchy Standard.

The source files for the module units is indeed a arch-independent resource, therefore the correct directory would be something under $PREFIX/share

If we ever intend to ship BMI files, they would belong in $libdir.

Here's how it would look like if we go in that direction:

$PREFIX/
   $libdir/
       libc++.so
       libc++.so.module-info
       c++/
           modules/
                libc++/
                      std.gcm.deadbeef1234
   share/
       c++/
           modules/
                 libc++/
                       std.cppm

the libc++.so.module-info file would have the metadata necessary for someone to understand how to produce their own BMI as well as potentially reuse the shipped BMI if it just so happen that they can.

[ruoso]

libcxx/docs/Modules.rst

137

There is one important bit that worries about splitting off the source files, tho.

The module metadata shipped alongside the library itself needs to reference those source files, and I am concerned that requiring the use of ../../../../share/ in order to address the source location can lead to fragility in the deployment.

So, even though it's technically arch-independent, I would also consider the following option:

$PREFIX/
   $libdir/
       libc++.so
       libc++.so.module-info
       c++/
           modules/
                libc++/
                      std.gcm.deadbeef1234
                      std.cppm

Because at that point, the metadata could reference a relative path from the library location without the awkwardness that using ../ can cause when directories are symlinks.

[ChuanqiXu]

Add CI jobs to test modules with parts disabled.

So, is the CI going to be ready?

libcxx/modules/std.compat/cassert.cppm

11–17 ↗

(On Diff #506637)

What's the meaning for the file? It looks useless.

[Mordante]

In D144994#4208434, @ChuanqiXu wrote:

Add CI jobs to test modules with parts disabled.

So, is the CI going to be ready?

Not at the moment. There are some CI issues not related to modules which should be resolved first. However I am testing with the CI configuration locally. I'm still fixing bugs in the modules and investigating issue which might be Clang bugs.

I'm also still busy to remove symbols from the global namespace so I can start to test the std module, for now I only test with the std.compat module.

libcxx/docs/Modules.rst

25–26

I fully agree. For now we will also ship a CMake file to aid users. But once build systems catch up that CMake file will be removed. At the moment we're not even sure where our .cppm files will be installed, so asking buildsystems to support libc++ is a bit premature. Having this information makes it possible for early adaptors to get started.

43

I've removed the section.

137

This is indeed a typo.

162–164

I will consider attending in SG15 to discuss this.

libcxx/modules/std.compat/cassert.cppm

11–17 ↗

(On Diff #506637)

It kind of is, but it's easier to have tooling that makes sure every header is a module. This way there need to be no exceptions. Some of the "empty" modules may get symbols in the future.

[ChuanqiXu]

Not at the moment. There are some CI issues not related to modules which should be resolved first. However I am testing with the CI configuration locally. I'm still fixing bugs in the modules and investigating issue which might be Clang bugs.

Oh, got it. Never be hurry : )

libcxx/modules/std.compat/cassert.cppm

11–17 ↗

(On Diff #506637)

Got your point. I remember the paper said clearly that assert and errno is not exported in the std modules. But it doesn't matter really.

[Mordante]

libcxx/modules/std.compat/cassert.cppm

11–17 ↗

(On Diff #506637)

I can't find that in the paper nor in the WP. There is http://eel.is/c++draft/std.modules#note-2 which states

[Note 2: Like all named modules, the C++ library modules do not make macros visible ([module.import]), such as assert ([cassert.syn]), errno ([cerrno.syn]), offsetof ([cstddef.syn]), and va_arg ([cstdarg.syn]).
— end note]

[ChuanqiXu]

libcxx/modules/std.compat/cassert.cppm

11–17 ↗

(On Diff #506637)

Oh, my bad for confusing : )

[Mordante]

Several minor improvements.

• updates comments
• removes C++20 modules
• adds new module specific tests using AST matchers
• fixes several module bugs, mainly found by the new tests

[Mordante]

Rebased on main and resolved merge conflicts.

[ChuanqiXu]

libcxx/test/libcxx/module_std.sh.cpp

227 ↗

(On Diff #512886)

I can't search libcpp-header-exportable-declarations. Is there a patch that haven't been uploaded?

[Mordante]

libcxx/test/libcxx/module_std.sh.cpp

227 ↗

(On Diff #512886)

It's in the file libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp which is part of this patch.
(It still has some issues, but I wanted to post some progress again.)

[philnik]

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

92 ↗

(On Diff #512886)

102–106 ↗

(On Diff #512886)

I think that's the idiomatic way to do this.

141–156 ↗

(On Diff #512886)

We have something very similar in ugilfy_attributes.cpp. Maybe we should add a header for a few utilities?

165 ↗

(On Diff #512886)

Is this equivalent to decl->getName()?

172 ↗

(On Diff #512886)

What is this doing?

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.hpp

21 ↗

(On Diff #512886)

Would an unordered_set be better?

[Mordante]

Thanks for the review!

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

92 ↗

(On Diff #512886)

Thanks I already spotted this locally.

102–106 ↗

(On Diff #512886)

Interesting I wasn't aware llvm::isa multiple arguments. For now I keep it as is, but leave this comment open,

Once the code is working as intended I will see whether this change improves the code.

141–156 ↗

(On Diff #512886)

That might be useful. BTW if (str[0] == '_' && str[1] >= 'A' && str[1] <= 'Z' does not work properly in EBCDIC.

165 ↗

(On Diff #512886)

The documentation in not fully clear, but since getName() returns a StringRef I'm sure it's not the same.
getName() would return fill where get_qualified_name() returns std::fill or std::ranges::fill.

172 ↗

(On Diff #512886)

Dumping a line like using std::vector. This checker is not a real checker, but extracts information.
The output of a toplevel header is compared with the output of a module.
This is done in libcxx/test/libcxx/module_std.sh.cpp (which very much under review and I'm still looking at the failures.)

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.hpp

21 ↗

(On Diff #512886)

I haven't tested. Most headers don't have a lot of declarations. The module type_traits which is one of the larger modules has less than 300 entries. (In total there are less than 4000 entries in the Standard library.)

[ChuanqiXu]

libcxx/modules/CMakeLists.txt.in

48 ↗

(On Diff #512886)

I guess we need a better library name before landing this.

[Mordante]

libcxx/modules/CMakeLists.txt.in

48 ↗

(On Diff #512886)

What would you propose?
I'm not even sure we really need to, but this is something to determine during a review.

[ChuanqiXu]

libcxx/docs/Modules.rst

84–99

Will these problems be blockers actually? Specially for the "header-module" order problem, we can't fix it fundamentally. And I feel 'std module' is still workable in some degree with these defects. If these problems are not blockers actually, could we move the "limitations" section?

libcxx/modules/CMakeLists.txt.in

48 ↗

(On Diff #512886)

What would you propose?

I use libstdmodule.a in the downstream. But it looks not good enough for the upstream.

I'm not even sure we really need to, but this is something to determine during a review.

Ideally this should be handled by cmake (or other build systems). But we need it now to make progress. How about something like 'libc++_std_module.a'?

[Mordante]

libcxx/docs/Modules.rst

84–99

I think this one isn't I think we should downgrade this one to limitation.

[aaronmondal]

Any idea how to get this diff from phabricator in a way that doesn't include the changes to the modules directory? That part somehow messes up Bazel's patching.

libcxx/modules/CMakeLists.txt.in

48 ↗

(On Diff #512886)

Don't have a strong opinion on this, though this will probably be painful to change once users adopt any name.

libc++-std.a, lib++_std.a? Though I personally think just std would be fine.

The std.compat archive should follow a similar scheme though.

[ChuanqiXu]

libcxx/docs/Modules.rst

84–99

What do you mean for this one?

[aaronmondal]

Started testing the Bazel build. Seems to almost build. The __new is a slight inconvenience, but easily worked around and I don't think we can do too much about it.

Only std:memory doesn't build yet on my end.

I'm also noticing that this will place quite the significant restriction on the compiler building the modules. It's a bit unintuitive to build libc++ with C++20 and the interfaces/partitions with C++23. It's more intuitive to build the entire libc++ (sources) with C++23 (which works), but I'd assume that the only compiler capable of doing that at the moment upstream Clang itself 🤣

libcxx/modules/CMakeLists.txt.in

48 ↗

(On Diff #512886)

I think I'm misunderstanding this target. What are the contents of this archive?

libcxx/modules/std/memory.cppm

183–184 ↗

(On Diff #512886)

This seems to break the build for me with "no member atomic in namespace std". Where is this symbol coming from?

The <atomic> include is disabled for C++23. Maybe I'm just missing some config flag?

[Mordante]

In D144994#4282770, @aaronmondal wrote:

Started testing the Bazel build. Seems to almost build. The __new is a slight inconvenience, but easily worked around and I don't think we can do too much about it.

Yeah we can't use new since it's a keyword.

I'm also noticing that this will place quite the significant restriction on the compiler building the modules. It's a bit unintuitive to build libc++ with C++20 and the interfaces/partitions with C++23. It's more intuitive to build the entire libc++ (sources) with C++23 (which works), but I'd assume that the only compiler capable of doing that at the moment upstream Clang itself 🤣

We can't nicely build libc++ with C++23, this requires a newer CMake. (I have a patch for it, but I'm waiting for the last buildbots to be updated.)
It could be done with older CMake versions, but that is quite inconvenient.

Since we have a CI it will be trivial to test whether our supported compilers have sufficient C++23 support to build libc++

libcxx/docs/Modules.rst

84–99

This bullet point.

libcxx/modules/CMakeLists.txt.in

48 ↗

(On Diff #512886)

This is the library for the module std. So next to the .pcm files there is a library component.

libcxx/modules/std/memory.cppm

183–184 ↗

(On Diff #512886)

I'm not sure, but there are several errors in the modules. I copy-paste the synopis and manually cleaned them, so errors were always bound to occur.

There is a test module_std.sh.cpp which validates the declarations in the include files and in the modules.
This found quite some issues, some parts are not implemented in libc++, the synopsis only sometimes doesn't have all declarations (bitmask types for example), etc/
I'm not sure whether the test flags this one, but I have some patches to fix some of the issue found in libc++ itself.

[aaronmondal]

Yeah we can't use new since it's a keyword.

Actually, what about renaming the new.cppm to __new.cppm? The issue with new.cppm is that you can't grep/ls all files in the libcxx/modules directory and extract the partition names from the filenames that way. Since the partition is named std:__new, naming the file same seems more natural.

The downside of this is that __new doesn't 1:1 correspond to the <new> header name. Since there is no include/__new in the same way that there is e.g. include/__algorithm there is little room for confusion though, and users can't directly import the partitions anyways.

[ldionne]

libcxx/test/std/time/time.syn/formatter_tests.h

22 ↗

(On Diff #512886)

This doesn't seem necessary at all, it's included above.

[aaronmondal]

Yayyy we have a working hello world https://github.com/eomii/rules_ll/pull/98 🥳

[aaronmondal]

I've just opened https://github.com/llvm/llvm-project/issues/62269 to track progress on the irreproducibility of BMIs. After thinking about this for a while, believe that this could be more of an issue than I initially thought. IMO we should add a warning that Module precompilation currently leaks absolute paths into BMIs.

[ChuanqiXu]

libcxx/docs/Modules.rst

84–99

Oh, this bullet has 3 issues. I thought you referred to one of them.

[ldionne]

As discussed, let's split the cppm files into a separate review so we can get the bulk of the mechanical changes in.

libcxx/modules/std/format.cppm

10 ↗

(On Diff #512886)

As discussed, I think this makes it too hard to distinguish what is a comment and what is an actual declaration. Thanks so much for doing the experiment -- I think it was a good idea on paper but it turns out to be a bit too hard to read.

libcxx/modules/std/memory.cppm

31 ↗

(On Diff #512886)

This has been fixed now. Also some stuff in <mutex> and <utility>, see D145589.

[Mordante]

Various cleanups
Documentation updates
Removed magic header from modules, this requires Clang 17

[Mordante]

Rebased.

[Mordante]

Removes some no longer needed work-arounds.
Adds a work-around for as_rvalue, which will be put in a separate review too.

[aaronmondal]

Regarding compilation of the BMIs themselves the only issue left seems to be that <type_traits> doesn't export some symbols and <functional> needs to be included in its cppm at the moment. Other than that everything builds and std is importable.

Some std:: symbols still breaks in a few unsurprising places, e.g. format/ranges.

[Mordante]

In D144994#4325321, @aaronmondal wrote:

Regarding compilation of the BMIs themselves the only issue left seems to be that <type_traits> doesn't export some symbols and <functional> needs to be included in its cppm at the moment. Other than that everything builds and std is importable.

Some std:: symbols still breaks in a few unsurprising places, e.g. format/ranges.

The first part for functional is D149351 which moves these declarations in the proper primary header.
On my list there are some issues with invocable too.

Once these are done I can start to finalize the cppm files.

[Mordante]

Polish the standard modules.

[Mordante]

Rebased on main.

[Mordante]

Final review of the std module

• fixes some minor issues
• enables the declarations that have been recently implemented by various contributors

[Mordante]

I split of the .cppm files for the std module in D151030 once that lands I'll rebase this patch on top of that.

[ldionne]

libcxx/utils/use_modules_in_test.py

2

Let's extract this to its own patch.

160

Could we instead use this annotation in the test itself, with a relevant comment?

// UNSUPPORTED: use_module_std && !(c++11 || c++14 || c++17)

Or actually, we can use just

// UNSUPPORTED: use_module_std

since we never run with use_module_std in C++11/14/17.

170–177

The fact that we need to disable these tests is quite interesting. I think it surfaces a pretty big problem with modules (as a language feature). Today, we use macros and compiler flags to customize the behavior of the library on a per translation-unit basis. That is an extremely important property of some aspects of the library (*). If we want everything to transition to modules (and we do), we need a way to satisfy those use cases. I don't mind whether that's done by defining macros, via some compiler flags or some other way, but those use cases are valid and we need to figure out how we're going to support them. Otherwise, we'll be left with large parts of our user base that can't switch over to C++ modules because they don't support some required use cases.

(*) For example, we use _LIBCPP_ENABLE_ASSERTIONS to control whether assertions are enabled or not on a per-TU basis. This is extremely important: when converting code bases to assertions, users might want to prevent assertions in some performance critical parts of the code, while still enabling assertions everywhere else. This approach allows for an incremental adoption of the feature and that's an important aspect of it being deployable in the real world.

I would like us to discuss avenues we could use to satisfy these use cases. For example, could we ship multiple "versions" of the library, each configured differently, and then the compiler would use a different version based on the compiler flags it is passed? I think pretty much all vendors are going to have similar questions, and that's going to severely limit how useful C++ modules can be in the real world. @jwakely @CaseyCarter I assume that's also something that you folks have thought about?

CC @ChuanqiXu

[ChuanqiXu]

libcxx/utils/use_modules_in_test.py

170–177

(I am not 100% sure that I understand your question)

A background (I guess you already know this. But I'd like to repeat it again to avoid misunderstandings): we're going to ship (*.cppm) files. And the compilation of the std modules would happen in the users' machine. Also the compilation of the std modules may occur multiple times due to different configuration of the build. For example, the Release build and the Debug build will compile std modules twice with different options. And ideally the process would be controlled by the build systems (cmake).

The consensus in SG15 now is that we need to ship source files (*.cppm files) and a metadata file to describe the requirement/information of the library/module. Note that SG15 doesn't have a consensus (or even a feeling as far as I know) how the metadata should be.

So a temporary conclusion here is that possibly there is not an off-the-shelf practice that we can take directly. We would have to explore the method during the practice.

Also, I strongly suggest to send this question to SG15 and there are multiple experts who studied the problem for a relative long time. Maybe it will be more helpful than the small group discussion here.

CC: @ruoso @ben.boeckel

[ldionne]

libcxx/utils/use_modules_in_test.py

170–177

we're going to ship (*.cppm) files. And the compilation of the std modules would happen in the users' machine.

Yes, we're on the same page. I'm not sure why I mentioned shipping various versions of the library, I was thinking about the need to pre-build multiple versions of the library for testing purposes (which is not related). Let me try to clarify my concern, and you can let me know whether I'm getting agitated for no good reason :-). Let's take for example _LIBCPP_ENABLE_ASSERTIONS. Today, that's a macro you define as -D_LIBCPP_ENABLE_ASSERTIONS=1 on the command-line or #define _LIBCPP_ENABLE_ASSERTIONS 1 as the first thing in your file, and the result is that libc++ functions like operator[] will be compiled with some assertions inside. This can be controlled on a per-TU basis today using the #include model we all know.

How do we do that in modules world if you're using import std instead? You can still pass -D_LIBCPP_ENABLE_ASSERTIONS=1 on the command-line, however that won't do anything because the compiler is using the BMI files that have already been compiled and _LIBCPP_ENABLE_ASSERTIONS was set to 0 when those were compiled. Right?

You can also still use #define _LIBCPP_ENABLE_ASSERTIONS=1 as the first thing in your file, but that also won't do anything because import std; doesn't have any way (or desire) to somehow resolve to a different BMI depending on the current macro environment. Right?

Basically, my question is: "What's the WG21-blessed alternative for this use case"? Are we expected to lift this mechanism from -D_LIBCPP_ENABLE_ASSERTIONS=1 to some other compiler flag like -flibcxx-enable-assertions (with a better name)? Then users would tell their build-system to build specific TUs using that flag, and that would result in different BMIs being compiled and used for those TUs? I think that would work, but it would create some challenges for sure.

If that's the expectation, then it means that we either need to build multiple configurations of the library BMIs during CMake invocation for the test suite to reuse, or lit needs to be able to somehow rebuild BMIs (or ask CMake to do it) based on the requirement of various tests in the test suite. For example, you'd tell lit that you're using -fsized-deallocation in your test, so it would go and rebuild the BMIs for libc++ with that set of compiler flags, and then set the appropriate substitution for that test to use the right BMIs for -fsized-deallocation. Possible, but fun to implement :-)

[davidstone]

libcxx/utils/use_modules_in_test.py

170–177

The point that you would define _LIBCPP_ENABLE_ASSERTIONS=1 is when you compile the module in which you want to enable assertions. In other words, you can control it on a per-TU basis for the code that has the assertions, but not for the code using the code that has assertions. In general, you get ODR violations if the user's code is using multiple versions of library code.

So the user would not define the macro in their source file, nor would they (in CMake terms) associate the macro with their own target, they would either define the macro globally in their build system or associate it (somehow) with the standard library build target.

[ChuanqiXu]

libcxx/utils/use_modules_in_test.py

170–177

@ldionne Oh, I got your point. You're mainly talking about testing instead of distributing. (IIUC).

How do we do that in modules world if you're using import std instead? You can still pass -D_LIBCPP_ENABLE_ASSERTIONS=1 on the command-line, however that won't do anything because the compiler is using the BMI files that have already been compiled and _LIBCPP_ENABLE_ASSERTIONS was set to 0 when those were compiled. Right?

You can also still use #define _LIBCPP_ENABLE_ASSERTIONS=1 as the first thing in your file, but that also won't do anything because import std; doesn't have any way (or desire) to somehow resolve to a different BMI depending on the current macro environment. Right?

Yes. This is by design. We don't want the build of modules to be affected by its users.

Basically, my question is: "What's the WG21-blessed alternative for this use case"?

The expected solution may be add a metadata file (which haven't been defined yet) to the library and the metadata file will contain informations about the interested flags of the library.

And if there are two (multiple) users use the same library and all the flags they used in the interesting flag set are the same, they can reuse the same BMI file. But if there is any different flag in the interesting flag set, they have to use different BMI file.

Let's come back to the example of testing of libcxx. Here every lit test with a configuration is a user of the std module. But the same lit test with different configuration are considered to be different users of the std module. And in your example, both -D_LIBCPP_ENABLE_ASSERTIONS and -fsized-deallocation are the interesting flags.

BTW, the intention of the design is that, (I guess you already know this too. Just repeat again to be informative. Sorry if this is wordy), the build system will rebuild the BMIs if the input compilation flag contains -DINTERESTING_MACRO=NEW_VALUE but the build system are capable to reuse the BMIs if the input compilation flag contains -DABCDEFG. This is important because almost every library has local macro definitions.

Given the lit tests are internal users, maybe we can assume all the flags to be interesting flags.

If that's the expectation, then it means that we either need to build multiple configurations of the library BMIs during CMake invocation for the test suite to reuse, or lit needs to be able to somehow rebuild BMIs (or ask CMake to do it) based on the requirement of various tests in the test suite.

If I read correctly, yes.

My mental model for the general case would be:

1. the user (a lit test with a configuration in this example) would ask the build system about the location of the BMI file with a certain module name and a list of flags.
2. The build systems will lookup if the appropriate BMI exists. If yes, return the location. If not, build it and return the location.

And in the testing case, maybe we need to implement a mechanism for lit and cmake to communicate with each other.

[ChuanqiXu]

libcxx/utils/use_modules_in_test.py

170–177

We don't want the build of modules to be affected by its users.

We don't want the build of modules to be affected by its users surprisingly. That said, the build of the modules can be affected by its users if and only if in the way designed by the modules.

[ben.boeckel]

libcxx/utils/use_modules_in_test.py

170–177

We don't want the build of modules to be affected by its users surprisingly.

Alas, consumers do need to agree on a lot of flags. We'll need at least a BMI per consuming standard. Probably per flag like -D_LIBCPP_* and the like, whatever -f and -m flags affect ABI, etc. I'd love for "I build module X one way and everyone agrees", but implementors have told me that it doesn't work that way. The ODR probably pops in at the other extreme as well.

[Mordante]

libcxx/utils/use_modules_in_test.py

170–177

Is there a way to indicate BMIs are incompatible due to ODR violations? For example when the size of a struct changes depending on compiler flags used?

[ben.boeckel]

libcxx/utils/use_modules_in_test.py

170–177

My understanding is that Clang stores the flags used to make the BMI in the BMI and if they mismatch "enough", it is incompatible. Given that…just about every flag does this (e.g., anything that affects __has_attribute, __has_builtin, or other preprocessor state), the BMI compatibility contract is very narrow. Named modules *might* be able to be a bit looser given how preprocessor state is far more isolated, but header units are going to leak these state differences far more easily.

[ChuanqiXu]

libcxx/utils/use_modules_in_test.py

170–177

Currently clang will try to perform a strict check when loading BMIs. For example if a TU imports module A and B, and the same declaration in module A and B differ, clang will emit an error.

For example when the size of a struct changes depending on compiler flags used?

But this may not be possible IIUC.

[DanielaE]

@Mordante As your direction is 'lifting' exported names from the GMF into the module purview I've initiated core issue CWG2783 https://cplusplus.github.io/CWG/issues/2783.html to strengthen the foundations.

[Mordante]

In D144994#4607621, @DanielaE wrote:

@Mordante As your direction is 'lifting' exported names from the GMF into the module purview I've initiated core issue CWG2783 https://cplusplus.github.io/CWG/issues/2783.html to strengthen the foundations.

Thanks @DanielaE! After our last discussion I had looking at this at my todo list.

[Mordante]

Since we move to GitHub PRs we're cleaning up our review queue. I abandon this patch and provide GitHub PRs for the not yet landed parts.

libcxx/CMakeLists.txt

 option(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS
   "Whether to turn on vendor availability annotations on declarations that depend
    on definitions in a shared library. By default, we assume that we're not building
    libc++ for any specific vendor, and we disable those annotations. Vendors wishing
    to provide compile-time errors when using features unavailable on some version of
    the shared library they shipped should turn this on and see `include/__availability`
    for more details." OFF)
 option(LIBCXX_ENABLE_CLANG_TIDY "Whether to compile and run clang-tidy checks" OFF)
+option(LIBCXX_ENABLE_STD_MODULE
+   "Whether to enable the building the C++23 std module. This feature is experimental
+    and far from usable. Only enable this when interested in testing and developing
+  this module." OFF)
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared-gcc.cfg.in")
 elseif(MINGW)
   set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-mingw.cfg.in")
 elseif(WIN32) # clang-cl
   if (LIBCXX_ENABLE_SHARED)
     set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared-clangcl.cfg.in")

 
 #===============================================================================
 # Configure System
 #===============================================================================
 
 # TODO: Projects that depend on libc++ should use LIBCXX_GENERATED_INCLUDE_DIR
 # instead of hard-coding include/c++/v1.
 
+# TODO: The LIBCXX_GENERATED_MODULE_DIR is a placeholder. A proper directory
+# needs to be determined. Maybe look at how other library vendors tackle this.
+
 set(LIBCXX_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/c++/v1" CACHE PATH
     "Path where target-agnostic libc++ headers should be installed.")
 set(LIBCXX_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
     "Path where built libc++ runtime libraries should be installed.")
 
 set(LIBCXX_SHARED_OUTPUT_NAME "c++" CACHE STRING "Output name for the shared libc++ runtime library.")
 set(LIBCXX_STATIC_OUTPUT_NAME "c++" CACHE STRING "Output name for the static libc++ runtime library.")
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
   set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")
+  set(LIBCXX_GENERATED_MODULE_DIR "${LLVM_BINARY_DIR}/include/c++/modules")
   set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LLVM_BINARY_DIR}/include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1")
   set(LIBCXX_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH
       "Path where built libc++ libraries should be installed.")
   set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1" CACHE PATH
       "Path where target-specific libc++ headers should be installed.")
   if(LIBCXX_LIBDIR_SUBDIR)
     string(APPEND LIBCXX_LIBRARY_DIR /${LIBCXX_LIBDIR_SUBDIR})
     string(APPEND LIBCXX_INSTALL_LIBRARY_DIR /${LIBCXX_LIBDIR_SUBDIR})
   endif()
 else()
   if(LLVM_LIBRARY_OUTPUT_INTDIR)
     set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
     set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")
+  set(LIBCXX_GENERATED_MODULE_DIR "${LLVM_BINARY_DIR}/include/c++/modules")
   else()
     set(LIBCXX_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBCXX_LIBDIR_SUFFIX})
     set(LIBCXX_GENERATED_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/c++/v1")
+  set(LIBCXX_GENERATED_MODULE_DIR "${CMAKE_BINARY_DIR}/include/c++/modules")
   endif()
   set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LIBCXX_GENERATED_INCLUDE_DIR}")
   set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX} CACHE PATH
       "Path where built libc++ libraries should be installed.")
   set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}" CACHE PATH
       "Path where target-specific libc++ headers should be installed.")
 endif()
 

 endfunction()
 
 #===============================================================================
 # Setup Source Code And Tests
 #===============================================================================
 add_subdirectory(include)
 add_subdirectory(src)
 add_subdirectory(utils)
+if (LIBCXX_ENABLE_STD_MODULE)
+  add_subdirectory(stdmodules)
+endif()
 
 set(LIBCXX_TEST_DEPS "cxx_experimental")
 
 if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY)
   list(APPEND LIBCXX_TEST_DEPS cxx_external_threads)
 endif()
 
 if (LIBCXX_ENABLE_CLANG_TIDY)
   list(APPEND LIBCXX_TEST_DEPS cxx-tidy)
 endif()
 
+if (LIBCXX_ENABLE_STD_MODULE)
+  list(APPEND LIBCXX_TEST_DEPS generate-cxx-modules)
+endif()
+
 if (LIBCXX_INCLUDE_BENCHMARKS)
   add_subdirectory(benchmarks)
 endif()
 
 if (LIBCXX_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(lib/abi)
 endif()
 
 if (LIBCXX_INCLUDE_DOCS)
   add_subdirectory(docs)
 endif()

libcxx/cmake/caches/Generic-module-std-compat.cmake

+set(LIBCXX_ENABLE_STD_MODULE ON CACHE BOOL "")
+set(LIBCXX_TEST_PARAMS "enable_modules=std.compat" CACHE STRING "")
+set(LIBCXXABI_TEST_PARAMS "${LIBCXX_TEST_PARAMS}" CACHE STRING "")
+

libcxx/cmake/caches/Generic-module-std.cmake

+set(LIBCXX_ENABLE_STD_MODULE ON CACHE BOOL "")
+set(LIBCXX_TEST_PARAMS "enable_modules=std" CACHE STRING "")
+set(LIBCXXABI_TEST_PARAMS "${LIBCXX_TEST_PARAMS}" CACHE STRING "")
+

libcxx/docs/Modules.rst

+.. _ModulesInLibcxx:
+
+=================
+Modules in libc++
+=================
+
+This page contains information regarding C++23 module support in libc++.
+There are two kinds of modules available in Clang
+
+ * `Clang specific modules <https://clang.llvm.org/docs/Modules.html>`_
+ * `C++ modules <https://clang.llvm.org/docs/StandardCPlusPlusModules.html>`_
+
+This page mainly discusses the C++ modules. In C++ there are also header units,
+these are not in this patch.
+
+This information is mainly to describe some of the features of this work in
+progress patch. It is not intended to be committed in this form.
+
+Overview
+========
+
+The module sources are stored in ``.cppm`` files. These need to be available as
+BMIs, which are ``.pcm`` files for Clang. These files are not portable, they
+depend on the compiler used and its compilation flags. Therefore there needs to
+be a way to distribute the ``.cppm`` files to the user and offer a way for them
+to build and use the ``.pcm`` files.
+
+What works
+~~~~~~~~~~
+
+ * Building BMIs
+ * Running tests using modules, not all tests pass yet.
+ * Using the ``std`` module in external projects
+ * Using the ``std.compat`` module in external projects
+
+Some of the current limitations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ * For now everything requires CMake.
+ * The files are not installed, but available in the build tree.
+ * The ``pcm`` files are regenerated when running a ``lit`` invocation.
+ * There is no Buildkite CI job yet.
+ * All tests need to be modified for modules, this can be done with a tool.
+ * The ``std`` module is incomplete.
+ * The ``std.compat`` module is incomplete.
+ * Requires CMake 3.26 (soon to be released)
+ * Requires Ninja 1.11
+ * Requires Clang 17 (Clang 16 should work, but is not tested)
+ * The path to the compiler may not be a symlink, ``clang-scan-deps`` does
+   not handle that case properly.
+ * There is no `P1689 style output <https://wg21.link/P1689>`_ yet.
+   The file generated by clang-scan-deps contains absolute paths to the files
+   in the libc++ build directory. (These should be relative paths or paths to
+   the installation directory.)
+ * Configurations with parts disable do not work properly. The ``#ifdef``
+   are not in the ``.cppm`` files yet.
+
+Blockers
+~~~~~~~~
+
+  * libc++
+
+    * Tests depend on ``uint32_t``, ``size_t`` in the global namespace.
+      Fixing this is WIP.
+    * There are a lot of failing tests, this needs to be investigated after
+      the global namespace issues have been fixed.
+      Currently 210 of the 7243 test in the directory ``libcxx/test/std`` fail.
+    * CMake 3.26 doesn't work with ``libunwind``. For ``libc++`` and
+      ``libc++abi`` it ignores a lot of compilation flags.
+      `Patch <https://llvm.org/D145596>`__
+    * The ``-pthread`` flag is not used a compile flag. This flag affects
+      the preprocessor so it should be a compile and linker flag.
+      There is a WIP patch.
+    * There are symbols with internal linkage in the header.
+
+      * Due to older language versions don't support ``inline constexpr``.
+        `Patch <https://reviews.llvm.org/D143797>`__
+      * The code contains ``_LIBCPP_HIDE_FROM_ABI static constexpr``. There
+        might be a patch.
+
+  * Clang
+
+    * ``__synth_three_way_result`` does not work. There is a work-around in libc++.
+
+      * `bug report <https://github.com/llvm/llvm-project/issues/57222>`__
+      * `patch <https://reviews.llvm.org/D140002>`__
+
+    * The ranges Niebloids doen't work properly. There is no bug report, this
+      might be related to ``__synth_three_way_result``. Changing
+      ``inline constexpr auto foo = foo_t{}`` to
+      ``inline constexpr foo_t foo{}`` seems to fix it in libc++.
+
+Discussion points
+~~~~~~~~~~~~~~~~~
+
+ * The ``std`` module is a C++23 feature, currently it's available in both
+   ``C++20`` and ``C++23``. The simple reason is that this allows testing with
+   different language versions. (This will be needed once the first ``C++26``
+   features become available.) Does libc++ want to retroactively supply the
+   module in ``C++23`` or restrict it to ``C++23`` and later?
+ * Do we want the feature behind a configuration flag or not? Louis already
+   mentioned he prefers it generally available. Then we need to restrict it on
+   the CMake version used.
+ * I'm not too unhappy with the generic approach for user project. I am quite
+   unhappy with how we need to do tests. I have some ideas how we can improve
+   this, basically by caching multiple configurations. However it would be good
+   to discuss that approach before spending effort in it.
+ * Currently the ``.cppm`` file and the generated ``CMakeLists.txt`` are not
+   installed. Before doing that it would be good to determine what the best
+   location for these files is.
+ * The current approach to make the tests work with modules add a ``#ifdef``
+   to select between including headers or importing the module ``std``.
+   This works great for testing during development, however the libc++
+   maintainers need to decide to keep using this approach in production or
+   that a different solution needs to be used.
+ * Should P1689 style output files be shipped with libc++?
+
+
+Running tests
+=============
+
+In order to run the tests with C++23 modules the libc++ needs to be build with
+the following configuration option in CMake ``LIBCXX_ENABLE_STD_MODULE``.
+
+The tests are executed like
+
+.. code-block:: bash
+
+  $ <build>/bin/llvm-lit -sv libcxx/test/std/containers # Run the tests without modules
+  $ <build>/bin/llvm-lit -sv -Denable_modules=clang libcxx/test/std/containers # Run the tests with Clang modules
+  $ <build>/bin/llvm-lit -sv -Denable_modules=std libcxx/test/std/containers # Run the tests with Standard modules
+
+The Clang modules are the modules that have been available for many libc++ releases.
+The Standard modules are the new feature.
+
+Using in external projects
+==========================
+
+Users need to be able to build their own BMI files. Currently this requires a
+local build of libc++ with modules enabled. "Importing" libc++ is a project can
+be done with the following CMake code.
+
+.. code-block:: cmake
+
+  include(FetchContent)
+  FetchContent_Declare(
+    std
+    URL file://<build>/include/c++/modules/
+    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+  )
+  FetchContent_GetProperties(std)
+  if(NOT std_POPULATED)
+    # The C++ version used in your project must match the version used here.
+    set(CMAKE_CXX_STANDARD 23)
+    # These compiler flags must match the flags used in your project.
+    # When they don't match the generated BMIs can't be used in your project.
+    set(CMAKE_CXX_FLAGS "-fexperimental-library")
+    FetchContent_Populate(std)
+    add_subdirectory(${std_SOURCE_DIR} ${std_BINARY_DIR} EXCLUDE_FROM_ALL)
+  endif()
+
+The libraries and/or executables that use the ``std`` module need to link
+against the ``std`` library. This is needed for CMake to get the proper module
+dependencies.

libcxx/docs/index.rst

 .. toctree::
    :maxdepth: 1
 
    ReleaseNotes
    UsingLibcxx
    BuildingLibcxx
    TestingLibcxx
    Contributing
+   Modules
    Status/Cxx14
    Status/Cxx17
    Status/Cxx20
    Status/Cxx2b
    Status/Format
    Status/Ranges
    Status/Spaceship
    Status/Zip

libcxx/include/__algorithm/ranges_find_if.h

 
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
 template <class _Ip, class _Sp, class _Pred, class _Proj>
-_LIBCPP_HIDE_FROM_ABI static constexpr
+_LIBCPP_HIDE_FROM_ABI constexpr // HAS THIS BEEN FIXED UPSTREAM???
 _Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
   for (; __first != __last; ++__first) {
     if (std::invoke(__pred, std::invoke(__proj, *__first)))
       break;
   }
   return __first;
 }
 

libcxx/include/__algorithm/ranges_min_element.h

 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
 // TODO(ranges): `ranges::min_element` can now simply delegate to `std::__min_element`.
 template <class _Ip, class _Sp, class _Proj, class _Comp>
-_LIBCPP_HIDE_FROM_ABI static constexpr
+_LIBCPP_HIDE_FROM_ABI constexpr
 _Ip __min_element_impl(_Ip __first, _Sp __last, _Comp& __comp, _Proj& __proj) {
   if (__first == __last)
     return __first;
 
   _Ip __i = __first;
   while (++__i != __last)
     if (std::invoke(__comp, std::invoke(__proj, *__i), std::invoke(__proj, *__first)))
       __first = __i;

libcxx/include/__compare/synth_three_way.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 // [expos.only.func]
 
+// Fails with C++20 modules.
+// https://github.com/llvm/llvm-project/issues/57222#issuecomment-1261618636
+// Possible fix https://reviews.llvm.org/D140002
+#if 0
 _LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way =
   []<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
     requires requires {
       { __t < __u } -> __boolean_testable;
       { __u < __t } -> __boolean_testable;
     }
   {
     if constexpr (three_way_comparable_with<_Tp, _Up>) {
       return __t <=> __u;
     } else {
       if (__t < __u) return weak_ordering::less;
       if (__u < __t) return weak_ordering::greater;
       return weak_ordering::equivalent;
     }
   };
+#else
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __synth_three_way(const _Tp& __t, const _Up& __u)
+    requires requires {
+      { __t < __u } -> __boolean_testable;
+      { __u < __t } -> __boolean_testable;
+    }
+  {
+    if constexpr (three_way_comparable_with<_Tp, _Up>) {
+      return __t <=> __u;
+    } else {
+      if (__t < __u) return weak_ordering::less;
+      if (__u < __t) return weak_ordering::greater;
+      return weak_ordering::equivalent;
+    }
+  }
+#endif
 
 template <class _Tp, class _Up = _Tp>
 using __synth_three_way_result = decltype(std::__synth_three_way(std::declval<_Tp&>(), std::declval<_Up&>()));
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___COMPARE_SYNTH_THREE_WAY_H

libcxx/include/tuple

 template <class _Up>
 struct __ignore_t
 {
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     const __ignore_t& operator=(_Tp&&) const {return *this;}
 };
 
-namespace {
-  constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
-} // namespace
+// SEPARATE REVIEW NEEDS TO USE NEW INLINE CONSTEXPR MACRO
+//namespace {
+  inline constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
+//} // namespace
 
 template <class... _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 tuple<typename __unwrap_ref_decay<_Tp>::type...>
 make_tuple(_Tp&&... __t)
 {
     return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
 }

libcxx/stdmodules/.clang-format

+BasedOnStyle: InheritParentConfig
+
+NamespaceIndentation: All

libcxx/stdmodules/CMakeLists.txt

+set(LIBCXX_SOURCES_MODULE_STD
+  std.cppm
+  #std-algorithm.cppm
+  std-array.cppm
+  std-charconv.cppm
+  std-chrono.cppm
+  std-coroutine.cppm
+  std-concepts.cppm
+  std-cstddef.cppm
+  std-cstdlib.cppm
+  std-exception.cppm
+  std-expected.cppm
+  std-format.cppm
+  std-functional.cppm
+  std-iterator.cppm
+  std-initializer_list.cppm
+  std-memory.cppm
+  std-numeric.cppm
+  std-optional.cppm
+  #std-ranges.cppm
+  std-span.cppm
+  std-string.cppm
+  std-string_view.cppm
+  std-system_error.cppm
+  std-type_traits.cppm
+  std-tuple.cppm
+  std-utility.cppm
+  std-variant.cppm
+  std-vector.cppm
+)
+if(LIBCXX_ENABLE_LOCALIZATION)
+  list(APPEND LIBCXX_SOURCES_MODULE_STD
+    std-fstream.cppm
+    std-iostream.cppm
+  )
+endif()
+
+set(LIBCXX_SOURCES_MODULE_STD_COMPAT
+  std-compat.cppm
+  std-compat-stddef.cppm
+)
+
+configure_file("CMakeLists.txt.in" "${LIBCXX_GENERATED_MODULE_DIR}/CMakeLists.txt" @ONLY)
+
+set(_all_modules "${LIBCXX_GENERATED_MODULE_DIR}/CMakeLists.txt")
+#list(APPEND LIBCXX_SOURCES_MODULE_STD ${LIBCXX_SOURCES_MODULE_STD_COMPAT})
+
+foreach(f ${LIBCXX_SOURCES_MODULE_STD} ${LIBCXX_SOURCES_MODULE_STD_COMPAT})
+  set(src "${CMAKE_CURRENT_SOURCE_DIR}/${f}")
+  set(dst "${LIBCXX_GENERATED_MODULE_DIR}/${f}")
+  add_custom_command(OUTPUT ${dst}
+    DEPENDS ${src}
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
+    COMMENT "Copying CXX module ${f}")
+  list(APPEND _all_modules "${dst}")
+endforeach()
+
+add_custom_target(generate-cxx-modules
+  ALL DEPENDS
+    ${_all_modules}
+)

libcxx/stdmodules/CMakeLists.txt.in

+# CMake 3.25 has modules support, but that does not work properly.
+cmake_minimum_required(VERSION 3.26)
+
+project(libc++-std LANGUAGES CXX)
+
+# CMake specific magic
+# In the future this probably is not needed and will be part of CMake itself.
+
+set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "2182bf5c-ef0d-489a-91da-49dbc3090d2a")
+set(CMake_TEST_CXXModules_UUID "a246741c-d067-4019-a8fb-3d16b0c9d1d3")
+
+set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
+string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
+  "${CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS}"
+  " -format=p1689"
+  " --"
+  " <CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS>"
+  " -x c++ <SOURCE> -c -o <OBJECT>"
+  " -MT <DYNDEP_FILE>"
+  " -MD -MF <DEP_FILE>"
+  " > <DYNDEP_FILE>")
+set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "clang")
+set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
+
+# Default to C++ extensions being off. Clang's modules support have trouble
+# with extensions right now.
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+
+#if( @_LIBCPP_ENABLE_EXPERIMENTAL@)
+# add_target_definitions(std PRIVATE _LIBCPP_ENABLE_EXPERIMENTAL)
+#endif()
+
+# Propagates the CMake options to the modules.
+#
+# This uses the std module hard-coded since the std.compat module does not
+# depend on these flags.
+macro(compile_define_if_not condition def)
+  if (NOT ${condition})
+    target_compile_definitions(std PRIVATE ${def})
+  endif()
+endmacro()
+macro(compile_define_if condition def)
+  if (${condition})
+    target_compile_definitions(std PRIVATE ${def})
+  endif()
+endmacro()
+
+# TODO Evaluate whether all are needed
+compile_define_if(@LIBCXX_HAS_PTHREAD_API@ _LIBCPP_HAS_THREAD_API_PTHREAD)
+compile_define_if(@LIBCXX_HAS_EXTERNAL_THREAD_API@ _LIBCPP_HAS_THREAD_API_EXTERNAL)
+compile_define_if(@LIBCXX_HAS_WIN32_THREAD_API@ _LIBCPP_HAS_THREAD_API_WIN32)
+compile_define_if(@LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY@ _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
+compile_define_if(@LIBCXX_HAS_MUSL_LIBC@ _LIBCPP_HAS_MUSL_LIBC)
+#compile_define_if(@LIBCXX_NO_VCRUNTIME@ _LIBCPP_NO_VCRUNTIME)
+compile_define_if(@LIBCXX_ENABLE_PARALLEL_ALGORITHMS@ _LIBCPP_HAS_PARALLEL_ALGORITHMS)
+compile_define_if_not(@LIBCXX_ENABLE_FILESYSTEM@ _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+compile_define_if_not(@LIBCXX_ENABLE_RANDOM_DEVICE@ _LIBCPP_HAS_NO_RANDOM_DEVICE)
+compile_define_if_not(@LIBCXX_ENABLE_LOCALIZATION@ _LIBCPP_HAS_NO_LOCALIZATION)
+compile_define_if_not(@LIBCXX_ENABLE_FSTREAM@ _LIBCPP_HAS_NO_FSTREAM)
+compile_define_if_not(@LIBCXX_ENABLE_UNICODE@ _LIBCPP_HAS_NO_UNICODE)
+compile_define_if_not(@LIBCXX_ENABLE_WIDE_CHARACTERS@ _LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#compile_define_if_not(@LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS@ _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+compile_define_if(@LIBCXX_ENABLE_DEBUG_MODE@ _LIBCPP_ENABLE_DEBUG_MODE)
+#if (@LIBCXX_ENABLE_ASSERTIONS@)
+#  target_compile_definitions(std PRIVATE _LIBCPP_ENABLE_ASSERTIONS_DEFAULT 1)
+#else()
+#  target_compile_definitions(std PRIVATE _LIBCPP_ENABLE_ASSERTIONS_DEFAULT 0)
+#endif()
+
+add_library(std)
+target_sources(std
+  PUBLIC FILE_SET cxx_modules TYPE CXX_MODULES FILES
+    @LIBCXX_SOURCES_MODULE_STD@
+)
+
+target_compile_definitions(std PRIVATE _LIBCPP_ENABLE_EXPERIMENTAL)
+target_include_directories(std SYSTEM PRIVATE @LIBCXX_GENERATED_INCLUDE_TARGET_DIR@)
+
+target_compile_options(std
+  PUBLIC
+    -nostdinc++
+    @LIBCXX_COMPILE_FLAGS@
+)
+
+add_library(std.compat)
+target_sources(std.compat
+  PUBLIC FILE_SET cxx_modules TYPE CXX_MODULES FILES
+    @LIBCXX_SOURCES_MODULE_STD_COMPAT@
+)
+target_include_directories(std.compat SYSTEM PRIVATE @LIBCXX_GENERATED_INCLUDE_TARGET_DIR@)
+target_compile_options(std.compat
+  PUBLIC
+    -nostdinc++
+    # HACK to find the std module
+    -fmodule-file=std=CMakeFiles/std.dir/std.pcm
+    @LIBCXX_COMPILE_FLAGS@
+)
+target_link_libraries(std.compat PRIVATE std)

libcxx/stdmodules/std-array.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <array>
+
+export module std:array;
+export namespace std {
+
+  // [array], class template array
+  using std::array;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  // [array.special], specialized algorithms
+  using std::swap;
+
+  // [array.creation], array creation functions
+  using std::to_array;
+
+  // [array.tuple], tuple interface
+  using std::get;
+  using std::tuple_element;
+  using std::tuple_size;
+
+} // namespace std

libcxx/stdmodules/std-charconv.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <charconv>
+
+export module std:charconv;
+export namespace std {
+
+  // floating-point format for primitive numerical conversion
+  using std::chars_format;
+
+  // [charconv.to.chars], primitive numerical output conversion
+  using std::to_chars_result;
+
+  using std::to_chars;
+
+  // [charconv.from.chars], primitive numerical input conversion
+  using std::from_chars_result;
+
+  using std::from_chars;
+} // namespace std

libcxx/stdmodules/std-chrono.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <chrono>
+
+export module std:chrono;
+export namespace std {
+
+  namespace chrono {
+    using std::chrono::duration;
+    using std::chrono::time_point;
+
+  } // namespace chrono
+
+  using std::common_type;
+
+  namespace chrono {
+
+    // [time.traits], customization traits
+    using std::chrono::treat_as_floating_point;
+    using std::chrono::treat_as_floating_point_v;
+
+    using std::chrono::duration_values;
+
+    // using std::chrono::is_clock; NOT IMPLEMENTEDYET
+    // using std::chrono::is_clock_v; NOT IMPLEMENTEDYET
+
+    // [time.duration.nonmember], duration arithmetic
+    using std::chrono::operator+;
+    using std::chrono::operator-;
+    using std::chrono::operator*;
+    using std::chrono::operator/;
+    using std::chrono::operator%;
+
+    // [time.duration.comparisons], duration comparisons
+    using std::chrono::operator==;
+    using std::chrono::operator!=;
+    using std::chrono::operator<;
+    using std::chrono::operator>;
+    using std::chrono::operator<=;
+    using std::chrono::operator>=;
+    using std::chrono::operator<=>;
+
+    // [time.duration.cast], conversions
+    using std::chrono::ceil;
+    using std::chrono::duration_cast;
+    using std::chrono::floor;
+    using std::chrono::round;
+
+    // [time.duration.io], duration I/O
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+    using std::chrono::operator<<;
+#endif
+    // using std::chrono::from_stream; NOT IMPLEMENTEDYET
+
+    // convenience typedefs
+    using std::chrono::days;
+    using std::chrono::hours;
+    using std::chrono::microseconds;
+    using std::chrono::milliseconds;
+    using std::chrono::minutes;
+    using std::chrono::months;
+    using std::chrono::nanoseconds;
+    using std::chrono::seconds;
+    using std::chrono::weeks;
+    using std::chrono::years;
+
+    // [time.point.nonmember], time_point arithmetic
+
+    // [time.point.comparisons], time_point comparisons
+
+    // [time.point.cast], conversions
+    using std::chrono::time_point_cast;
+
+    // [time.duration.alg], specialized algorithms
+    using std::chrono::abs;
+
+    // [time.clock.system], class system_clock
+    using std::chrono::system_clock;
+
+    using std::chrono::sys_days;
+    using std::chrono::sys_seconds;
+    using std::chrono::sys_time;
+
+#if 0
+    // [time.clock.utc], class utc_clock
+    using std::chrono::utc_clock;
+
+    using std::chrono::utc_seconds;
+    using std::chrono::utc_time;
+
+    using std::chrono::leap_second_info;
+
+    using std::chrono::get_leap_second_info;
+    // [time.clock.tai], class tai_clock
+    using std::chrono::tai_clock;
+
+    using std::chrono::tai_seconds;
+    using std::chrono::tai_time;
+
+    // [time.clock.gps], class gps_clock
+    using std::chrono::gps_clock;
+
+    using std::chrono::gps_seconds;
+    using std::chrono::gps_time;
+#endif
+    // [time.clock.file], type file_clock
+    using std::chrono::file_clock;
+
+    using std::chrono::file_time;
+
+    // [time.clock.steady], class steady_clock
+    using std::chrono::steady_clock;
+
+    // [time.clock.hires], class high_resolution_clock
+    using std::chrono::high_resolution_clock;
+
+    // [time.clock.local], local time
+    using std::chrono::local_days;
+    using std::chrono::local_seconds;
+    using std::chrono::local_t;
+    using std::chrono::local_time;
+
+    // [time.clock.cast], time_point conversions
+    // using std::chrono::clock_time_conversion; NOT IMPLEMENTED YET
+
+    // using std::chrono::clock_cast; NOT IMPLEMENTED YET
+
+    // [time.cal.last], class last_spec
+    using std::chrono::last_spec;
+
+    // [time.cal.day], class day
+    using std::chrono::day;
+
+    // [time.cal.month], class month
+    using std::chrono::month;
+
+    // [time.cal.year], class year
+    using std::chrono::year;
+
+    // [time.cal.wd], class weekday
+    using std::chrono::weekday;
+
+    // [time.cal.wdidx], class weekday_indexed
+    using std::chrono::weekday_indexed;
+
+    // [time.cal.wdlast], class weekday_last
+    using std::chrono::weekday_last;
+
+    // [time.cal.md], class month_day
+    using std::chrono::month_day;
+
+    // [time.cal.mdlast], class month_day_last
+    using std::chrono::month_day_last;
+
+    // [time.cal.mwd], class month_weekday
+    using std::chrono::month_weekday;
+
+    // [time.cal.mwdlast], class month_weekday_last
+    using std::chrono::month_weekday_last;
+
+    // [time.cal.ym], class year_month
+    using std::chrono::year_month;
+
+    // [time.cal.ymd], class year_month_day
+    using std::chrono::year_month_day;
+
+    // [time.cal.ymdlast], class year_month_day_last
+    using std::chrono::year_month_day_last;
+
+    // [time.cal.ymwd], class year_month_weekday
+    using std::chrono::year_month_weekday;
+
+    // [time.cal.ymwdlast], class year_month_weekday_last
+    using std::chrono::year_month_weekday_last;
+
+    // [time.cal.operators], civil calendar conventional syntax operators
+
+    // [time.hms], class template hh_mm_ss
+    using std::chrono::hh_mm_ss;
+
+    // [time.12], 12/24 hour functions
+    using std::chrono::is_am;
+    using std::chrono::is_pm;
+    using std::chrono::make12;
+    using std::chrono::make24;
+
+#if 0
+    // [time.zone.db], time zone database
+    using std::chrono::tzdb;
+    using std::chrono::tzdb_list;
+
+    // [time.zone.db.access], time zone database access
+    using std::chrono::current_zone;
+    using std::chrono::get_tzdb;
+    using std::chrono::get_tzdb_list;
+    using std::chrono::locate_zone;
+
+    // [time.zone.db.remote], remote time zone database support
+    using std::chrono::reload_tzdb;
+    using std::chrono::remote_version;
+
+    // [time.zone.exception], exception classes
+    using std::chrono::ambiguous_local_time;
+    using std::chrono::nonexistent_local_time;
+
+    // [time.zone.info], information classes
+    using std::chrono::sys_info;
+
+    // [time.zone.timezone], class time_zone
+    using std::chrono::choose;
+    using std::chrono::time_zone;
+
+    // [time.zone.zonedtraits], class template zoned_traits
+    using std::chrono::zoned_traits;
+
+    // [time.zone.zonedtime], class template zoned_time
+    using std::chrono::zoned_time;
+
+    using std::chrono::zoned_seconds;
+
+    // [time.zone.leap], leap second support
+    using std::chrono::leap_second;
+
+    // [time.zone.link], class time_zone_link
+    using std::chrono::time_zone_link;
+
+    // [time.format], formatting
+    using std::chrono::local_time_format;
+#endif
+  } // namespace chrono
+
+  using std::formatter;
+
+  namespace chrono {
+    // using std::chrono::parse;NOT IMPLEMENTED YET
+
+    // calendrical constants
+    using std::chrono::last;
+
+    using std::chrono::Friday;
+    using std::chrono::Monday;
+    using std::chrono::Saturday;
+    using std::chrono::Sunday;
+    using std::chrono::Thursday;
+    using std::chrono::Tuesday;
+    using std::chrono::Wednesday;
+
+    using std::chrono::April;
+    using std::chrono::August;
+    using std::chrono::December;
+    using std::chrono::February;
+    using std::chrono::January;
+    using std::chrono::July;
+    using std::chrono::June;
+    using std::chrono::March;
+    using std::chrono::May;
+    using std::chrono::November;
+    using std::chrono::October;
+    using std::chrono::September;
+
+  } // namespace chrono
+
+} // namespace std
+export namespace std::inline literals::inline chrono_literals {
+  // [time.duration.literals], suffixes for duration literals
+  using std::literals::chrono_literals::operator""h;
+  using std::literals::chrono_literals::operator""min;
+  using std::literals::chrono_literals::operator""s;
+  using std::literals::chrono_literals::operator""ms;
+  using std::literals::chrono_literals::operator""us;
+  using std::literals::chrono_literals::operator""ns;
+
+  // [using std::literals::chrono_literals::.cal.day.nonmembers], non-member functions
+  using std::literals::chrono_literals::operator""d;
+
+  // [using std::literals::chrono_literals::.cal.year.nonmembers], non-member functions
+  using std::literals::chrono_literals::operator""y;
+} // namespace std::inline literals::inline chrono_literals
+
+export namespace std::chrono {
+  using namespace literals::chrono_literals;
+}

libcxx/stdmodules/std-compat-stddef.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <stddef.h>
+
+export module std.compat:stddef;
+export {
+  // validate the list against the proper C standard
+  using ::max_align_t;
+  using ::ptrdiff_t;
+  using ::size_t;
+
+//  using ::nullptr_t; // required?
+
+} // export

libcxx/stdmodules/std-compat.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export module std.compat;
+export import std;
+export import :stddef;
+

libcxx/stdmodules/std-concepts.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <concepts>
+
+export module std:concepts;
+export namespace std {
+
+  // [concepts.lang], language-related concepts
+  // [concept.same], concept same_as
+  using std::same_as;
+
+  // [concept.derived], concept derived_from
+  using std::derived_from;
+
+  // [concept.convertible], concept convertible_to
+  using std::convertible_to;
+
+  // [concept.commonref], concept common_reference_with
+  using std::common_reference_with;
+
+  // [concept.common], concept common_with
+  using std::common_with;
+
+  // [concepts.arithmetic], arithmetic concepts
+  using std::floating_point;
+  using std::integral;
+  using std::signed_integral;
+  using std::unsigned_integral;
+
+  // [concept.assignable], concept assignable_from
+  using std::assignable_from;
+
+  // [concept.swappable], concept swappable
+  namespace ranges {
+    inline namespace __cpo {
+      using std::ranges::__cpo::swap;
+    }
+  } // namespace ranges
+
+  using std::swappable;
+  using std::swappable_with;
+
+  // [concept.destructible], concept destructible
+  using std::destructible;
+
+  // [concept.constructible], concept constructible_from
+  using std::constructible_from;
+
+  // [concept.default.init], concept default_initializable
+  using std::default_initializable;
+
+  // [concept.moveconstructible], concept move_constructible
+  using std::move_constructible;
+
+  // [concept.copyconstructible], concept copy_constructible
+  using std::copy_constructible;
+
+  // [concepts.compare], comparison concepts
+  // [concept.equalitycomparable], concept equality_comparable
+  using std::equality_comparable;
+  using std::equality_comparable_with;
+
+  // [concept.totallyordered], concept totally_ordered
+  using std::totally_ordered;
+  using std::totally_ordered_with;
+
+  // [concepts.object], object concepts
+  using std::copyable;
+  using std::movable;
+  using std::regular;
+  using std::semiregular;
+
+  // [concepts.callable], callable concepts
+  // [concept.invocable], concept invocable
+  using std::invocable;
+
+  // [concept.regularinvocable], concept regular_invocable
+  using std::regular_invocable;
+
+  // [concept.predicate], concept predicate
+  using std::predicate;
+
+  // [concept.relation], concept relation
+  using std::relation;
+
+  // [concept.equiv], concept equivalence_relation
+  using std::equivalence_relation;
+
+  // [concept.strictweakorder], concept strict_weak_order
+  using std::strict_weak_order;
+
+} // namespace std

libcxx/stdmodules/std-coroutine.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <coroutine>
+#include <functional>
+export module std:coroutine;
+export namespace std {
+  using std::coroutine_handle;
+  using std::coroutine_traits;
+  using std::operator==;
+  using std::operator<=>;
+  using std::noop_coroutine;
+  using std::suspend_always;
+  using std::suspend_never;
+
+  using std::hash;
+} // namespace std

libcxx/stdmodules/std-cstddef.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <cstddef>
+
+export module std:cstddef;
+export namespace std {
+  using std::max_align_t;
+  using std::nullptr_t;
+  using std::ptrdiff_t;
+  using std::size_t;
+
+  using std::byte;
+
+  // [support.types.byteops], byte type operations
+  using std::operator<<=;
+  using std::operator<<;
+  using std::operator>>=;
+  using std::operator>>;
+  using std::operator|=;
+  using std::operator|;
+  using std::operator&=;
+  using std::operator&;
+  using std::operator^=;
+  using std::operator^;
+  using std::operator~;
+  using std::to_integer;
+} // namespace std

libcxx/stdmodules/std-cstdlib.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <cstdlib>
+
+export module std:cstdlib;
+export namespace std {
+
+  using std::div_t;
+  using std::ldiv_t;
+  using std::lldiv_t;
+  using std::size_t;
+
+  // [support.start.term], start and termination
+  using std::_Exit;
+  using std::abort;
+  using std::at_quick_exit;
+  using std::atexit;
+  using std::exit;
+  using std::quick_exit;
+
+  using std::getenv;
+  using std::system;
+
+  // [c.malloc], C library memory allocation
+  using std::aligned_alloc;
+  using std::calloc;
+  using std::free;
+  using std::malloc;
+  using std::realloc;
+
+  using std::atof;
+  using std::atoi;
+  using std::atol;
+  using std::atoll;
+  using std::strtod;
+  using std::strtof;
+  using std::strtol;
+  using std::strtold;
+  using std::strtoll;
+  using std::strtoul;
+  using std::strtoull;
+
+  // [c.mb.wcs], multibyte / wide string and character conversion functions
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::mblen;
+  using std::mbstowcs;
+  using std::mbtowc;
+  using std::wcstombs;
+  using std::wctomb;
+#endif
+  // [alg.c.library], C standard library algorithms
+  using std::bsearch;
+  using std::qsort;
+
+  // [c.math.rand], low-quality random number generation
+  using std::rand;
+  using std::srand;
+
+  // [c.math.abs], absolute values
+  using std::abs;
+
+  using std::labs;
+  using std::llabs;
+
+  using std::div;
+  using std::ldiv;
+  using std::lldiv;
+
+} // namespace std

libcxx/stdmodules/std-exception.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <exception>
+export module std:exception;
+export namespace std {
+  using std::bad_exception;
+  using std::current_exception;
+  using std::exception;
+  using std::exception_ptr;
+  using std::get_terminate;
+  using std::make_exception_ptr;
+  using std::nested_exception;
+  using std::rethrow_if_nested;
+  using std::set_terminate;
+  using std::terminate;
+  using std::throw_with_nested;
+  using std::uncaught_exception;
+} // namespace std

libcxx/stdmodules/std-expected.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <expected> // Since C++23
+
+export module std:expected;
+export namespace std {
+
+  // [expected.unexpected], class template unexpected
+  using std::unexpected;
+
+  // [expected.bad], class template bad_expected_access
+  using std::bad_expected_access;
+
+  // [expected.bad.void], specialization for void
+
+  // in-place construction of unexpected values
+  using std::unexpect_t;
+
+  using std::unexpect;
+
+  // [expected.expected], class template expected
+  using std::expected;
+
+  // [expected.void], partial specialization of expected for void types
+
+} // namespace std

libcxx/stdmodules/std-format.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// TODO This file is two-fold
+// - look at how we want to integrate a synopsis
+// - test whether the experimental library works properly
+
+module;
+#include <format> // Since C++20
+
+export module std:format;
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+export namespace std {
+
+  // [format.context], class template basic_format_context
+  // template <class Out, class charT>
+  // class basic_format_context;
+  using std::basic_format_context;
+  /*
+    template<class Out, class charT>
+    class basic_format_context {
+      basic_format_args<basic_format_context> args_;      // exposition only
+      Out out_;                                           // exposition only
+
+    public:
+      using iterator = Out;
+      using char_type = charT;
+      template<class T> using formatter_type = formatter<T, charT>;
+
+      basic_format_arg<basic_format_context> arg(size_t id) const noexcept;
+      std::locale locale();
+
+      iterator out();
+      void advance_to(iterator it);
+    };
+  */
+  // using format_context  = basic_format_context<unspecified, char>;
+  // using wformat_context = basic_format_context<unspecified, wchar_t>;
+  using std::format_context;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_context;
+#  endif
+
+  // [format.args], class template basic_format_args
+  // template <class Context>
+  // class basic_format_args;
+  using std::basic_format_args;
+  /*
+    template<class Context>
+    class basic_format_args {
+      size_t size_;                               // exposition only
+      const basic_format_arg<Context>* data_;     // exposition only
+
+    public:
+      basic_format_args() noexcept;
+
+      template<class... Args>
+        basic_format_args(const format-arg-store<Context, Args...>& store) noexcept;
+
+      basic_format_arg<Context> get(size_t i) const noexcept;
+    };
+  */
+  // using format_args  = basic_format_args<format_context>;
+  // using wformat_args = basic_format_args<wformat_context>;
+  using std::format_args;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_args;
+#  endif
+
+  // [format.fmt.string], class template basic_format_string
+  // template <class charT, class... Args>
+  // struct basic_format_string;
+  using std::basic_format_string;
+
+  // template <class... Args>
+  // using format_string = basic_format_string<char, type_identity_t<Args>...>;
+  // template <class... Args>
+  // using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+  using std::format_string;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_string;
+#  endif
+
+  // [format.functions], formatting functions
+  // template <class... Args>
+  // string format(format_string<Args...> fmt, Args&&... args);
+  // template <class... Args>
+  // wstring format(wformat_string<Args...> fmt, Args&&... args);
+  // template <class... Args>
+  // string format(const locale& loc, format_string<Args...> fmt, Args&&... args);
+  // template <class... Args>
+  // wstring format(const locale& loc, wformat_string<Args...> fmt, Args&&... args);
+  using std::format;
+
+  // string vformat(string_view fmt, format_args args);
+  // wstring vformat(wstring_view fmt, wformat_args args);
+  // string vformat(const locale& loc, string_view fmt, format_args args);
+  // wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
+  using std::vformat;
+
+  // template <class Out, class... Args>
+  // Out format_to(Out out, format_string<Args...> fmt, Args&&... args);
+  // template <class Out, class... Args>
+  // Out format_to(Out out, wformat_string<Args...> fmt, Args&&... args);
+  // template <class Out, class... Args>
+  // Out format_to(Out out, const locale& loc, format_string<Args...> fmt, Args&&... args);
+  // template <class Out, class... Args>
+  // Out format_to(Out out, const locale& loc, wformat_string<Args...> fmt, Args&&... args);
+  using std::format_to;
+
+  // template <class Out>
+  // Out vformat_to(Out out, string_view fmt, format_args args);
+  // template <class Out>
+  // Out vformat_to(Out out, wstring_view fmt, wformat_args args);
+  // template <class Out>
+  // Out vformat_to(Out out, const locale& loc, string_view fmt, format_args args);
+  // template <class Out>
+  // Out vformat_to(Out out, const locale& loc, wstring_view fmt, wformat_args args);
+  using std::vformat_to;
+
+  // template <class Out>
+  // struct format_to_n_result {
+  //   Out out;
+  //   iter_difference_t<Out> size;
+  // };
+  using std::format_to_n_result;
+  // template <class Out, class... Args>
+  // format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, format_string<Args...> fmt, Args&&... args);
+  // template <class Out, class... Args>
+  // format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, wformat_string<Args...> fmt, Args&&...
+  // args); template <class Out, class... Args> format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+  // const locale& loc, format_string<Args...> fmt, Args&&... args); template <class Out, class... Args>
+  // format_to_n_result<Out>
+  // format_to_n(Out out, iter_difference_t<Out> n, const locale& loc, wformat_string<Args...> fmt, Args&&... args);
+  using std::format_to_n;
+
+  // template <class... Args>
+  // size_t formatted_size(format_string<Args...> fmt, Args&&... args);
+  // template <class... Args>
+  // size_t formatted_size(wformat_string<Args...> fmt, Args&&... args);
+  // template <class... Args>
+  // size_t formatted_size(const locale& loc, format_string<Args...> fmt, Args&&... args);
+  // template <class... Args>
+  // size_t formatted_size(const locale& loc, wformat_string<Args...> fmt, Args&&... args);
+  using std::formatted_size;
+
+  // [format.formatter], formatter
+  // template <class T, class charT = char>
+  // struct formatter;
+  using std::formatter;
+
+  // [format.formattable], concept formattable
+  // template <class T, class charT>
+  // concept formattable = see below; // Since C++23
+  using std::formattable;
+
+  // template <class R, class charT>
+  //     concept const-formattable-range = // exposition only
+  //     ranges::input_range<const R> && formattable<ranges::range_reference_t<const R>, charT>;
+
+  // template <class R, class charT>
+  //     using fmt-maybe-const = // exposition only
+  //     conditional_t<const-formattable-range<R, charT>, const R, R>;
+
+  // [format.parse.ctx], class template basic_format_parse_context
+  // template <class charT>a
+  // class basic_format_parse_context;
+  using std::basic_format_parse_context;
+
+  /*
+    template<class charT>
+    class basic_format_parse_context {
+    public:
+      using char_type = charT;
+      using const_iterator = typename basic_string_view<charT>::const_iterator;
+      using iterator = const_iterator;
+
+    private:
+      iterator begin_;                                    // exposition only
+      iterator end_;                                      // exposition only
+      enum indexing { unknown, manual, automatic };       // exposition only
+      indexing indexing_;                                 // exposition only
+      size_t next_arg_id_;                                // exposition only
+      size_t num_args_;                                   // exposition only
+
+    public:
+      constexpr explicit basic_format_parse_context(basic_string_view<charT> fmt,
+                                                    size_t num_args = 0) noexcept;
+      basic_format_parse_context(const basic_format_parse_context&) = delete;
+      basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;
+
+      constexpr const_iterator begin() const noexcept;
+      constexpr const_iterator end() const noexcept;
+      constexpr void advance_to(const_iterator it);
+
+      constexpr size_t next_arg_id();
+      constexpr void check_arg_id(size_t id);
+    };
+  */
+
+  // using format_parse_context  = basic_format_parse_context<char>;
+  // using wformat_parse_context = basic_format_parse_context<wchar_t>;
+  using std::format_parse_context;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_parse_context;
+#  endif
+
+  // [format.range], formatting of ranges
+  // [format.range.fmtkind], variable template format_kind
+  // enum class range_format { disabled, map, set, sequence, string, debug_string }; // Since C++23
+  using std::range_format;
+
+  // template <class R>
+  // constexpr unspecified format_kind = unspecified;
+  using std::format_kind;
+
+  // template <ranges::input_range R>
+  //   requires same_as<R, remove_cvref_t<R>>
+  // constexpr range_format format_kind<R> = see below;
+  using std::format_kind;
+
+  // [format.range.formatter], class template range_formatter
+  // template <class T, class charT = char>
+  //  requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
+  // class range_formatter;
+  using std::range_formatter;
+
+  /*
+    template<class T, class charT = char>
+      requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
+    class range_formatter {
+      formatter<T, charT> underlying_;                                          // exposition only
+      basic_string_view<charT> separator_ = STATICALLY-WIDEN<charT>(", ");      // exposition only
+      basic_string_view<charT> opening-bracket_ = STATICALLY-WIDEN<charT>("["); // exposition only
+      basic_string_view<charT> closing-bracket_ = STATICALLY-WIDEN<charT>("]"); // exposition only
+
+    public:
+      constexpr void set_separator(basic_string_view<charT> sep);
+      constexpr void set_brackets(basic_string_view<charT> opening,
+                                  basic_string_view<charT> closing);
+      constexpr formatter<T, charT>& underlying() { return underlying_; }
+      constexpr const formatter<T, charT>& underlying() const { return underlying_; }
+
+      template<class ParseContext>
+        constexpr typename ParseContext::iterator
+          parse(ParseContext& ctx);
+
+      template<ranges::input_range R, class FormatContext>
+          requires formattable<ranges::range_reference_t<R>, charT> &&
+                   same_as<remove_cvref_t<ranges::range_reference_t<R>>, T>
+        typename FormatContext::iterator
+          format(R&& r, FormatContext& ctx) const;
+    };
+  */
+
+  // [format.range.fmtdef], class template range-default-formatter
+  // template <range_format K, ranges::input_range R, class charT>
+  //    struct range-default-formatter; // exposition only
+  /*
+    template<ranges::input_range R, class charT>
+    struct range-default-formatter<range_format::sequence, R, charT> {    // exposition only
+    private:
+      using maybe-const-r = fmt-maybe-const<R, charT>;                    // exposition only
+      range_formatter<remove_cvref_t<ranges::range_reference_t<maybe-const-r>>,
+                      charT> underlying_;                                 // exposition only
+
+    public:
+      constexpr void set_separator(basic_string_view<charT> sep);
+      constexpr void set_brackets(basic_string_view<charT> opening,
+                                  basic_string_view<charT> closing);
+
+      template<class ParseContext>
+        constexpr typename ParseContext::iterator
+          parse(ParseContext& ctx);
+
+      template<class FormatContext>
+        typename FormatContext::iterator
+          format(maybe-const-r& elems, FormatContext& ctx) const;
+    };
+  */
+
+  // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr], specializations for maps, sets, and strings
+  /*
+    template<ranges::input_range R, class charT>                         // Since C++23
+    struct range-default-formatter<range_format::map, R, charT> {
+    private:
+      using maybe-const-map = fmt-maybe-const<R, charT>;                  // exposition only
+      using element-type =                                                // exposition only
+        remove_cvref_t<ranges::range_reference_t<maybe-const-map>>;
+      range_formatter<element-type, charT> underlying_;                   // exposition only
+
+    public:
+      constexpr range-default-formatter();
+
+      template<class ParseContext>
+        constexpr typename ParseContext::iterator
+          parse(ParseContext& ctx);
+
+      template<class FormatContext>
+        typename FormatContext::iterator
+          format(maybe-const-map& r, FormatContext& ctx) const;
+    };
+
+    template<ranges::input_range R, class charT>
+    struct range-default-formatter<range_format::set, R, charT> {         // Since C++23
+    private:
+      using maybe-const-set = fmt-maybe-const<R, charT>;                  // exposition only
+      range_formatter<remove_cvref_t<ranges::range_reference_t<maybe-const-set>>,
+                      charT> underlying_;                                 // exposition only
+
+    public:
+      constexpr range-default-formatter();
+
+      template<class ParseContext>
+        constexpr typename ParseContext::iterator
+          parse(ParseContext& ctx);
+
+      template<class FormatContext>
+        typename FormatContext::iterator
+          format(maybe-const-set& r, FormatContext& ctx) const;
+    };
+
+    template<range_format K, ranges::input_range R, class charT>
+      requires (K == range_format::string || K == range_format::debug_string)
+    struct range-default-formatter<K, R, charT> {                         // Since C++23
+    private:
+      formatter<basic_string<charT>, charT> underlying_;                  // exposition only
+
+    public:
+      template<class ParseContext>
+        constexpr typename ParseContext::iterator
+          parse(ParseContext& ctx);
+
+      template<class FormatContext>
+        typename FormatContext::iterator
+          format(see below& str, FormatContext& ctx) const;
+    };
+  */
+  // template <ranges::input_range R, class charT>
+  //   requires(format_kind<R> != range_format::disabled) &&
+  //           formattable<ranges::range_reference_t<R>, charT>
+  //           struct formatter<R, charT> : range-default-formatter<format_kind<R>, R, charT> {};
+
+  // [format.arguments], arguments
+  // [format.arg], class template basic_format_arg
+  // template <class Context>
+  // class basic_format_arg;
+  using std::basic_format_arg;
+
+  /*
+    template<class Context>
+    class basic_format_arg {
+    public:
+      class handle;
+
+    private:
+      using char_type = typename Context::char_type;                              // exposition only
+
+      variant<monostate, bool, char_type,
+              int, unsigned int, long long int, unsigned long long int,
+              float, double, long double,
+              const char_type*, basic_string_view<char_type>,
+              const void*, handle> value;                                         // exposition only
+
+      template<class T> explicit basic_format_arg(T&& v) noexcept;                // exposition only
+      explicit basic_format_arg(float n) noexcept;                                // exposition only
+      explicit basic_format_arg(double n) noexcept;                               // exposition only
+      explicit basic_format_arg(long double n) noexcept;                          // exposition only
+      explicit basic_format_arg(const char_type* s);                              // exposition only
+
+      template<class traits>
+        explicit basic_format_arg(
+          basic_string_view<char_type, traits> s) noexcept;                       // exposition only
+
+      template<class traits, class Allocator>
+        explicit basic_format_arg(
+          const basic_string<char_type, traits, Allocator>& s) noexcept;          // exposition only
+
+      explicit basic_format_arg(nullptr_t) noexcept;                              // exposition only
+
+      template<class T>
+        explicit basic_format_arg(T* p) noexcept;                                 // exposition only
+
+    public:
+      basic_format_arg() noexcept;
+
+      explicit operator bool() const noexcept;
+    };
+
+    template<class Context>
+    class basic_format_arg<Context>::handle {
+      const void* ptr_;                                           // exposition only
+      void (*format_)(basic_format_parse_context<char_type>&,
+                      Context&, const void*);                     // exposition only
+
+      template<class T> explicit handle(T&& val) noexcept;        // exposition only
+
+      friend class basic_format_arg<Context>;                     // exposition only
+
+    public:
+      void format(basic_format_parse_context<char_type>&, Context& ctx) const;
+    };
+  */
+
+  // template <class Visitor, class Context>
+  // decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
+  using std::visit_format_arg;
+
+  // [format.arg.store], class template format-arg-store
+  // template <class Context, class... Args>
+  //    class format-arg-store; // exposition only
+  /*
+    template<class Context, class... Args>
+    class format-arg-store {                                      // exposition only
+      array<basic_format_arg<Context>, sizeof...(Args)> args;     // exposition only
+    };
+  */
+
+  // template <class Context = format_context, class... Args>
+  //     format-arg-store<Context, Args...> make_format_args(Args&&... fmt_args);
+  // template <class... Args>
+  //     format-arg-store<wformat_context, Args...> make_wformat_args(Args&&... args);
+  using std::make_format_args;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::make_wformat_args;
+#  endif
+
+  // [format.error], class format_error
+  // class format_error;
+  using std::format_error;
+  /*
+    class format_error : public runtime_error {
+    public:
+      explicit format_error(const string& what_arg);
+      explicit format_error(const char* what_arg);
+    };
+  */
+
+  /*
+    template<class charT, formattable<charT>... Ts>
+    struct formatter<pair-or-tuple<Ts...>, charT> {                             // Since C++23
+    private:
+      tuple<formatter<remove_cvref_t<Ts>, charT>...> underlying_;               // exposition only
+      basic_string_view<charT> separator_ = STATICALLY-WIDEN<charT>(", ");      // exposition only
+      basic_string_view<charT> opening-bracket_ = STATICALLY-WIDEN<charT>("("); // exposition only
+      basic_string_view<charT> closing-bracket_ = STATICALLY-WIDEN<charT>(")"); // exposition only
+
+    public:
+      constexpr void set_separator(basic_string_view<charT> sep);
+      constexpr void set_brackets(basic_string_view<charT> opening,
+                                  basic_string_view<charT> closing);
+
+      template<class ParseContext>
+        constexpr typename ParseContext::iterator
+          parse(ParseContext& ctx);
+
+      template<class FormatContext>
+        typename FormatContext::iterator
+          format(see below& elems, FormatContext& ctx) const;
+    };
+  */
+} // namespace std
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)

libcxx/stdmodules/std-fstream.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <fstream>
+
+export module std:fstream;
+export namespace std {
+
+  using std::basic_filebuf;
+
+  using std::swap;
+
+  using std::filebuf;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wfilebuf;
+#endif
+
+  using std::basic_ifstream;
+
+  using std::ifstream;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wifstream;
+#endif
+
+  using std::basic_ofstream;
+
+  using std::ofstream;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wofstream;
+#endif
+
+  using std::basic_fstream;
+
+  using std::fstream;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wfstream;
+#endif
+} // namespace std

libcxx/stdmodules/std-functional.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <functional>
+
+export module std:functional;
+export namespace std {
+  // [func.invoke], invoke
+  using std::invoke_r;
+  using std::invoke_result_t;
+
+  // [refwrap], reference_wrapper
+  using std::reference_wrapper;
+
+  using std::cref;
+  using std::ref;
+
+  // [arithmetic.operations], arithmetic operations
+  using std::divides;
+  using std::minus;
+  using std::modulus;
+  using std::multiplies;
+  using std::negate;
+  using std::plus;
+  // [comparisons], comparisons
+  using std::equal_to;
+  using std::greater;
+  using std::greater_equal;
+  using std::less;
+  using std::less_equal;
+  using std::not_equal_to;
+
+  // [comparisons.three.way], class compare_three_way
+  using std::compare_three_way;
+
+  // [logical.operations], logical operations
+  using std::logical_and;
+  using std::logical_not;
+  using std::logical_or;
+
+  // [bitwise.operations], bitwise operations
+  using std::bit_and;
+  using std::bit_not;
+  using std::bit_or;
+  using std::bit_xor;
+
+  // [func.identity], identity
+  using std::identity;
+
+  // [func.not.fn], function template not_fn
+  using std::not_fn;
+
+  // [func.bind.partial], function templates bind_front and bind_back
+  // using std::bind_back; not implemented
+  using std::bind_front;
+
+  // [func.bind], bind
+  using std::is_bind_expression;
+  using std::is_bind_expression_v;
+  using std::is_placeholder;
+  using std::is_placeholder_v;
+
+  using std::bind;
+
+  // Blocked by D143797
+#if 0
+  namespace placeholders {
+    // M is the implementation-defined number of placeholders
+    using std::placeholders::_1;
+    using std::placeholders::_10;
+    using std::placeholders::_2;
+    using std::placeholders::_3;
+    using std::placeholders::_4;
+    using std::placeholders::_5;
+    using std::placeholders::_6;
+    using std::placeholders::_7;
+    using std::placeholders::_8;
+    using std::placeholders::_9;
+  } // namespace placeholders
+#endif
+  // [func.memfn], member function adaptors
+  using std::mem_fn;
+
+  // [func.wrap], polymorphic function wrappers
+  using std::bad_function_call;
+
+  using std::function;
+
+  using std::swap;
+
+  using std::operator==;
+
+  // [func.wrap.move], move only wrapper
+  // using std::move_only_function; not implemented
+
+  // [func.search], searchers
+  using std::default_searcher;
+
+  using std::boyer_moore_searcher;
+
+  using std::boyer_moore_horspool_searcher;
+
+  // [unord.hash], class template hash
+  using std::hash;
+
+  namespace ranges {
+    // [range.cmp], concept-constrained comparisons
+    using std::ranges::equal_to;
+    using std::ranges::greater;
+    using std::ranges::greater_equal;
+    using std::ranges::less;
+    using std::ranges::less_equal;
+    using std::ranges::not_equal_to;
+  } // namespace ranges
+
+} // namespace std

libcxx/stdmodules/std-initializer_list.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <initializer_list>
+
+export module std:initializer_list;
+export namespace std {
+  using std::initializer_list;
+
+  // [support.initlist.range], initializer list range access
+  using std::begin;
+  using std::end;
+} // namespace std

libcxx/stdmodules/std-iostream.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <iostream>
+
+export module std:iostream;
+export namespace std {
+
+  using std::cerr;
+  using std::cin;
+  using std::clog;
+  using std::cout;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wcerr;
+  using std::wcin;
+  using std::wclog;
+  using std::wcout;
+#endif
+
+} // namespace std

libcxx/stdmodules/std-iterator.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <iterator>
+
+export module std:iterator;
+export namespace std {
+
+  // [iterator.assoc.types], associated types
+  // [incrementable.traits], incrementable traits
+  using std::incrementable_traits;
+  using std::iter_difference_t;
+
+  using std::indirectly_readable_traits;
+  using std::iter_value_t;
+
+  // [iterator.traits], iterator traits
+  using std::iterator_traits;
+
+  using std::iter_reference_t;
+
+#if 0 // TODO INVESTIGATE
+  namespace ranges {
+    // [iterator.cust], customization point objects
+    inline namespace unspecified {
+      // [iterator.cust.move], ranges!::!iter_move
+      inline constexpr unspecified iter_move = unspecified;                    
+
+      // [iterator.cust.swap], ranges!::!iter_swap
+      inline constexpr unspecified iter_swap = unspecified;                     
+    }
+  }
+#endif
+
+  using std::iter_rvalue_reference_t;
+
+  // [iterator.concepts], iterator concepts
+  // [iterator.concept.readable], concept indirectly_readable
+  using std::indirectly_readable;
+
+  using std::iter_common_reference_t;
+
+  // [iterator.concept.writable], concept indirectly_writable
+  using std::indirectly_writable;
+
+  // [iterator.concept.winc], concept weakly_incrementable
+  using std::weakly_incrementable;
+
+  // [iterator.concept.inc], concept incrementable
+  using std::incrementable;
+
+  // [iterator.concept.iterator], concept input_or_output_iterator
+  using std::input_or_output_iterator;
+
+  // [iterator.concept.sentinel], concept sentinel_for
+  using std::sentinel_for;
+
+  // [iterator.concept.sizedsentinel], concept sized_sentinel_for
+  using std::disable_sized_sentinel_for;
+
+  using std::sized_sentinel_for;
+
+  // [iterator.concept.input], concept input_iterator
+  using std::input_iterator;
+
+  // [iterator.concept.output], concept output_iterator
+  using std::output_iterator;
+
+  // [iterator.concept.forward], concept forward_iterator
+  using std::forward_iterator;
+
+  // [iterator.concept.bidir], concept bidirectional_iterator
+  using std::bidirectional_iterator;
+
+  // [iterator.concept.random.access], concept random_access_iterator
+  using std::random_access_iterator;
+
+  // [iterator.concept.contiguous], concept contiguous_iterator
+  using std::contiguous_iterator;
+
+  // [indirectcallable], indirect callable requirements
+  // [indirectcallable.indirectinvocable], indirect callables
+  using std::indirectly_unary_invocable;
+
+  using std::indirectly_regular_unary_invocable;
+
+  using std::indirect_unary_predicate;
+
+  using std::indirect_binary_predicate;
+
+  using std::indirect_equivalence_relation;
+
+  using std::indirect_strict_weak_order;
+
+  using std::indirect_result_t;
+
+  // [projected], projected
+  using std::projected;
+
+  using std::incrementable_traits;
+
+  // [alg.req], common algorithm requirements
+  // [alg.req.ind.move], concept indirectly_movable
+  using std::indirectly_movable;
+
+  using std::indirectly_movable_storable;
+
+  // [alg.req.ind.copy], concept indirectly_copyable
+  using std::indirectly_copyable;
+
+  using std::indirectly_copyable_storable;
+
+  // [alg.req.ind.swap], concept indirectly_swappable
+  using std::indirectly_swappable;
+
+  // [alg.req.ind.cmp], concept indirectly_comparable
+  using std::indirectly_comparable;
+
+  // [alg.req.permutable], concept permutable
+  using std::permutable;
+
+  // [alg.req.mergeable], concept mergeable
+  using std::mergeable;
+
+  // [alg.req.sortable], concept sortable
+  using std::sortable;
+
+  // [iterator.primitives], primitives
+  // [std.iterator.tags], iterator tags
+  using std::bidirectional_iterator_tag;
+  using std::contiguous_iterator_tag;
+  using std::forward_iterator_tag;
+  using std::input_iterator_tag;
+  using std::output_iterator_tag;
+  using std::random_access_iterator_tag;
+
+  // [iterator.operations], iterator operations
+  using std::advance;
+  using std::distance;
+  using std::next;
+  using std::prev;
+
+  // [range.iter.ops], range iterator operations
+  namespace ranges {
+    // [range.iter.op.advance], ranges!::!advance
+    using std::ranges::advance;
+
+    // [range.iter.op.distance], ranges!::!distance
+    using std::ranges::distance;
+
+    // [range.iter.op.next], ranges!::!next
+    using std::ranges::next;
+
+    // [range.iter.op.prev], ranges!::!prev
+    using std::ranges::prev;
+  } // namespace ranges
+
+  // [predef.iterators], predefined iterators and sentinels
+  // [reverse.iterators], reverse iterators
+  using std::reverse_iterator;
+
+  using std::operator==;
+  using std::operator!=;
+  using std::operator<;
+  using std::operator>;
+  using std::operator<=;
+  using std::operator>=;
+  using std::operator<=>;
+
+  using std::operator-;
+  using std::operator+;
+
+  using std::make_reverse_iterator;
+
+  using std::disable_sized_sentinel_for;
+
+  // [insert.iterators], insert iterators
+  using std::back_insert_iterator;
+  using std::back_inserter;
+
+  using std::front_insert_iterator;
+  using std::front_inserter;
+
+  using std::insert_iterator;
+  using std::inserter;
+
+  // [const.iterators], constant iterators and sentinels
+  // [const.iterators.alias], alias templates
+  //  using std::const_iterator; NOT IMPLEMENTED
+  //  using std::const_sentinel; NOT IMPLEMENTED
+  //  using std::iter_const_reference_t; NOT IMPLEMENTED?
+
+  // [const.iterators.iterator], class template basic_const_iterator
+  //  using std::basic_const_iterator; NOT IMPLEMENTED
+
+  using std::common_type;
+
+  //  using std::make_const_iterator; NOT IMPLEMENTED
+
+  // [move.iterators], move iterators and sentinels
+  using std::move_iterator; // freestanding
+
+  using std::make_move_iterator;
+
+  using std::move_sentinel;
+
+  using std::common_iterator;
+
+  using std::incrementable_traits;
+
+  // [default.sentinel], default sentinel
+  using std::default_sentinel;
+  using std::default_sentinel_t;
+
+  // [iterators.counted], counted iterators
+  using std::counted_iterator;
+
+  // [unreachable.sentinel], unreachable sentinel
+  using std::unreachable_sentinel;
+  using std::unreachable_sentinel_t;
+
+  // [stream.iterators], stream iterators
+  using std::istream_iterator;
+
+  using std::ostream_iterator;
+
+  using std::istreambuf_iterator;
+  using std::ostreambuf_iterator;
+
+  // [iterator.range], range access
+  using std::begin;
+  using std::cbegin;
+  using std::cend;
+  using std::crbegin;
+  using std::crend;
+  using std::end;
+  using std::rbegin;
+  using std::rend;
+
+  using std::empty;
+  using std::size;
+  using std::ssize;
+
+  using std::data;
+
+} // namespace std

libcxx/stdmodules/std-memory.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <memory>
+
+export module std:memory;
+export namespace std {
+  // [pointer.traits], pointer traits
+  using std::pointer_traits;
+
+  // [pointer.conversion], pointer conversion
+  using std::to_address;
+
+  // [ptr.align], pointer alignment
+  using std::align;
+  using std::assume_aligned;
+
+  // [obj.lifetime], explicit lifetime management
+  //  using std::start_lifetime_as; NOT IMPLEMENTED
+  //  using std::start_lifetime_as_array NOT IMPLEMENTED;
+
+  // [allocator.tag], allocator argument tag
+  //  using std::allocator_arg; TODO INTERNAL LINKAGE
+  //  using std::allocator_arg_t TODO INTERNAL LINKAGE;
+
+  // [allocator.uses], uses_allocator
+  using std::uses_allocator;
+
+  // [allocator.uses.trait], uses_allocator
+  using std::uses_allocator_v;
+
+  // [allocator.uses.construction], uses-allocator construction
+  using std::uses_allocator_construction_args;
+
+  using std::make_obj_using_allocator;
+  using std::uninitialized_construct_using_allocator;
+
+  // [allocator.traits], allocator traits
+  using std::allocator_traits; // freestanding
+
+  using std::allocation_result;
+
+  using std::allocate_at_least;
+
+  // [default.allocator], the default allocator
+  using std::allocator;
+  using std::operator==;
+
+  // [specialized.addressof], addressof
+  using std::addressof;
+
+  // [specialized.algorithms], specialized algorithms
+  // [special.mem.concepts], special memory concepts
+
+  using std::uninitialized_default_construct;
+  using std::uninitialized_default_construct_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_default_construct;
+    using std::ranges::uninitialized_default_construct_n;
+  } // namespace ranges
+
+  using std::uninitialized_value_construct;
+  using std::uninitialized_value_construct_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_value_construct;
+    using std::ranges::uninitialized_value_construct_n;
+  } // namespace ranges
+
+  using std::uninitialized_copy;
+  using std::uninitialized_copy_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_copy;
+    using std::ranges::uninitialized_copy_result;
+
+    using std::ranges::uninitialized_copy_n;
+    using std::ranges::uninitialized_copy_n_result;
+
+  } // namespace ranges
+  using std::uninitialized_move;
+  using std::uninitialized_move_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_move;
+    using std::ranges::uninitialized_move_result;
+
+    using std::ranges::uninitialized_move_n;
+    using std::ranges::uninitialized_move_n_result;
+
+  } // namespace ranges
+
+  using std::uninitialized_fill;
+  using std::uninitialized_fill_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_fill;
+    using std::ranges::uninitialized_fill_n;
+  } // namespace ranges
+
+  // [specialized.construct], construct_at
+  using std::construct_at;
+
+  namespace ranges {
+    using std::ranges::construct_at;
+  }
+  // [specialized.destroy], destroy
+  using std::destroy;
+  using std::destroy_at;
+  using std::destroy_n;
+
+  namespace ranges {
+    using std::ranges::destroy;
+    using std::ranges::destroy_at;
+    using std::ranges::destroy_n;
+  } // namespace ranges
+    // [unique.ptr], class template unique_ptr
+  using std::default_delete;
+  using std::unique_ptr;
+
+  using std::make_unique;
+  using std::make_unique_for_overwrite;
+
+  using std::swap;
+
+  using std::operator!=;
+  using std::operator<;
+  using std::operator>;
+  using std::operator<=;
+  using std::operator>=;
+  using std::operator<=>;
+
+  using std::operator<<;
+
+  // [util.smartptr.weak.bad], class bad_weak_ptr
+  using std::bad_weak_ptr;
+
+  // [util.smartptr.shared], class template shared_ptr
+  using std::shared_ptr;
+
+  // [util.smartptr.shared.create], shared_ptr creation
+  using std::allocate_shared;
+  using std::make_shared;
+
+  using std::make_shared_for_overwrite;
+
+  // [util.smartptr.shared.spec], shared_ptr specialized algorithms
+  using std::swap;
+
+  // [util.smartptr.shared.cast], shared_ptr casts
+  using std::const_pointer_cast;
+  using std::dynamic_pointer_cast;
+  using std::reinterpret_pointer_cast;
+  using std::static_pointer_cast;
+
+  using std::get_deleter;
+
+  // [util.smartptr.shared.io], shared_ptr I/O
+
+  // [util.smartptr.weak], class template weak_ptr
+  using std::weak_ptr;
+
+  // [util.smartptr.weak.spec], weak_ptr specialized algorithms
+
+  // [util.smartptr.ownerless], class template owner_less
+  using std::owner_less;
+
+  // [util.smartptr.enab], class template enable_shared_from_this
+  using std::enable_shared_from_this;
+
+  // [util.smartptr.hash], hash support
+  using std::hash;
+
+  // [util.smartptr.atomic], atomic smart pointers
+  using std::atomic;
+
+  // [out.ptr.t], class template out_ptr_t
+  //  using std::out_ptr_t NOT IMPLEMENTED;
+
+  // [out.ptr], function template out_ptr
+  //  using std::out_ptr NOT IMPLEMENTED;
+
+  // [inout.ptr.t], class template inout_ptr_t
+  //  using std::inout_ptr_t NOT IMPLEMENTED;
+
+  // [inout.ptr], function template inout_ptr
+  //  using std::inout_ptr NOT IMPLEMENTED;
+
+} // namespace std

libcxx/stdmodules/std-numeric.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <numeric>
+
+export module std:numeric;
+export namespace std {
+
+  // [accumulate], accumulate
+  using std::accumulate;
+
+  // [reduce], reduce
+  using std::reduce;
+
+  // [inner.product], inner product
+  using std::inner_product;
+
+  // [transform.reduce], transform reduce
+  using std::transform_reduce;
+
+  // [partial.sum], partial sum
+  using std::partial_sum;
+
+  // [exclusive.scan], exclusive scan
+  using std::exclusive_scan;
+
+  // [inclusive.scan], inclusive scan
+  using std::inclusive_scan;
+
+  // [transform.exclusive.scan], transform exclusive scan
+  using std::transform_exclusive_scan;
+
+  // [adjacent.difference], adjacent difference
+  using std::adjacent_difference;
+
+  // [numeric.iota], iota
+  using std::iota;
+
+  namespace ranges {
+    // using std::ranges::iota_result; NOT YET IMPLEMENTED
+    // using std::ranges::iota;  NOT YET IMPLEMENTED
+  } // namespace ranges
+
+  // [numeric.ops.gcd], greatest common divisor
+  using std::gcd;
+
+  // [numeric.ops.lcm], least common multiple
+  using std::lcm;
+
+  // [numeric.ops.midpoint], midpoint
+  using std::midpoint;
+
+} // namespace std

libcxx/stdmodules/std-optional.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <optional>
+
+export module std:optional;
+export namespace std {
+
+  // [optional.optional], class template optional
+  using std::optional;
+
+  // [optional.nullopt], no-value state indicator
+  using std::nullopt;
+  using std::nullopt_t;
+
+  // [optional.bad.access], class bad_optional_access
+  using std::bad_optional_access;
+
+  // [optional.relops], relational operators
+  using std::operator==;
+  using std::operator!=;
+  using std::operator<;
+  using std::operator>;
+  using std::operator<=;
+  using std::operator>=;
+  using std::operator<=>;
+
+  // [optional.nullops], comparison with nullopt
+
+  // [optional.comp.with.t], comparison with T
+
+  // [optional.specalg], specialized algorithms
+  using std::swap;
+
+  using std::make_optional;
+
+  // [optional.hash], hash support
+  using std::hash;
+
+} // namespace std

libcxx/stdmodules/std-span.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <span>
+
+export module std:span;
+export namespace std {
+
+  // constants
+  using std::dynamic_extent;
+
+  // [views.span], class template span
+  using std::span;
+
+  using std::ranges::enable_borrowed_range;
+  using std::ranges::enable_view;
+
+  // [span.objectrep], views of object representation
+  using std::as_bytes;
+
+  using std::as_writable_bytes;
+
+} // namespace std

libcxx/stdmodules/std-string.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <string>
+
+export module std:string;
+export namespace std {
+
+  // [char.traits], character traits
+  using std::char_traits;
+
+  // [basic.string], basic_string
+  using std::basic_string;
+
+  using std::operator+;
+  using std::operator==;
+  using std::operator<=>;
+
+  // [string.special], swap
+  using std::swap;
+
+  // [string.io], inserters and extractors
+  using std::operator>>;
+  using std::operator<<;
+  using std::getline;
+
+  // [string.erasure], erasure
+  using std::erase;
+  using std::erase_if;
+
+  // basic_string typedef-names
+  using std::string;
+  using std::u16string;
+  using std::u32string;
+  using std::u8string;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstring;
+#endif
+
+  // [string.conversions], numeric conversions
+  using std::stod;
+  using std::stof;
+  using std::stoi;
+  using std::stol;
+  using std::stold;
+  using std::stoll;
+  using std::stoul;
+  using std::stoull;
+  using std::to_string;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::to_wstring;
+#endif
+
+  namespace pmr {
+    using std::pmr::basic_string;
+    using std::pmr::string;
+    using std::pmr::u16string;
+    using std::pmr::u32string;
+    using std::pmr::u8string;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    using std::pmr::wstring;
+#endif
+
+  } // namespace pmr
+
+  // [basic.string.hash], hash support
+  using std::hash;
+
+  inline namespace literals {
+    inline namespace string_literals {
+      // [basic.string.literals], suffix for basic_string literals
+      using std::literals::string_literals::operator""s;
+    } // namespace string_literals
+  }   // namespace literals
+
+} // namespace std

libcxx/stdmodules/std-string_view.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <string_view>
+
+export module std:string_view;
+export namespace std {
+
+  // [string.view.template], class template basic_string_view
+  using std::basic_string_view;
+
+  using std::ranges::enable_borrowed_range;
+  using std::ranges::enable_view;
+
+  // [string.view.comparison], non-member comparison functions
+  using std::operator==;
+  using std::operator<=>;
+
+  // see [string.view.comparison], sufficient additional overloads of comparison functions
+
+  // [string.view.io], inserters and extractors
+  using std::operator<<;
+
+  // basic_string_view typedef-names
+  using std::string_view;
+  using std::u16string_view;
+  using std::u32string_view;
+  using std::u8string_view;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstring_view;
+#endif
+
+  // [string.view.hash], hash support
+  using std::hash;
+
+  inline namespace literals {
+    inline namespace string_view_literals {
+      // [string.view.literals], suffix for basic_string_view literals
+      using std::literals::string_view_literals::operator"" sv;
+    }
+  } // namespace literals
+} // namespace std

libcxx/stdmodules/std-system_error.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <system_error>
+
+export module std:system_error;
+export namespace std {
+
+  using std::error_category;
+  using std::generic_category;
+  using std::system_category;
+
+  using std::error_code;
+  using std::error_condition;
+  using std::system_error;
+
+  using std::is_error_code_enum;
+
+  using std::errc;
+
+  // [syserr.errcode.nonmembers], non-member functions
+  using std::make_error_code;
+
+  using std::operator<<;
+
+  // [syserr.errcondition.nonmembers], non-member functions
+  using std::make_error_condition;
+
+  // [syserr.compare], comparison operator functions
+  using std::operator==;
+  using std::operator<=>;
+
+  // [syserr.hash], hash support
+  using std::hash;
+
+  // [syserr], system error support
+  using std::is_error_code_enum_v;
+  using std::is_error_condition_enum_v;
+
+} // namespace std

libcxx/stdmodules/std-tuple.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <tuple>
+
+export module std:tuple;
+export namespace std {
+
+  // [tuple.tuple], class template tuple
+  using std::tuple;
+
+  // [tuple.like], concept tuple-like
+
+  // [tuple.common.ref], common_reference related specializations
+  using std::basic_common_reference;
+  using std::common_type;
+
+  // [tuple.creation], tuple creation functions
+  using std::ignore;
+
+  using std::forward_as_tuple;
+  using std::make_tuple;
+  using std::tie;
+  using std::tuple_cat;
+
+  // [tuple.apply], calling a function with a tuple of arguments
+  using std::apply;
+
+  using std::make_from_tuple;
+
+  // [tuple.helper], tuple helper classes
+  using std::tuple_element;
+  using std::tuple_size;
+
+  using std::tuple_element_t;
+
+  // [tuple.elem], element access
+  using std::tuple_element_t;
+
+  // [tuple.rel], relational operators
+  using std::operator==;
+  using std::operator<=>;
+
+  // [tuple.traits], allocator-related traits
+  using std::uses_allocator;
+
+  // [tuple.special], specialized algorithms
+  using std::swap;
+
+  // [tuple.helper], tuple helper classes
+  using std::tuple_size_v;
+
+} // namespace std

libcxx/stdmodules/std-type_traits.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <functional> // needed for unwrap_ref_decay (is this a bug?)
+#include <type_traits>
+export module std:type_traits;
+export namespace std {
+  using std::bool_constant;
+  using std::false_type;
+  using std::integral_constant;
+  using std::true_type;
+
+  // helper traits
+  using std::conditional;
+  using std::enable_if;
+
+  // Primary classification traits:
+  using std::is_array;
+  using std::is_class;
+  using std::is_enum;
+  using std::is_floating_point;
+  using std::is_function;
+  using std::is_integral;
+  using std::is_lvalue_reference;
+  using std::is_member_function_pointer;
+  using std::is_member_object_pointer;
+  using std::is_null_pointer; // C++14
+  using std::is_pointer;
+  using std::is_rvalue_reference;
+  using std::is_union;
+  using std::is_void;
+
+  // Secondary classification traits:
+  using std::is_arithmetic;
+  using std::is_compound;
+  using std::is_fundamental;
+  using std::is_member_pointer;
+  using std::is_object;
+  using std::is_reference;
+  using std::is_scalar;
+#if _LIBCPP_STD_VER >= 23    // TODO Do we want to provide std module in C++20
+  using std::is_scoped_enum; // C++2b
+#endif
+
+  // Const-volatile properties and transformations:
+  using std::add_const;
+  using std::add_cv;
+  using std::add_volatile;
+  using std::is_const;
+  using std::is_volatile;
+  using std::remove_const;
+  using std::remove_cv;
+  using std::remove_volatile;
+
+  // Reference transformations:
+  using std::add_lvalue_reference;
+  using std::add_rvalue_reference;
+  using std::remove_reference;
+
+  // Pointer transformations:
+  using std::add_pointer;
+  using std::remove_pointer;
+
+  using std::type_identity; // C++20
+  using std::type_identity_t;
+
+  // Integral properties:
+  using std::is_signed;
+  using std::is_unsigned;
+  using std::make_signed;
+  using std::make_unsigned;
+
+  // Array properties and transformations:
+  using std::extent;
+  using std::rank;
+  using std::remove_all_extents;
+  using std::remove_extent;
+
+  using std::is_bounded_array;   // C++20
+  using std::is_unbounded_array; // C++20
+
+  // Member introspection:
+  using std::is_abstract;
+  using std::is_aggregate; // C++17
+  using std::is_empty;
+  using std::is_final;     // C++14
+  using std::is_pod;
+  using std::is_polymorphic;
+  using std::is_standard_layout;
+  using std::is_trivial;
+  using std::is_trivially_copyable;
+
+  using std::is_assignable;
+  using std::is_constructible;
+  using std::is_copy_assignable;
+  using std::is_copy_constructible;
+  using std::is_default_constructible;
+  using std::is_destructible;
+  using std::is_move_assignable;
+  using std::is_move_constructible;
+  using std::is_swappable;      // C++17
+  using std::is_swappable_with; // C++17
+
+  using std::is_trivially_assignable;
+  using std::is_trivially_constructible;
+  using std::is_trivially_copy_assignable;
+  using std::is_trivially_copy_constructible;
+  using std::is_trivially_default_constructible;
+  using std::is_trivially_destructible;
+  using std::is_trivially_move_assignable;
+  using std::is_trivially_move_constructible;
+
+  using std::is_nothrow_assignable;
+  using std::is_nothrow_constructible;
+  using std::is_nothrow_copy_assignable;
+  using std::is_nothrow_copy_constructible;
+  using std::is_nothrow_default_constructible;
+  using std::is_nothrow_destructible;
+  using std::is_nothrow_move_assignable;
+  using std::is_nothrow_move_constructible;
+  using std::is_nothrow_swappable;      // C++17
+  using std::is_nothrow_swappable_with; // C++17
+
+  using std::has_virtual_destructor;
+
+  using std::has_unique_object_representations; // C++17
+
+  // Relationships between types:
+  using std::is_base_of;
+  using std::is_same;
+
+  using std::is_convertible;
+  using std::is_nothrow_convertible;   // C++20
+  using std::is_nothrow_convertible_v; // C++20
+
+  using std::is_invocable;
+  using std::is_invocable_r;
+
+  using std::is_nothrow_invocable;
+  using std::is_nothrow_invocable_r;
+
+  // Alignment properties and transformations:
+  using std::aligned_storage;
+  using std::aligned_union;
+  using std::alignment_of;
+  using std::remove_cvref; // C++20
+
+  using std::common_type;
+  using std::decay;
+  using std::invoke_result; // C++17
+  using std::unwrap_ref_decay;
+  using std::underlying_type;
+
+  // const-volatile modifications:
+  using std::add_const_t;
+  using std::add_cv_t;
+  using std::add_volatile_t;
+  using std::remove_const_t;
+  using std::remove_cv_t;
+  using std::remove_volatile_t;
+
+  // reference modifications:
+  using std::add_lvalue_reference_t;
+  using std::add_rvalue_reference_t;
+  using std::remove_reference_t;
+
+  // sign modifications:
+  using std::make_signed_t;
+  using std::make_unsigned_t;
+
+  // array modifications:
+  using std::remove_all_extents_t;
+  using std::remove_extent_t;
+
+  using std::is_bounded_array_v;   // C++20
+  using std::is_unbounded_array_v; // C++20
+
+  // pointer modifications:
+  using std::add_pointer_t;    // C++14
+  using std::remove_pointer_t; // C++14
+
+  // other transformations:
+  using std::aligned_storage_t; // C++14
+  using std::aligned_union_t;   // C++14
+  using std::common_type_t;     // C++14
+  using std::conditional_t;     // C++14
+  using std::decay_t;           // C++14
+  using std::enable_if_t;       // C++14
+  using std::invoke_result_t;
+  using std::remove_cvref_t;    // C++20
+  using std::underlying_type_t;
+  using std::unwrap_ref_decay_t;
+
+  using std::void_t;
+
+  // See C++14 20.10.4.1, primary type categories
+  using std::is_array_v;
+  using std::is_class_v;
+  using std::is_enum_v;
+  using std::is_floating_point_v;
+  using std::is_function_v;
+  using std::is_integral_v;
+  using std::is_lvalue_reference_v;
+  using std::is_member_function_pointer_v;
+  using std::is_member_object_pointer_v;
+  using std::is_null_pointer_v;
+  using std::is_pointer_v;
+  using std::is_rvalue_reference_v;
+  using std::is_union_v;
+  using std::is_void_v;
+
+  // See C++14 20.10.4.2, composite type categories
+  using std::is_arithmetic_v;
+  using std::is_compound_v;
+  using std::is_fundamental_v;
+  using std::is_member_pointer_v;
+  using std::is_object_v;
+  using std::is_reference_v;
+  using std::is_scalar_v;
+
+#if _LIBCPP_STD_VER >= 23 // TODO Do we want to provide std module in C++20
+  using std::is_scoped_enum_v;
+#endif
+
+  // See C++14 20.10.4.3, type properties
+  using std::has_unique_object_representations_v; // C++17;
+  using std::has_virtual_destructor_v;
+  using std::is_abstract_v;
+  using std::is_aggregate_v;
+  using std::is_assignable_v;
+  using std::is_const_v;
+  using std::is_constructible_v;
+  using std::is_copy_assignable_v;
+  using std::is_copy_constructible_v;
+  using std::is_default_constructible_v;
+  using std::is_destructible_v;
+  using std::is_empty_v;
+  using std::is_final_v;
+  using std::is_move_assignable_v;
+  using std::is_move_constructible_v;
+  using std::is_nothrow_assignable_v;
+  using std::is_nothrow_constructible_v;
+  using std::is_nothrow_copy_assignable_v;
+  using std::is_nothrow_copy_constructible_v;
+  using std::is_nothrow_default_constructible_v;
+  using std::is_nothrow_destructible_v;
+  using std::is_nothrow_move_assignable_v;
+  using std::is_nothrow_move_constructible_v;
+  using std::is_nothrow_swappable_v;
+  using std::is_nothrow_swappable_with_v;
+  using std::is_pod_v;
+  using std::is_polymorphic_v;
+  using std::is_signed_v;
+  using std::is_standard_layout_v;
+  using std::is_swappable_v;
+  using std::is_swappable_with_v;
+  using std::is_trivial_v;
+  using std::is_trivially_assignable_v;
+  using std::is_trivially_constructible_v;
+  using std::is_trivially_copy_assignable_v;
+  using std::is_trivially_copy_constructible_v;
+  using std::is_trivially_copyable_v;
+  using std::is_trivially_default_constructible_v;
+  using std::is_trivially_destructible_v;
+  using std::is_trivially_move_assignable_v;
+  using std::is_trivially_move_constructible_v;
+  using std::is_unsigned_v;
+  using std::is_volatile_v;
+
+  // See C++14 20.10.5, type property queries
+  using std::alignment_of_v; // C++17
+  using std::extent_v;       // C++17
+  using std::rank_v;         // C++17
+
+  // See C++14 20.10.6, type relations
+  using std::is_base_of_v;
+  using std::is_convertible_v;
+  using std::is_invocable_r_v;
+  using std::is_invocable_v;
+  using std::is_nothrow_invocable_r_v;
+  using std::is_nothrow_invocable_v;
+  using std::is_same_v;
+
+  // [meta.logical], logical operator traits:                        // C++17
+  using std::conjunction_v;
+  using std::disjunction_v;
+  using std::negation_v;
+
+  // Move to proper section
+  using std::is_constant_evaluated;
+  using std::negation;
+} // namespace std

libcxx/stdmodules/std-utility.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <utility>
+export module std:utility;
+export namespace std {
+  using std::swap;
+
+  namespace rel_ops {
+    using rel_ops::operator!=;
+    using rel_ops::operator>;
+    using rel_ops::operator<=;
+    using rel_ops::operator>=;
+  } // namespace rel_ops
+
+  using std::as_const;
+  using std::cmp_equal;
+  using std::cmp_greater;       // C++20
+  using std::cmp_greater_equal; // C++20
+  using std::cmp_less;          // C++20
+  using std::cmp_less_equal;    // C++20
+  using std::cmp_not_equal;     // C++20
+  using std::declval;
+  using std::forward;
+// TODO Even when we don't want to provide std module in C++20 this is kept for now.
+// This allows testing whether this way works properly. That will be required for
+// symbols that will be added in C++26.
+#if _LIBCPP_STD_VER >= 23 // TODO Do we want to provide std module in C++20
+  using std::forward_like;
+#endif
+  using std::in_range; // C++20
+  using std::move;
+  using std::move_if_noexcept;
+
+  using std::pair;
+  using std::operator==;
+
+  using std::make_pair;
+  using std::piecewise_construct_t;
+  // FIXME: We can't export non-inline constexpr variables.
+  // using std::piecewise_construct;
+
+  using std::tuple_element;
+  using std::tuple_size;
+
+  using std::get;
+  using std::index_sequence;
+  using std::index_sequence_for;
+  using std::integer_sequence;
+  using std::make_index_sequence;
+  using std::make_integer_sequence;
+
+  using std::exchange;
+  using std::in_place;
+  using std::in_place_t;
+
+  using std::in_place_index_t;
+  using std::in_place_type;
+  using std::in_place_type_t;
+
+  using std::in_place_index;
+#if _LIBCPP_STD_VER >= 23 // TODO Do we want to provide std module in C++20
+  using std::to_underlying;
+#endif
+} // namespace std

libcxx/stdmodules/std-variant.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <variant>
+
+export module std:variant;
+export namespace std {
+  // [variant.variant], class template variant
+  using std::variant;
+
+  // [variant.helper], variant helper classes
+  using std::variant_alternative;
+  using std::variant_npos;
+  using std::variant_size;
+
+  // [variant.get], value access
+  using std::get;
+  using std::get_if;
+  using std::holds_alternative;
+  using std::variant_alternative_t;
+
+  // [variant.relops], relational operators
+  using std::operator==;
+  using std::operator!=;
+  using std::operator<;
+  using std::operator>;
+  using std::operator<=;
+  using std::operator>=;
+  using std::operator<=>;
+
+  // [variant.visit], visitation
+  using std::visit;
+
+  // [variant.monostate], class monostate
+  using std::monostate;
+
+  // [variant.monostate.relops], monostate relational operators
+
+  // [variant.specalg], specialized algorithms
+  using std::swap;
+
+  // [variant.bad.access], class bad_variant_access
+  using std::bad_variant_access;
+
+  // [variant.hash], hash support
+  using std::hash;
+
+} // namespace std

libcxx/stdmodules/std-vector.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+module;
+#include <functional>
+#include <vector>
+export module std:vector;
+
+export namespace std {
+  using std::hash;
+  using std::swap;
+  using std::vector;
+  using std::operator==;
+  using std::erase;
+  using std::erase_if;
+} // namespace std
+
+export { using ::operator new; }

libcxx/stdmodules/std.cppm

+# 1 __FILE__ 1 3
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+export module std;
+// export import :algorithm; // Work in progress
+export import :array;
+export import :charconv;
+export import :chrono;
+export import :coroutine;
+export import :concepts;
+export import :cstddef;
+export import :cstdlib;
+export import :exception;
+export import :expected;
+export import :format;
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+export import :fstream;
+#endif
+export import :functional;
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+export import :iostream;
+#endif
+export import :iterator;
+export import :initializer_list;
+export import :memory;
+export import :numeric;
+export import :optional;
+// export import :ranges; Does not work properly in modules
+export import :span;
+export import :string;
+export import :string_view;
+export import :system_error;
+export import :type_traits;
+export import :tuple;
+export import :utility;
+export import :variant;
+export import :vector;

libcxx/test/configs/cmake-bridge.cfg.in

 import shlex
 config.substitutions.append(('%{cxx}', shlex.quote('@CMAKE_CXX_COMPILER@')))
 config.substitutions.append(('%{libcxx}', '@LIBCXX_SOURCE_DIR@'))
 config.substitutions.append(('%{include}', '@LIBCXX_GENERATED_INCLUDE_DIR@'))
 config.substitutions.append(('%{target-include}', '@LIBCXX_GENERATED_INCLUDE_TARGET_DIR@'))
 config.substitutions.append(('%{lib}', '@LIBCXX_LIBRARY_DIR@'))
 config.substitutions.append(('%{executor}', '@LIBCXX_EXECUTOR@'))
 config.substitutions.append(('%{test-tools}', '@LIBCXX_TEST_TOOLS_PATH@'))
+
+# These are for testing with modules. This is probably not the way forward
+config.substitutions.append(('%{cmake}', '@CMAKE_COMMAND@'))
+config.substitutions.append(('%{make}', '@CMAKE_MAKE_PROGRAM@'))
+config.substitutions.append(('%{generator}', '@CMAKE_GENERATOR@'))

libcxx/test/configs/llvm-libc++-shared.cfg.in

 # This testing configuration handles running the test suite against LLVM's libc++
 # using a shared library.
 
 lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg')
 
 config.substitutions.append(('%{flags}',
-    '-isysroot {}'.format('@CMAKE_OSX_SYSROOT@') if '@CMAKE_OSX_SYSROOT@' else ''
+    '-pthread -isysroot {}'.format('@CMAKE_OSX_SYSROOT@') if '@CMAKE_OSX_SYSROOT@' else ''
 ))
 config.substitutions.append(('%{compile_flags}',
     '-nostdinc++ -I %{include} -I %{target-include} -I %{libcxx}/test/support'
 ))
 config.substitutions.append(('%{link_flags}',
-    '-nostdlib++ -L %{lib} -Wl,-rpath,%{lib} -lc++ -pthread'
+    '-nostdlib++ -L %{lib} -Wl,-rpath,%{lib} -lc++'
 ))
 config.substitutions.append(('%{exec}',
     '%{executor} --execdir %T -- '
 ))
 
 import os, site
 site.addsitedir(os.path.join('@LIBCXX_SOURCE_DIR@', 'utils'))
 import libcxx.test.params, libcxx.test.config
 libcxx.test.config.configure(
     libcxx.test.params.DEFAULT_PARAMETERS,
     libcxx.test.features.DEFAULT_FEATURES,
     config,
     lit_config
 )

libcxx/test/configs/llvm-libc++-static.cfg.in

 # This testing configuration handles running the test suite against LLVM's libc++
 # using a static library.
 
 lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg')
 
 config.substitutions.append(('%{flags}',
-    '-isysroot {}'.format('@CMAKE_OSX_SYSROOT@') if '@CMAKE_OSX_SYSROOT@' else ''
+    '-pthread -isysroot {}'.format('@CMAKE_OSX_SYSROOT@') if '@CMAKE_OSX_SYSROOT@' else ''
 ))
 config.substitutions.append(('%{compile_flags}',
     '-nostdinc++ -I %{include} -I %{target-include} -I %{libcxx}/test/support'
 ))
 config.substitutions.append(('%{link_flags}',
-    '-nostdlib++ -L %{lib} -lc++ -lc++abi -pthread'
+    '-nostdlib++ -L %{lib} -lc++ -lc++abi'
 ))
 config.substitutions.append(('%{exec}',
     '%{executor} --execdir %T -- '
 ))
 
 import os, site
 site.addsitedir(os.path.join('@LIBCXX_SOURCE_DIR@', 'utils'))
 import libcxx.test.params, libcxx.test.config
 libcxx.test.config.configure(
     libcxx.test.params.DEFAULT_PARAMETERS,
     libcxx.test.features.DEFAULT_FEATURES,
     config,
     lit_config
 )

libcxx/test/libcxx/language.support/support.types/cstddef.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure libc++'s <cstddef> defines types like ::nullptr_t in the global namespace.
 // This is a conforming extension to be consistent with other implementations, which all
 // appear to provide that behavior too.
 
-#include <cstddef>
+// XFAIL: use_module_std
+
+#if defined(TEST_USE_MODULE_STD)
+import std;
+#elif defined(TEST_USE_MODULE_STD_COMPAT)
+import std.compat;
+#else
+#  include <cstddef>
+#endif
 #include "test_macros.h"
 
 using PtrdiffT = ::ptrdiff_t;
 using SizeT = ::size_t;
 #if TEST_STD_VER >= 11
 using MaxAlignT = ::max_align_t;
 #endif
 
+#ifndef TEST_USE_MODULE
 // Supported in C++03 mode too for backwards compatibility with previous versions of libc++
 using NullptrT = ::nullptr_t;
+#endif
 
 // Also ensure that we provide std::nullptr_t in C++03 mode, which is an extension too.
 using StdNullptrT = std::nullptr_t;

libcxx/utils/ci/buildkite-pipeline.yml

- label: "Format"
     agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
-
-  - label: "Generated output"
-    command: "libcxx/utils/ci/run-buildbot check-generated-output"
-    artifact_paths:
-      - "**/generated_output.patch"
-      - "**/generated_output.status"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        CLANG_FORMAT: "/usr/bin/clang-format-${LLVM_STABLE_VERSION}"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Documentation"
-    command: "libcxx/utils/ci/run-buildbot documentation"
-    artifact_paths:
-      - "**/test-results.xml"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  #
-  # General testing with the default configuration, under all the supported
-  # Standard modes, with Clang and GCC. This catches most issues upfront.
-  # The goal of this step is to catch most issues while being very fast.
-  #
-  - wait
-
-  - label: "GCC ${GCC_STABLE_VERSION} / C++latest"
-    command: "libcxx/utils/ci/run-buildbot generic-gcc"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "gcc-${GCC_STABLE_VERSION}"
-        CXX: "g++-${GCC_STABLE_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++2b"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx2b"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Modular build"
-    command: "libcxx/utils/ci/run-buildbot generic-modules"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++11"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx11"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++03"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx03"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  #
-  # All other supported configurations of libc++.
-  #
-  - wait
-
-  - label: "C++20"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx20"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++17"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx17"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "C++14"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx14"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with the supported compilers.
-  - label: "GCC ${GCC_STABLE_VERSION} / C++11"
-    command: "libcxx/utils/ci/run-buildbot generic-gcc-cxx11"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "gcc-${GCC_STABLE_VERSION}"
-        CXX: "g++-${GCC_STABLE_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Clang 15"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx2b"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-15"
-        CXX: "clang++-15"
-        # TODO LLVM18: Enable clang-tidy
-        # ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Clang 16"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx2b"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-16"
-        CXX: "clang++-16"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with the sanitizers.
-  - group: "Sanitizers"
-    steps:
-    - label: "ASAN"
-      command: "libcxx/utils/ci/run-buildbot generic-asan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "TSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-tsan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "UBSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-ubsan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MSAN"
-      command: "libcxx/utils/ci/run-buildbot generic-msan"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  # Tests with the various supported ways to build libc++.
-  - label: "Bootstrapping build"
-    command: "libcxx/utils/ci/run-buildbot bootstrapping-build"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-      - "**/crash_diagnostics/*"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        LLVM_SYMBOLIZER_PATH: "/usr/bin/llvm-symbolizer-${LLVM_HEAD_VERSION}"
-        CLANG_CRASH_DIAGNOSTICS_DIR: "crash_diagnostics"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests with various build configurations.
-  - label: "Static libraries"
-    command: "libcxx/utils/ci/run-buildbot generic-static"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Shared library with merged ABI and unwinder libraries"
-    command: "libcxx/utils/ci/run-buildbot generic-merged"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Assertions enabled"
-    command: "libcxx/utils/ci/run-buildbot generic-assertions"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Debug mode"
-    command: "libcxx/utils/ci/run-buildbot generic-debug-mode"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "With LLVM's libunwind"
-    command: "libcxx/utils/ci/run-buildbot generic-with_llvm_unwinder"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - label: "Modular build with Local Submodule Visibility"
-    command: "libcxx/utils/ci/run-buildbot generic-modules-lsv"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  - group: "Parts disabled"
-    steps:
-    - label: "No threads"
-      command: "libcxx/utils/ci/run-buildbot generic-no-threads"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No filesystem"
-      command: "libcxx/utils/ci/run-buildbot generic-no-filesystem"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No random device"
-      command: "libcxx/utils/ci/run-buildbot generic-no-random_device"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No fstream"
-      command: "libcxx/utils/ci/run-buildbot generic-no-fstream"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No locale"
-      command: "libcxx/utils/ci/run-buildbot generic-no-localization"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No Unicode"
-      command: "libcxx/utils/ci/run-buildbot generic-no-unicode"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No wide characters"
-      command: "libcxx/utils/ci/run-buildbot generic-no-wide-characters"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No experimental features"
-      command: "libcxx/utils/ci/run-buildbot generic-no-experimental"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "No exceptions"
-      command: "libcxx/utils/ci/run-buildbot generic-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  - label: "Unstable ABI"
-    command: "libcxx/utils/ci/run-buildbot generic-abi-unstable"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Other non-testing CI jobs
-  - label: "Benchmarks"
-    command: "libcxx/utils/ci/run-buildbot benchmarks"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    env:
-        CC: "clang-${LLVM_HEAD_VERSION}"
-        CXX: "clang++-${LLVM_HEAD_VERSION}"
-        ENABLE_CLANG_TIDY: "On"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
-  # Tests on non-Unix platforms
-  - group: ":windows: Windows"
-    steps:
-    - label: "Clang-cl (DLL)"
-      command: "bash libcxx/utils/ci/run-buildbot clang-cl-dll"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Clang-cl (Static)"
-      command: "bash libcxx/utils/ci/run-buildbot clang-cl-static"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Clang-cl (no vcruntime exceptions)"
-      command: "bash libcxx/utils/ci/run-buildbot clang-cl-no-vcruntime"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-
-    - label: "MinGW (DLL, x86_64)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-dll"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (Static, x86_64)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-static"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MinGW (DLL, i686)"
-      command: "bash libcxx/utils/ci/run-buildbot mingw-dll-i686"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "windows"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  - group: ":apple: Apple"
-    steps:
-    - label: "MacOS x86_64"
-      command: "libcxx/utils/ci/run-buildbot apple-cxx20"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "MacOS arm64"
-      command: "libcxx/utils/ci/run-buildbot apple-cxx20"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "arm64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    # Build with the configuration we use to generate libc++.dylib on Apple platforms
-    - label: "Apple system"
-      command: "libcxx/utils/ci/run-buildbot apple-system"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "arm64" # This can technically run on any architecture, but we have more resources on arm64 so we pin this job to arm64
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    # Test back-deployment to older Apple platforms
-    - label: "Apple back-deployment macosx10.9"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.9"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64" # We need to use x86_64 for back-deployment CI on this target since macOS didn't support arm64 back then.
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Apple back-deployment macosx10.15"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.15"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "x86_64" # We need to use x86_64 for back-deployment CI on this target since macOS didn't support arm64 back then.
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Apple back-deployment macosx11.0 arm64"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-11.0"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-        arch: "arm64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Apple back-deployment with assertions enabled"
-      command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-assertions-11.0"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders"
-        os: "macos"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  - group: "ARM"
-    steps:
-    - label: "AArch64"
-      command: "libcxx/utils/ci/run-buildbot aarch64"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "aarch64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "AArch64 -fno-exceptions"
-      command: "libcxx/utils/ci/run-buildbot aarch64-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "aarch64"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv8"
-      command: "libcxx/utils/ci/run-buildbot armv8"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv8 -fno-exceptions"
-      command: "libcxx/utils/ci/run-buildbot armv8-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv7"
-      command: "libcxx/utils/ci/run-buildbot armv7"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l" # Compiling for v7, running on v8 hardware
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "Armv7 -fno-exceptions"
-      command: "libcxx/utils/ci/run-buildbot armv7-noexceptions"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      agents:
-        queue: "libcxx-builders-linaro-arm"
-        arch: "armv8l" # Compiling for v7, running on v8 hardware
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-  - group: "AIX"
-    steps:
-    - label: "AIX (32-bit)"
-      command: "libcxx/utils/ci/run-buildbot aix"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang"
-          CXX: "clang++"
-          OBJECT_MODE: "32"
-      agents:
-          queue: libcxx-builders
-          os: aix
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
-    - label: "AIX (64-bit)"
-      command: "libcxx/utils/ci/run-buildbot aix"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang"
-          CXX: "clang++"
-          OBJECT_MODE: "64"
-      agents:
-          queue: libcxx-builders
-          os: aix
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120

libcxx/utils/ci/run-buildbot

generic-debug-mode)
     check-runtimes
     # We don't check the ABI lists because the debug mode ABI is not stable
 ;;
 generic-with_llvm_unwinder)
     clean
     generate-cmake -DLIBCXXABI_USE_LLVM_UNWINDER=ON
     check-runtimes
 ;;
+generic-module-std)
+     clean
+     export CC=/usr/lib/llvm-17/bin/clang
+     export CXX=/usr/lib/llvm-17/bin/clang++
+     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-module-std.cmake"
+     check-runtimes
+;;
+generic-module-std-compat)
+     clean
+     export CC=/usr/lib/llvm-17/bin/clang
+     export CXX=/usr/lib/llvm-17/bin/clang++
+     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-module-std-compat.cmake"
+     check-runtimes
+;;
 generic-modules)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-modules.cmake"
     check-runtimes
     check-abi-list
 ;;
 generic-modules-lsv)
     clean

libcxx/utils/libcxx/test/dsl.py

 #===----------------------------------------------------------------------===##
 #
 # 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
 #
 #===----------------------------------------------------------------------===##
 
 import os
 import pickle
 import pipes
 import platform
 import re
 import shutil
+import subprocess
 import tempfile
 
 import libcxx.test.format
 import lit
 import lit.LitConfig
 import lit.Test
 import lit.TestRunner
 import lit.util
class AddFlag(ConfigAction):
   def applyTo(self, config):
     flag = self._getFlag(config)
     assert hasCompileFlag(config, flag), "Trying to enable flag {}, which is not supported".format(flag)
     config.substitutions = _appendToSubstitution(config.substitutions, '%{flags}', flag)
 
   def pretty(self, config, litParams):
     return 'add {} to %{{flags}}'.format(self._getFlag(config))
 
+def _getSubstitution(substitution, config):
+  for (orig, replacement) in config.substitutions:
+    if orig == substitution:
+      return replacement
+  raise ValueError('Substitution {} is not in the config.'.format(substitution))
+
+# TODO This solution works, but is way too slow. Running in the CI
+# should trigger the build once. Running one test will also trigger this
+# which gives quite a overhead when quickly testing some changes.
+class AddModule(ConfigAction):
+
+  def applyTo(self, config):
+    build = os.path.join(config.test_exec_root, '__config_module__')
+
+    cxx = _getSubstitution('%{cxx}', config)
+    std = _getSubstitution('%{cxx_std}', config)
+    if std == 'cxx20':
+        std = '20'
+    elif std == 'cxx2b':
+        std = '23'
+    else:
+        std = '17' # Not allowed for modules
+
+    flags = _getSubstitution('%{flags}', config)
+    include = _getSubstitution('%{include}', config)
+    source = os.path.join(include, '../modules')
+
+    cmake = _getSubstitution('%{cmake}', config)
+    make = _getSubstitution('%{make}', config)
+    generator = _getSubstitution('%{generator}', config)
+
+    print(f"cxx {cxx}")
+    print(f"std {std}")
+    print(f"flags {flags}")
+    print(f"include {include}")
+    print(f"source {source}")
+
+    print(f"cmake {cmake}")
+    print(f"make {make}")
+    print(f"generator {generator}")
+
+    subprocess.check_call([cmake,
+        "-G" + generator,
+        "-DCMAKE_MAKE_PROGRAM=" + make,
+        "-B" + build,
+        "-H" + source,
+        "-DCMAKE_CXX_COMPILER_WORKS=TRUE", # The compiler test fails, but forcing this works
+        "-DCMAKE_CXX_COMPILER=" + cxx,
+        "-DCMAKE_CXX_STANDARD=" + std,
+        "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
+        f"-DCMAKE_CXX_FLAGS={flags}",
+        ], env={})
+
+    subprocess.check_call([cmake, "--build", build], env={})
+
+  def pretty(self, config, litParams):
+    pass
 
 class AddFlagIfSupported(ConfigAction):
   """
   This action adds the given flag to the %{flags} substitution, only if
   the compiler supports the flag.
 
   The flag can be a string or a callable, in which case it is called with the
   configuration to produce the actual flag (as a string).
class AddLinkFlag(ConfigAction):
   The flag can be a string or a callable, in which case it is called with the
   configuration to produce the actual flag (as a string).
   """
   def __init__(self, flag):
     self._getFlag = lambda config: flag(config) if callable(flag) else flag
 
   def applyTo(self, config):
     flag = self._getFlag(config)
-    assert hasCompileFlag(config, flag), "Trying to enable link flag {}, which is not supported".format(flag)
+    # TODO This fails when enabling the modular flags.
+    #assert hasCompileFlag(config, flag), "Trying to enable link flag {}, which is not supported".format(flag)
     config.substitutions = _appendToSubstitution(config.substitutions, '%{link_flags}', flag)
 
   def pretty(self, config, litParams):
     return 'append {} to %{{link_flags}}'.format(self._getFlag(config))
 
-
 class PrependLinkFlag(ConfigAction):
   """
   This action prepends the given flag to the %{link_flags} substitution.
 
   The flag can be a string or a callable, in which case it is called with the
   configuration to produce the actual flag (as a string).
   """
   def __init__(self, flag):

libcxx/utils/libcxx/test/params.py

fallbacks = {
     'c++20': 'c++2a',
   }
   if hasCompileFlag(cfg, '-std='+std):
     return '-std='+std
   if std in fallbacks and hasCompileFlag(cfg, '-std='+fallbacks[std]):
     return '-std='+fallbacks[std]
   return None
 
+_allModules = ['none', 'clang', 'std', 'std.compat']
+def getModuleFlag(cfg, enable_modules):
+  # Originaly the flag was a Boolean, this maps the original Boolean values
+  # to the new enumerate values.
+  fallbacks = {
+    'none': 'False',
+    'clang': 'True',
+  }
+  if enable_modules in _allModules:
+    return enable_modules
+  if enable_modules in fallbacks:
+    return fallbacks[enable_modules]
+  return None
+
+
 DEFAULT_PARAMETERS = [
   Parameter(name='target_triple', type=str,
             help="The target triple to compile the test suite for. This must be "
                  "compatible with the target that the tests will be run on.",
             actions=lambda triple: filter(None, [
               AddFeature('target={}'.format(triple)),
               AddFlagIfSupported('--target={}'.format(triple)),
               AddSubstitution('%{triple}', triple)
             ])),
 
   Parameter(name='std', choices=_allStandards, type=str,
             help="The version of the standard to compile the test suite with.",
             default=lambda cfg: next(s for s in reversed(_allStandards) if getStdFlag(cfg, s)),
             actions=lambda std: [
               AddFeature(std),
               AddSubstitution('%{cxx_std}', re.sub('\+','x', std)),
               AddCompileFlag(lambda cfg: getStdFlag(cfg, std)),
             ]),
 
-  Parameter(name='enable_modules', choices=[True, False], type=bool, default=False,
-            help="Whether to build the test suite with Clang modules enabled.",
-            actions=lambda modules: [
+  Parameter(name='enable_modules', choices=_allModules + ['True', 'False'], type=str,
+            help="Whether to build the test suite with modules enabled. Select "
+                 "Clang for Clang modules and c++ for C++ Standard modules",
+            default=lambda cfg: next(s for s in _allModules if getModuleFlag(cfg, s)),
+            actions=lambda enable_modules: [
               AddFeature('modules-build'),
               AddCompileFlag('-fmodules'),
               AddCompileFlag('-fcxx-modules'), # AppleClang disregards -fmodules entirely when compiling C++. This enables modules for C++.
-            ] if modules else []),
+            ] if enable_modules == "clang" or enable_modules == "True" else [
+              AddFeature('use_module_std'),
+              AddCompileFlag('-DTEST_MODULES'), # remove
+              AddCompileFlag('-DTEST_USE_MODULE'),
+              AddCompileFlag('-DTEST_USE_MODULE_STD'),
+              AddCompileFlag(lambda cfg: '-fprebuilt-module-path=' + os.path.join(cfg.test_exec_root, '__config_module__/CMakeFiles/std.dir')),
+              AddLinkFlag(lambda cfg: os.path.join(cfg.test_exec_root, '__config_module__/libstd.a')),
+              AddModule(),
+            ] if enable_modules == "std" else [
+              AddFeature('use_module_std.compat'),
+              AddCompileFlag('-DTEST_USE_MODULE'),
+              AddCompileFlag("-DTEST_USE_MODULE_STD_COMPAT"),
+              AddCompileFlag(lambda cfg: '-fprebuilt-module-path=' + os.path.join(cfg.test_exec_root, '__config_module__/CMakeFiles/std.compat.dir')),
+              AddLinkFlag(lambda cfg: os.path.join(cfg.test_exec_root, '__config_module__/libstd.compat.a')),
+              AddModule(),
+            ] if enable_modules == "std.compat" else []),
 
   Parameter(name='enable_modules_lsv', choices=[True, False], type=bool, default=False,
           help="Whether to enable Local Submodule Visibility in the Modules build.",
           actions=lambda lsv: [
             AddCompileFlag('-Xclang -fmodules-local-submodule-visibility'),
           ] if lsv else []),
 
   Parameter(name='enable_exceptions', choices=[True, False], type=bool, default=True,

libcxx/utils/use_modules_in_test.py

+#!/usr/bin/env python
+# ===------------------------------------------------------------------------------===##
+#
+# 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
+#
+# ===------------------------------------------------------------------------------===##
+
+# This script converts a regular test to a test using modules.
+#
+# Note this script is mainly used to test the patch https://reviews.llvm.org/D144994
+# It has not been decided that libc++ will use this approach for modules. Therefore
+# the transformation uses a simple algorithm and generates not the prettiest output.
+#
+# The main goal is to quickly convert a batch of tests to the use modules to test
+# whether the std module works for the headers that have been converted. The
+# script can't be executed twice on the same header, so it's intended this
+# script is executed on a not-yet converted code base.
+#
+# Usage
+#   use_modules_in_test.py <file>
+#
+# If the file contains at least one of the headers that is available in the std module
+# it will add a guarded import statement. All headers that are in the module std will
+# be included conditionally.
+
+import re
+import sys
+
+
+HEADERS_MODULE_STD = [
+    # "algorithm",
+    "array",
+    "charconv",
+    "chrono",
+    "coroutines",
+    "concepts",
+    "cstddef",
+    "cstdlib",
+    "exception",
+    "expected",
+    "format",
+    "fstream",
+    "functional",
+    "iostream",
+    "iterator",
+    "initializer_list",
+    "memory",
+    "numeric",
+    "optional",
+    # "ranges",
+    "span",
+    "string",
+    "string_view",
+    "system_error",
+    "tuple",
+    "type_traits",
+    "utility",
+    "variant",
+    "vector",
+]
+
+# Tests that need to be marked as XFAIL for various reasons
+#
+# For example is_literal type has been removed from C++20, the tests reenables it using
+# test specific compile flags. This is not supported by modules.
+UNSUPPORTED_TESTS = [
+    "libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp",
+]
+
+INCLUDE_REGEX = re.compile(r"^\s*#\s*include\s*<(?P<include>[^>]+)>")
+
+
+def process_unsupported(filename: str) -> None:
+    file = open(filename)
+    lines = file.readlines()
+    file.close()
+
+    file = open(filename, "w")
+    file.write("// UNSUPPORTED: c++-modules-build\n")
+    for line in lines:
+        file.write(line)
+
+
+def process_supported(filename: str) -> None:
+    import_written = False
+
+    file = open(filename)
+    lines = file.readlines()
+    file.close()
+
+    file = open(filename, "w")
+    for line in lines:
+        if m := INCLUDE_REGEX.match(line):
+            include = m.group("include")
+            if include in HEADERS_MODULE_STD:
+                if not import_written:
+                    import_written = True
+                    # Note some tests depend on the relavant part of version to be included.
+                    # Therefore include this header unconditionally.
+                    file.write(
+                        """#ifdef TEST_USE_MODULE
+import TEST_USE_MODULE;
+#include <version>   // TODO REMOVE
+#endif
+"""
+                    )
+                file.write(f"#ifndef TEST_USE_MODULE\n{line}#endif\n")
+            else:
+                file.write(line)
+        else:
+            file.write(line)
+
+
+def process(filename: str) -> None:
+    if filename in UNSUPPORTED_TESTS:
+        process_unsupported(filename)
+    else:
+        process_supported(filename)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 2:
+        process(sys.argv[1])

runtimes/CMakeLists.txt

 # Disable use of the installed C++ standard library when building runtimes.
 # Check for -nostdlib++ first; if there's no C++ standard library yet,
 # all check_cxx_compiler_flag commands will fail until we add -nostdlib++
 # (or -nodefaultlibs).
 llvm_check_compiler_linker_flag(CXX "-nostdlib++" CXX_SUPPORTS_NOSTDLIBXX_FLAG)
 if (CXX_SUPPORTS_NOSTDLIBXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdlib++")
 endif()
+# When present, the -nostdinc++ flag gets propagated to the linker flags. In
+# CMake 3.26 this causes try_compile to fail for other compile options. Which
+# results in flags not being set, even when present.
+check_c_compiler_flag("-Wno-unused-command-line-argument" C_SUPPORTS_START_NO_UNUSED_COMMAND_LINE_ARGUMENTS)
+if (C_SUPPORTS_START_NO_UNUSED_COMMAND_LINE_ARGUMENTS)
+  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Wno-unused-command-line-argument")
+endif()
 check_cxx_compiler_flag(-nostdinc++ CXX_SUPPORTS_NOSTDINCXX_FLAG)
 if (CXX_SUPPORTS_NOSTDINCXX_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nostdinc++")
 endif()
 
 # Avoid checking whether the compiler is working.
 set(LLVM_COMPILER_CHECKED ON)