[libc++][print] Adds FILE functions.

[Mordante]

Summary

Drive-by fix to make sure the __retarget_buffer works correctly whan
using a hint of 1. This was discovered in one of the new tests.

Drive-by fixes __retarget_buffer when initialized with size 1.

Implements parts of

• P2093R14 Formatted output
• P2539R4 Should the output of std::print to a terminal be synchronized with the underlying stream?

[Mordante]

Several CI fixes.

[Mordante]

CI fixes.

[Mordante]

Fixes a part of the CI issues.

[Mordante]

Rebased and adjusted to upstream changes.

[Mordante]

CI fixes

[Mordante]

Rebased and updated modules to test with CI.

[Mordante]

Rebased to fix CI.

[Mordante]

CI fixes.

[Mordante]

Update ABI list.

[Mordante]

Fixes issues and test with reduced CI run.

[Mordante]

Test CI and remove unwanted forwards.

[Mordante]

libcxx/include/print

334

Remove this comment.
I spoke with Victor about this in the context of P2905 R0 Runtime format strings and the std::forward should indeed be removed

[Mordante]

Attempts to fix the CI.

[Mordante]

Try to fix the CI.

[Mordante]

Attempts to fix the CI.

[Mordante]

Rebased and CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes and update the lit flags.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Rebased, minimal improvement, and reanable full CI again.

[Mordante]

Removes flush testing; its to unreliable.

[Mordante]

CI fixes.

[Mordante]

Trigger CI.

[Mordante]

Did a final review before publishing.

[Mordante]

Fixes a typo that broke the Windows build.

[philnik]

It's really cool to see this coming together slowly. I didn't do any in-depth review since I'm not familiar with most of the code, but I have a few comments.

libcxx/docs/Status/FormatPaper.csv

51

You probably meant LLVM?

libcxx/include/print

153

Would it make sense to use TODO PRINT or something like that instead? the actual output and formatting seem like two separate things to me.

201

Is this some sort of POSIX function? If yes, maybe we should check that we are on a POSIX system and error out otherwise?

309

I don't expect disabled wide characters and windows to be a common combination, so maybe just adding a compile time error would be the right thing to do here? That would probably be a lot easier to diagnose, and in the unlikely case that people complain we can still change it.

libcxx/src/print.cpp

18

Is lower or upper case the right thing here? I can never remember...

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_windows.pass.cpp

42

This should probably not be here, since this test is currently disabled for GCC.

[Mordante]

Thanks for the review!

libcxx/docs/Status/FormatPaper.csv

51

This is what we did in the past, I agree it's not entirely correct. For now I keep it as is. In the end this page is intended to be removed once format is complete.

libcxx/include/print

153

Good point, mainly a force of habit to type FMT in format related places.
(Since print is quite small I prefer to track the status on the format page.)

[Mordante]

libcxx/include/print

201

Yes it's indeed POSIX and provided by unistd. I followed the method of src/filesystem/operations.cpp where we include this when not on Windows. Other places use #if __has_include(<unistd.h>), so I switch to that method.

309

Good point!

libcxx/src/print.cpp

18

I checked, we use lower case everywhere.

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_windows.pass.cpp

42

I prefer to keep it since this was needed for GCC. I still hope we can enable format/print with GCC in the near future.

[Mordante]

Addresses review comments.

[ldionne]

Nice, thanks! There's a lot of details in this patch, but it means that users would have a really hard time doing this right if they did it themselves!

libcxx/docs/Status/FormatPaper.csv

51

I think this should be 17.0, and this patch needs to be rebased.

libcxx/include/print

67

103–108

I don't think this hunk should be in this patch.

184

We could reorder like this instead, I think it would be easier to follow:

#ifdef _LIBCPP_HAS_NO_UNICODE
inline constexpr bool __use_unicode = false;
#elif defined(_MSVC_EXECUTION_CHARACTER_SET)
inline constexpr bool __use_unicode = _MSVC_EXECUTION_CHARACTER_SET == 65001;
#else
inline constexpr bool __use_unicode = true;
#endif

WDYT? This removes one layer.

186–187

207

Can you link to http://llvm.org/PR61563? Same thing below.

210

Let's use _LIBCPP_UNCATEGORIZED_ASSERT everywhere for now.

228

254

311

344–347

Suggestions:

1. Don't define this function when unicode has been disabled. It's less surprising to have a compilation error when using this function on a system where unicode has been disabled than to call it and get non-unicode output.
2. Don't define __vprint_unicode (above) when unicode is disabled.
3. Switch the if constexpr (__print::__use_unicode) above in println and print to #if <USE UNICODE>

libcxx/src/print.cpp

44

I think this comment is outdated.

46

I don't think this function is needed outside of Windows anymore, since you now use a macro for testing. This would also get rid of the diff in the ABI list.

55

__throw_system_error? This way you don't need ifndef _LIBCPP_HAS_NO_EXCEPTIONS.

libcxx/test/libcxx/input.output/iostream.format/print.fun/transcoding.pass.cpp

39–42 ↗

(On Diff #536525)

I don't think this should be specific to Glibc?

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_posix.pass.cpp

45

49

Maybe we can use ranges::all_of here too?

libcxx/test/std/input.output/iostream.format/print.fun/print.file.pass.cpp

68

We're not using _POSIX_C_SOURCE anywhere in the code base right now, and it looks like at least macOS doesn't define it properly. I generally try to steer away from checking specific macros in the test suite if I can because it's easy to disable tests without intending it.

Instead, I would suggest moving this test to another .pass.cpp file and we can mark it as XFAIL or UNSUPPORTED on the relevant platforms.

71

libcxx/test/std/input.output/iostream.format/print.fun/print_tests.h

68

Can you add some unicode test cases here? It should just write the data as-is IIUC.

libcxx/utils/libcxx/test/header_information.py

42

Can you keep this list sorted?

[Mordante]

Addresses review comments.

[Mordante]

Thanks for the review!

libcxx/include/print

184

Yes this looks better.

207

I slightly changed the message to include the report, I prefer to keep it at this location instead of before the template. Some functions have useful comment which I don't want to clutter with this todo.

libcxx/test/libcxx/input.output/iostream.format/print.fun/transcoding.pass.cpp

39–42 ↗

(On Diff #536525)

Since this is not a part of this patch, I'll do the all_of change separately.

[Mordante]

CI fixes.

[Mordante]

Retrigger CI.

[Mordante]

Rebased and removed parent dependencies. Hopefully this lets the CI ruun.

[Mordante]

CI fixes.

[Mordante]

Fixes building on Windows.

[Mordante]

libcxx/src/print.cpp

52–53

This changes back to the original version. The function __throw_system_error is in the dylib but has no error code overload. I don't think we need to add an overload for one usage.

[ldionne]

libcxx/src/print.cpp

52–53

We could add an overload in another patch to address https://reviews.llvm.org/D154995#inline-1500381 at the same time.

[Mordante]

libcxx/src/print.cpp

52–53

As discussed I'll do that in a follow-up patch.

[hctim]

Edit: May have misattributed this due to changes in vprint files, but I'm bisecting now. There were ~4 other libcxx changes that I'm not 100% confident this is the culprit.

Hi folks,

Looks like this broke sanitizer buildbots, in https://lab.llvm.org/buildbot/#/builders/237/builds/3578:

llvm-libc++-shared.cfg.in :: std/input.output/iostream.format/print.fun/vprint_nonunicode.file.pass.cpp
llvm-libc++-shared.cfg.in :: std/input.output/iostream.format/print.fun/vprint_unicode.file.pass.cpp

(the other failure has since gone away)

********************
Testing:  0.. 10.. 20.. 30.. 40.. 50
FAIL: llvm-libc++-shared.cfg.in :: std/input.output/iostream.format/print.fun/vprint_unicode.file.pass.cpp (5373 of 10181)
******************** TEST 'llvm-libc++-shared.cfg.in :: std/input.output/iostream.format/print.fun/vprint_unicode.file.pass.cpp' FAILED ********************
Script:
--
: 'COMPILED WITH';  /b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm_build0/bin/clang++ /b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm-project/libcxx/test/std/input.output/iostream.format/print.fun/vprint_unicode.file.pass.cpp -pthread --target=aarch64-unknown-linux-gnu -g -fno-omit-frame-pointer -fsanitize=memory -nostdinc++ -I /b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/include/c++/v1 -I /b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/include/c++/v1 -I /b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm-project/libcxx/test/support -std=c++26 -Werror -Wall -Wctad-maybe-unsupported -Wextra -Wshadow -Wundef -Wunused-template -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-noexcept-type -Wno-atomic-alignment -Wno-reserved-module-identifier -Wno-user-defined-literals -Wno-tautological-compare -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Wno-local-type-template-args -Wno-c++11-extensions -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D_LIBCPP_ENABLE_EXPERIMENTAL -Werror=thread-safety -Wuser-defined-warnings  -lc++experimental -nostdlib++ -L /b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/lib -Wl,-rpath,/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/lib -lc++ -o /b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_unicode.file.pass.cpp.dir/t.tmp.exe
: 'EXECUTED AS';  "/usr/bin/python3.10" /b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm-project/libcxx/test/../utils/run.py --execdir /b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_unicode.file.pass.cpp.dir --  /b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_unicode.file.pass.cpp.dir/t.tmp.exe
--
Exit Code: 250
Command Output (stdout):
--
$ ":" "COMPILED WITH"
note: command had no output on stdout or stderr
$ "/b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm_build0/bin/clang++" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm-project/libcxx/test/std/input.output/iostream.format/print.fun/vprint_unicode.file.pass.cpp" "-pthread" "--target=aarch64-unknown-linux-gnu" "-g" "-fno-omit-frame-pointer" "-fsanitize=memory" "-nostdinc++" "-I" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/include/c++/v1" "-I" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/include/c++/v1" "-I" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm-project/libcxx/test/support" "-std=c++26" "-Werror" "-Wall" "-Wctad-maybe-unsupported" "-Wextra" "-Wshadow" "-Wundef" "-Wunused-template" "-Wno-unused-command-line-argument" "-Wno-attributes" "-Wno-pessimizing-move" "-Wno-noexcept-type" "-Wno-atomic-alignment" "-Wno-reserved-module-identifier" "-Wno-user-defined-literals" "-Wno-tautological-compare" "-Wsign-compare" "-Wunused-variable" "-Wunused-parameter" "-Wunreachable-code" "-Wno-unused-local-typedef" "-Wno-local-type-template-args" "-Wno-c++11-extensions" "-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER" "-D_LIBCPP_ENABLE_EXPERIMENTAL" "-Werror=thread-safety" "-Wuser-defined-warnings" "-lc++experimental" "-nostdlib++" "-L" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/lib" "-Wl,-rpath,/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/lib" "-lc++" "-o" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_unicode.file.pass.cpp.dir/t.tmp.exe"
note: command had no output on stdout or stderr
$ ":" "EXECUTED AS"
note: command had no output on stdout or stderr
$ "/usr/bin/python3.10" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/llvm-project/libcxx/test/../utils/run.py" "--execdir" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_unicode.file.pass.cpp.dir" "--" "/b/sanitizer-aarch64-linux-bootstrap-msan/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_unicode.file.pass.cpp.dir/t.tmp.exe"
# command stderr:
libc++abi: terminating due to uncaught exception of type std::__1::format_error: Argument index out of bounds
error: command failed with exit status: 250

You can reproduce the exact bot with https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild (buildbot_bootstrap_msan.sh is that particular bot), but I suspect a libcxxabi-libcxx bootstrap build should be sufficient to reproduce.

[Mordante]

In D150044#4514158, @hctim wrote:

Edit: May have misattributed this due to changes in vprint files, but I'm bisecting now. There were ~4 other libcxx changes that I'm not 100% confident this is the culprit.

This indeed looks like the culprit.

You can reproduce the exact bot with https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild (buildbot_bootstrap_msan.sh is that particular bot), but I suspect a libcxxabi-libcxx bootstrap build should be sufficient to reproduce.

Unfortunately I can't reproduce it locally (Linux x86_64). I see https://lab.llvm.org/buildbot/#/builders/74 the x86_64 msan buildbot is happy but the aarch64. The exception in the logs is thrown in the test, but it seems it's not caught. Is it possible to see where the exception is thrown? Or can I get access to the buildbot to run some tests?

[hctim]

In D150044#4515133, @Mordante wrote:

Unfortunately I can't reproduce it locally (Linux x86_64). I see https://lab.llvm.org/buildbot/#/builders/74 the x86_64 msan buildbot is happy but the aarch64. The exception in the logs is thrown in the test, but it seems it's not caught. Is it possible to see where the exception is thrown? Or can I get access to the buildbot to run some tests?

Let me see if I can get you a stack trace (it might take me until ~tomorrow). Is it possible to revert/skip these tests on aarch64 in the meantime?

[Mordante]

In D150044#4515393, @hctim wrote:

In D150044#4515133, @Mordante wrote:

Unfortunately I can't reproduce it locally (Linux x86_64). I see https://lab.llvm.org/buildbot/#/builders/74 the x86_64 msan buildbot is happy but the aarch64. The exception in the logs is thrown in the test, but it seems it's not caught. Is it possible to see where the exception is thrown? Or can I get access to the buildbot to run some tests?

Let me see if I can get you a stack trace (it might take me until ~tomorrow). Is it possible to revert/skip these tests on aarch64 in the meantime?

Thanks! It's a bit tricky to find the proper flags to only disable it on aarch64 with msan. Instead I'll disable it for all msan builds.

[hctim]

In D150044#4515777, @Mordante wrote:

Thanks! It's a bit tricky to find the proper flags to only disable it on aarch64 with msan. Instead I'll disable it for all msan builds.

Unfortunately that doesn't quite do the trick, as we're also seeing the bug on the aarch64 asan and aarch64 hwasan bots as well :(.

[Mordante]

In D150044#4519110, @hctim wrote:

In D150044#4515777, @Mordante wrote:

Thanks! It's a bit tricky to find the proper flags to only disable it on aarch64 with msan. Instead I'll disable it for all msan builds.

Unfortunately that doesn't quite do the trick, as we're also seeing the bug on the aarch64 asan and aarch64 hwasan bots as well :(.

I indeed only turned of msan, doing it for asan and hwsan is trivial. Are the other sanitizers that fail?

[hctim]

In D150044#4519273, @Mordante wrote:

I indeed only turned of msan, doing it for asan and hwsan is trivial. Are the other sanitizers that fail?

The aarch64-ubsan build bot is fine, so it's just aarch64_{asan,msan,hwasan}. Still looking into getting you a stack trace or some other debugging info.

[Mordante]

In D150044#4519320, @hctim wrote:

In D150044#4519273, @Mordante wrote:

I indeed only turned of msan, doing it for asan and hwsan is trivial. Are the other sanitizers that fail?

The aarch64-ubsan build bot is fine, so it's just aarch64_{asan,msan,hwasan}. Still looking into getting you a stack trace or some other debugging info.

I've committed a fix for these two sanitizers too. Thanks for the info.

[hctim]

$ lldb /home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe
(lldb) target create "/home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe"                                            Current executable set to '/home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe' (aarch64).                            (lldb) r
Process 737940 launched: '/home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe' (aarch64)
Process 737940 stopped and restarted: thread 1 received signal: SIGCHLD
libc++abi: terminating due to uncaught exception of type std::__1::format_error: Argument index out of bounds
Process 737940 stopped
* thread #1, name = 't.tmp.exe', stop reason = signal SIGABRT
    frame #0: 0x0000fffff7ac7eac libc.so.6`__GI_raise(sig=6) at raise.c:51:1
(lldb) bt
* thread #1, name = 't.tmp.exe', stop reason = signal SIGABRT
  * frame #0: 0x0000fffff7ac7eac libc.so.6`__GI_raise(sig=6) at raise.c:51:1
    frame #1: 0x0000fffff7ab4aa0 libc.so.6`__GI_abort at abort.c:79:7
    frame #2: 0x0000fffff7dd4948 libc++abi.so.1`abort_message at abort_message.cpp:78:5
    frame #3: 0x0000fffff7d8a1f0 libc++abi.so.1`::demangling_terminate_handler() at cxa_default_handlers.cpp:72:9
    frame #4: 0x0000fffff7dd3138 libc++abi.so.1`std::__terminate(void (*)()) at cxa_handlers.cpp:59:9
    frame #5: 0x0000fffff7dda23c libc++abi.so.1`__cxxabiv1::failed_throw(__cxxabiv1::__cxa_exception*) at cxa_exception.cpp:152:5
    frame #6: 0x0000fffff7dda168 libc++abi.so.1`::__cxa_throw() at cxa_exception.cpp:283:5
    frame #7: 0x0000aaaaaabdbfac t.tmp.exe`std::__1::__throw_format_error[abi:v170000](__s="Argument index out of bounds") at format_error.h:41:3
    frame #8: 0x0000aaaaaabdf058 t.tmp.exe`auto char const* std::__1::__format::__handle_replacement_field[abi:v170000]<char const*, std::__1::basic_format_parse_context<char>, std::__1::basic_format_cont
ext<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>(this=0x0000ffffffffe0c0, __arg=monostate @ 0x0000ffffffffdeaf)::'lambda'(char const*)::operator()<std::__1::monostate>
(char const*) const at format_functions.h:274:13
    frame #9: 0x0000aaaaaabdefe8 t.tmp.exe`decltype(std::declval<char const*>()(std::declval<std::__1::monostate&>())) std::__1::__invoke[abi:v170000]<char const* std::__1::__format::__handle_replacement_
field[abi:v170000]<char const*, std::__1::basic_format_parse_context<char>, std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>(char const*, ch
ar const*, std::__1::basic_format_parse_context<char>&, std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>&)::'lambda'(char const*), std::__1::
monostate&>(__f=0x0000ffffffffe0c0, __args=0x0000ffffffffe0a0) at invoke.h:340:25
    frame #10: 0x0000aaaaaabde430 t.tmp.exe`std::__1::invoke_result<char const*, std::__1::monostate&>::type std::__1::invoke[abi:v170000]<char const* std::__1::__format::__handle_replacement_field[abi:v1
70000]<char const*, std::__1::basic_format_parse_context<char>, std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>(char const*, char const*, s
td::__1::basic_format_parse_context<char>&, std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>&)::'lambda'(char const*), std::__1::monostate&>(
__f=0x0000ffffffffe0c0, __args=0x0000ffffffffe0a0) at invoke.h:30:12
    frame #11: 0x0000aaaaaabdcfa0 t.tmp.exe`decltype(auto) std::__1::__visit_format_arg[abi:v170000]<char const* std::__1::__format::__handle_replacement_field[abi:v170000]<char const*, std::__1::basic_fo
rmat_parse_context<char>, std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>(char const*, char const*, std::__1::basic_format_parse_context<ch
ar>&, std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>&)::'lambda'(char const*), std::__1::basic_format_context<std::__1::back_insert_iterato
r<std::__1::__format::__output_buffer<char>>, char>>(__vis=0x0000ffffffffe0c0, __arg=basic_format_arg<std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char
> >, char> > @ 0x0000ffffffffe0a0) at format_arg.h:103:12
    frame #12: 0x0000aaaaaabdc404 t.tmp.exe`char const* std::__1::__format::__handle_replacement_field[abi:v170000]<char const*, std::__1::basic_format_parse_context<char>, std::__1::basic_format_context<
std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>(__begin="}", __end="", __parse_ctx=0x0000ffffffffe408, __ctx=0x0000ffffffffe3c8) at format_functions.h:271:5
    frame #13: 0x0000aaaaaabd7ddc t.tmp.exe`std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>::iterator std::__1::__format::__vformat_to[abi:v
170000]<std::__1::basic_format_parse_context<char>, std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>(__parse_ctx=0x0000ffffffffe408, __ctx=0
x0000ffffffffe3c8) at format_functions.h:312:13
    frame #14: 0x0000aaaaaabd7738 t.tmp.exe`std::__1::back_insert_iterator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>> std::__1::__vformat_to[abi:v170000]<std::__1::back_insert_iterator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>>, char, std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>>(__out_it=(container = ""), __fmt="hello {}", __args=basic_format_args<std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char> >, char> > @ 0x0000ffffffffe808) at format_functions.h:387:5
    frame #15: 0x0000aaaaaabd6ee4 t.tmp.exe`void std::__1::__print::__vprint_nonunicode[abi:v170000]<void>(_IO_FILE*, std::__1::basic_string_view<char, std::__1::char_traits<char>>, std::__1::basic_format_args<std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>, bool) [inlined] std::__1::back_insert_iterator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>> std::__1::vformat_to[abi:v170000]<std::__1::back_insert_iterator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>>>(__out_it=(container = ""), __fmt="hello {}", __args=std::__1::format_args @ 0x0000ffffffffe7a0) at format_functions.h:399:10
    frame #16: 0x0000aaaaaabd6e5c t.tmp.exe`void std::__1::__print::__vprint_nonunicode[abi:v170000]<void>(_IO_FILE*, std::__1::basic_string_view<char, std::__1::char_traits<char>>, std::__1::basic_format_args<std::__1::basic_format_context<std::__1::back_insert_iterator<std::__1::__format::__output_buffer<char>>, char>>, bool) [inlined] std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> std::__1::vformat[abi:v170000]<void>(__fmt="hello {}", __args=std::__1::format_args @ 0x0000ffffffffe730) at format_functions.h:432:3
    frame #17: 0x0000aaaaaabd6d3c t.tmp.exe`void std::__1::__print::__vprint_nonunicode[abi:v170000]<void>(__stream=0x0000e14000000000, __fmt="hello {}", __args=std::__1::format_args @ 0x0000ffffffffe8c8, __write_nl=false) at print:208:18
    frame #18: 0x0000aaaaaabd6850 t.tmp.exe`void std::__1::vprint_nonunicode[abi:v170000]<void>(__stream=0x0000e14000000000, __fmt="hello {}", __args=std::__1::format_args @ 0x0000ffffffffea38) at print:355:3
    frame #19: 0x0000aaaaaabc1510 t.tmp.exe`auto $_1::operator()<>(this=0x0000fffffffff2f6, what="Argument index out of bounds", fmt="hello {}") const at vprint_nonunicode.file.pass.cpp:57:3
    frame #20: 0x0000aaaaaabbb3f0 t.tmp.exe`void print_tests<$_0, $_1>(check=(unnamed class) @ 0x0000fffffffff2f7, check_exception=(unnamed class) @ 0x0000fffffffff2f6) at print_tests.h:78:3
    frame #21: 0x0000aaaaaabb9d9c t.tmp.exe`main((null)=1, (null)=0x0000fffffffff4e8) at vprint_nonunicode.file.pass.cpp:134:3
    frame #22: 0x0000fffff7ab4e18 libc.so.6`__libc_start_main(main=(t.tmp.exe`main at vprint_nonunicode.file.pass.cpp:133), argc=1, argv=0x0000fffffffff4e8, init=<unavailable>, fini=<unavailable>, rtld_fini=<unavailable>, stack_end=<unavailable>) at libc-start.c:308:16
    frame #23: 0x0000aaaaaab31df4 t.tmp.exe`_start + 52

[Mordante]

In D150044#4519677, @hctim wrote:

$ lldb /home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe
(lldb) target create "/home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe"                                            Current executable set to '/home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe' (aarch64).                            (lldb) r
Process 737940 launched: '/home/mitchp/build/libcxx_build_msan/test/std/input.output/iostream.format/print.fun/Output/vprint_nonunicode.file.pass.cpp.dir/t.tmp.exe' (aarch64)
Process 737940 stopped and restarted: thread 1 received signal: SIGCHLD
libc++abi: terminating due to uncaught exception of type std::__1::format_error: Argument index out of bounds
Process 737940 stopped
* thread #1, name = 't.tmp.exe', stop reason = signal SIGABRT
    frame #0: 0x0000fffff7ac7eac libc.so.6`__GI_raise(sig=6) at raise.c:51:1
(lldb) bt
* thread #1, name = 't.tmp.exe', stop reason = signal SIGABRT
  * frame #0: 0x0000fffff7ac7eac libc.so.6`__GI_raise(sig=6) at raise.c:51:1
    frame #1: 0x0000fffff7ab4aa0 libc.so.6`__GI_abort at abort.c:79:7
    frame #2: 0x0000fffff7dd4948 libc++abi.so.1`abort_message at abort_message.cpp:78:5
    frame #3: 0x0000fffff7d8a1f0 libc++abi.so.1`::demangling_terminate_handler() at cxa_default_handlers.cpp:72:9
    frame #4: 0x0000fffff7dd3138 libc++abi.so.1`std::__terminate(void (*)()) at cxa_handlers.cpp:59:9
    frame #5: 0x0000fffff7dda23c libc++abi.so.1`__cxxabiv1::failed_throw(__cxxabiv1::__cxa_exception*) at cxa_exception.cpp:152:5
    frame #6: 0x0000fffff7dda168 libc++abi.so.1`::__cxa_throw() at cxa_exception.cpp:283:5
    frame #7: 0x0000aaaaaabdbfac t.tmp.exe`std::__1::__throw_format_error[abi:v170000](__s="Argument index out of bounds") at format_error.h:41:3

This looks suspicious.
The code throws an exception which I verified is intended.
Then the libc++abi calls failed_throw which causes termination.
Is there a way to get more information about what happens in frame #6? Here it seems the exception is not able to find the proper handler for the exception and thus calling terminate.

[Mordante]

libcxx/src/print.cpp

55

D156019 is the followup.

[rprichard]

libcxx/include/print

216

I'm wondering about this usage of std::ferror. The first argument to std::__throw_system_error appears to be a Unix errno value, whereas ferror appears to returns non-zero if the stream's error indicator flag is set.

e.g. The (print.file.pass.cpp, test_read_only) test opens a read-only file and tries to print to it. fwrite to such a stream fails with EBADF(9). glibc sets the stream's error indicator, so ferror returns 1, which is interpreted as EPERM(1). With Bionic, ferror instead returns 0, so this test is failing on Bionic/Android, because there is no OS error string suffixed to the what() result.

[uabelho]

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_posix.pass.cpp

40

When I run this testcase the assert on line 48 below fails for me, and it seems to be because the "fmemopen" call here writes '\0' at the first byte in buffer.

I really doen't know anything about this and if I read at
https://man7.org/linux/man-pages/man3/fmemopen.3.html
it says

w      The stream is opened for writing.

and also

w+     Open the stream for reading and writing.  The buffer
       contents are truncated (i.e., '\0' is placed in the first
       byte of the buffer).

So it seems like when I run this in my environment "w" partly does what "w+" should do.

Does this problem sound familiar to anyone?

[tahonermann]

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_posix.pass.cpp

40

Are you by chance using an old glibc version from 2015 or earlier? Early implementations of fmemopen() unconditionally truncated the buffer when opened for write. This was changed in this commit:

• https://github.com/bminor/glibc/commit/fdb7d390dd0d96e4a8239c46f3aa64598b90842b#diff-d190e07e0c146d56444d64c78bb49f4764974719ed454e0254644e1a7b793803L239

Alternatively, the "old" implementation replaced by the commit above is still present in current glibc releases under the name __old_fmemopen. Perhaps your builds are somehow calling that implementation?

• https://github.com/bminor/glibc/blob/master/libio/oldfmemopen.c

[uabelho]

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_posix.pass.cpp

40

Yes, seems like we're using ancient glibc versions on our servers.

That explains our problem then. Thank you!

[ldionne]

libcxx/include/print

216

See https://reviews.llvm.org/D158930

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_mdspan``                                *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_move_only_function``                    *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_optional``                              ``202110L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_out_ptr``                               *unimplemented*
     --------------------------------------------------- -----------------
+    ``__cpp_lib_print``                                 *unimplemented*
+    --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_as_rvalue``                      ``202207L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                          *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk_by``                       *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_iota``                           *unimplemented*
     --------------------------------------------------- -----------------

libcxx/docs/Status/Cxx23Papers.csv

 "`P0009R18 <https://wg21.link/P0009R18>`__","LWG","mdspan: A Non-Owning Multidimensional Array Reference","July 2022","|In progress| [#note-P0009R18]_|",""
 "`P0429R9 <https://wg21.link/P0429R9>`__","LWG","A Standard ``flat_map``","July 2022","",""
 "`P1169R4 <https://wg21.link/P1169R4>`__","LWG","``static operator()``","July 2022","|Complete|","16.0"
 "`P1222R4 <https://wg21.link/P1222R4>`__","LWG","A Standard ``flat_set``","July 2022","",""
 "`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","","","|ranges|"
 "`P1467R9 <https://wg21.link/P1467R9>`__","LWG","Extended ``floating-point`` types and standard names","July 2022","",""
 "`P1642R11 <https://wg21.link/P1642R11>`__","LWG","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","July 2022","",""
 "`P1899R3 <https://wg21.link/P1899R3>`__","LWG","``stride_view``","July 2022","","","|ranges|"
-"`P2093R14 <https://wg21.link/P2093R14>`__","LWG","Formatted output","July 2022","",""
+"`P2093R14 <https://wg21.link/P2093R14>`__","LWG","Formatted output","July 2022","","|In Progress|"
 "`P2165R4 <https://wg21.link/P2165R4>`__","LWG","Compatibility between ``tuple``, ``pair`` and ``tuple-like`` objects","July 2022","",""
 "`P2278R4 <https://wg21.link/P2278R4>`__","LWG","``cbegin`` should always return a constant iterator","July 2022","","","|ranges|"
 "`P2286R8 <https://wg21.link/P2286R8>`__","LWG","Formatting Ranges","July 2022","|Complete|","16.0","|format| |ranges|"
 "`P2291R3 <https://wg21.link/P2291R3>`__","LWG","Add Constexpr Modifiers to Functions ``to_chars`` and ``from_chars`` for Integral Types in ``<charconv>`` Header","July 2022","|Complete|","16.0"
 "`P2302R4 <https://wg21.link/P2302R4>`__","LWG","``std::ranges::contains``","July 2022","","","|ranges|"
 "`P2322R6 <https://wg21.link/P2322R6>`__","LWG","``ranges::fold``","July 2022","","","|ranges|"
 "`P2374R4 <https://wg21.link/P2374R4>`__","LWG","``views::cartesian_product``","July 2022","","","|ranges|"
 "`P2404R3 <https://wg21.link/P2404R3>`__","LWG","Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``","July 2022","",""

 "`P2613R1 <https://wg21.link/P2613R1>`__","LWG","Add the missing ``empty`` to ``mdspan``","July 2022","",""
 "","","","","","",""
 "`P1202R5 <https://wg21.link/P1202R5>`__","LWG", "Asymmetric Fences", "November 2022","","","|concurrency TS|"
 "`P1264R2 <https://wg21.link/P1264R2>`__","LWG", "Revising the wording of ``stream`` input operations", "November 2022","|Complete|","9.0",""
 "`P1478R8 <https://wg21.link/P1478R8>`__","LWG", "``Byte-wise`` ``atomic`` ``memcpy``", "November 2022","","","|concurrency TS|"
 "`P2167R3 <https://wg21.link/P2167R3>`__","LWG", "Improved Proposed Wording for LWG 2114", "November 2022","","",""
 "`P2396R1 <https://wg21.link/P2396R1>`__","LWG", "Concurrency TS 2 fixes ", "November 2022","","","|concurrency TS|"
 "`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","|Complete|","17.0",""
-"`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","","","|format|"
+"`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","|In Progress|","","|format|"
 "`P2602R2 <https://wg21.link/P2602R2>`__","LWG", "Poison Pills are Too Toxic", "November 2022","","","|ranges|"
 "`P2708R1 <https://wg21.link/P2708R1>`__","LWG", "No Further Fundamentals TSes", "November 2022","|Nothing to do|","",""
 "","","","","","",""
 "`P0290R4 <https://wg21.link/P0290R4>`__","LWG", "``apply()`` for ``synchronized_value<T>``","February 2023","","","|concurrency TS|"
 "`P2770R0 <https://wg21.link/P2770R0>`__","LWG", "Stashing stashing ``iterators`` for proper flattening","February 2023","","","|ranges|"
 "`P2164R9 <https://wg21.link/P2164R9>`__","LWG", "``views::enumerate``","February 2023","","","|ranges|"
 "`P2711R1 <https://wg21.link/P2711R1>`__","LWG", "Making multi-param constructors of ``views`` ``explicit``","February 2023","|Partial| [#note-P2711R1]_","","|ranges|"
 "`P2609R3 <https://wg21.link/P2609R3>`__","LWG", "Relaxing Ranges Just A Smidge","February 2023","","","|ranges|"

libcxx/docs/Status/FormatIssues.csv

 Number,Name,Standard,Assignee,Status,First released version
 `P0645 <https://wg21.link/P0645>`_,"Text Formatting","C++20",Mark de Wever,|Complete|,14.0
 `P1652 <https://wg21.link/P1652>`_,"Printf corner cases in std::format","C++20",Mark de Wever,|Complete|,14.0
 `P1892 <https://wg21.link/P1892>`_,"Extended locale-specific presentation specifiers for std::format","C++20",Mark de Wever,|Complete|,14.0
 `P1868 <https://wg21.link/P1868>`_,"width: clarifying units of width and precision in std::format (Implements the unicode support.)","C++20",Mark de Wever,|Complete|,14.0
 `P2216 <https://wg21.link/P2216>`_,"std::format improvements","C++20",Mark de Wever,|Complete|,15.0
 `P2418 <https://wg21.link/P2418>`__,"Add support for ``std::generator``-like types to ``std::format``","C++20",Mark de Wever,|Complete|,15.0
-"`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output","C++23",Mark de Wever,|In Progress|,
+"`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output","C++23",Mark de Wever,|In Progress|
 "`P2286R8 <https://wg21.link/P2286R8>`__","Formatting Ranges","C++23","Mark de Wever","|Complete|",16.0
 "`P2508R1 <https://wg21.link/P2508R1>`__","Exposing ``std::basic-format-string``","C++23","Mark de Wever","|Complete|",15.0
 "`P2585R0 <https://wg21.link/P2585R0>`__","Improving default container formatting","C++23","Mark de Wever","|Complete|",17.0
-"`P2539R4 <https://wg21.link/P2539R4>`__","Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?","C++23","Mark de Wever"
+"`P2539R4 <https://wg21.link/P2539R4>`__","Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?","C++23","Mark de Wever","|In Progress|"
 "`P2713R1 <https://wg21.link/P2713R1>`__","Escaping improvements in ``std::format``","C++23","Mark de Wever",""
 "`P2675R1 <https://wg21.link/P2675R1>`__","``format``'s width estimation is too approximate and not forward compatible","C++23","Mark de Wever","|Complete|",17.0
 "`P2572R1 <https://wg21.link/P2572R1>`__","``std::format`` fill character allowances","C++23","Mark de Wever","|Complete|",17.0
-"`P2693R1 <https://wg21.link/P2693R1>`__","Formatting ``thread::id`` and ``stacktrace``","C++23","Mark de Wever","|In progress|"
-"`P2510R3 <https://wg21.link/P2510R3>`__","Formatting pointers","C++26","Mark de Wever","|Complete|", 17.0
+"`P2693R1 <https://wg21.link/P2693R1>`__","Formatting ``thread::id`` and ``stacktrace``","C++23","Mark de Wever","|In Progress|"
+"`P2510R3 <https://wg21.link/P2510R3>`__","Formatting pointers","C++26","Mark de Wever","|Complete|",17.0
 "`P2757R3 <https://wg21.link/P2757R3>`__","Type-checking format args","C++26","","",
 "`P2637R3 <https://wg21.link/P2637R3>`__","Member ``visit``","C++26","","",
 `P1361 <https://wg21.link/P1361>`_,"Integration of chrono with text formatting","C++20",Mark de Wever,|In Progress|,
 `P2372 <https://wg21.link/P2372>`__,"Fixing locale handling in chrono formatters","C++20",Mark de Wever,|In Progress|,
 "`P2419R2 <https://wg21.link/P2419R2>`__","Clarify handling of encodings in localized formatting of chrono types","C++23",

libcxx/docs/Status/FormatPaper.csv

 `[format.range.fmtstr] <https://wg21.link/format.range.fmtstr>`_,"Formatting for ranges: debug_strings",,Mark de Wever,|Complete|,17.0
 
 "`P2693R1 <https://wg21.link/P2693R1>`__","Formatting ``thread::id`` and ``stacktrace``"
 `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,"Formatting ``thread::id``",,Mark de Wever,|Complete|,17.0
 `[stacktrace.format] <https://wg21.link/stacktrace.format>`_,"Formatting ``stacktrace``",A ``<stacktrace>`` implementation,Mark de Wever,,
 
 "`P2093R14 <https://wg21.link/P2093R14>`__","Formatted output"
 `[print.fun] <https://wg21.link/print.fun>`__,"Output to ``stdout``",,Mark de Wever,|In Progress|,
-`[print.fun] <https://wg21.link/print.fun>`__,"Output to ``FILE*``",,Mark de Wever,,
+`[print.fun] <https://wg21.link/print.fun>`__,"Output to ``FILE*``",,Mark de Wever,|Complete|, 17.0
 `[ostream.formatted.print] <https://wg21.link/ostream.formatted.print>`__,"Output to ``ostream``",,Mark de Wever

libcxx/include/__format/buffer.h

 class _LIBCPP_TEMPLATE_VIS __retarget_buffer {
   using _Alloc = allocator<_CharT>;
 
 public:
   using value_type = _CharT;
 
   struct __iterator {
     using difference_type = ptrdiff_t;
+    using value_type      = _CharT;
 
     _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(__retarget_buffer& __buffer)
         : __buffer_(std::addressof(__buffer)) {}
     _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator=(const _CharT& __c) {
       __buffer_->push_back(__c);
       return *this;
     }
     _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator=(_CharT&& __c) {
       __buffer_->push_back(__c);
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator*() { return *this; }
     _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() { return *this; }
     _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) { return *this; }
     __retarget_buffer* __buffer_;
   };
 
   __retarget_buffer(const __retarget_buffer&)            = delete;
   __retarget_buffer& operator=(const __retarget_buffer&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI explicit __retarget_buffer(size_t __size_hint) {
-    auto __result = std::__allocate_at_least(__alloc_, __size_hint ? __size_hint : 256 / sizeof(_CharT));
+    // When the initial size is very small a lot of resizes happen
+    // when elements added. So use a hard-coded minimum size.
+    //
+    // Note a size < 2 will not work
+    // - 0 there is no buffer, while push_back requires 1 empty element.
+    // - 1 multiplied by the grow factor is 1 and thus the buffer never
+    //   grows.
+    auto __result = std::__allocate_at_least(__alloc_, std::max(__size_hint, 256 / sizeof(_CharT)));
     __ptr_        = __result.ptr;
     __capacity_   = __result.count;
   }
 
   _LIBCPP_HIDE_FROM_ABI ~__retarget_buffer() {
     ranges::destroy_n(__ptr_, __size_);
     allocator_traits<_Alloc>::deallocate(__alloc_, __ptr_, __capacity_);
   }

libcxx/include/print

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_PRINT
 #define _LIBCPP_PRINT
 
+/*
+namespace std {
+  // [print.fun], print functions
+  template<class... Args>
+    void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+
+  template<class... Args>
+    void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+
+  void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+
+  void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+}
+*/
+
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__concepts/same_as.h>
 #include <__config>
+#include <__format/buffer.h>
+#include <__format/format_arg_store.h>
+#include <__format/format_args.h>
+#include <__format/format_context.h>
+#include <__format/format_error.h>
+#include <__format/format_functions.h>
 #include <__format/unicode.h>
+#include <__system_error/system_error.h>
+#include <__utility/forward.h>
+#include <cerrno>
+#include <cstdio>
+#include <string>
 #include <string_view>
 #include <version>
 
+#if __has_include(<unistd.h>)
+#  include <unistd.h>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifdef _WIN32
+_LIBCPP_EXPORTED_FROM_ABI bool __is_windows_terminal(FILE* __stream);
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+// A wrapper for WriteConsoleW which is used to write to the Windows
+// console. This function is in the dylib to avoid pulling in windows.h
+// in the library headers. The function itself uses some private parts
+// of the dylib too.
+//
+// The function does not depend on the language standard used. Guarding
+// it with C++23 would fail since the dylib is currently built using C++20.
+//
+// Note the function is only implemented on the Windows platform.
+_LIBCPP_EXPORTED_FROM_ABI void __write_to_windows_console(FILE* __stream, wstring_view __view);
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+#endif // _WIN32
+
 #if _LIBCPP_STD_VER >= 23
 
 #  ifndef _LIBCPP_HAS_NO_UNICODE
 // This is the code to transcode UTF-8 to UTF-16. This is used on
 // Windows for the native Unicode API. The code is modeled to make it
 // easier to extend to
 //
 //  P2728R0 Unicode in the Library, Part 1: UTF Transcoding
#      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
     || same_as<_Tp, wchar_t>
 #      endif
     ;
 template <class _Tp>
 concept __utf32_code_unit = same_as<_Tp, char32_t>;
 #    else // _LIBCPP_SHORT_WCHAR
 template <class _Tp>
 concept __utf16_code_unit = same_as<_Tp, char16_t>;
 template <class _Tp>
 concept __utf32_code_unit =
     same_as<_Tp, char32_t>
 #      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
     || same_as<_Tp, wchar_t>
 #      endif
     ;
 #    endif // _LIBCPP_SHORT_WCHAR
 
 // Pass by reference since an output_iterator may not be copyable.
 template <class _OutIt>
 _LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt&, char32_t) = delete;
 
 template <class _OutIt>
   requires __utf16_code_unit<iter_value_t<_OutIt>>
 _LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
-  _LIBCPP_ASSERT(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-16");
+  _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-16");
 
   if (__value < 0x10000) {
     *__out_it++ = __value;
     return;
   }
 
   __value -= 0x10000;
   *__out_it++ = 0xd800 + (__value >> 10);
   *__out_it++ = 0xdc00 + (__value & 0x3FF);
 }
 
 template <class _OutIt>
   requires __utf32_code_unit<iter_value_t<_OutIt>>
 _LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
-  _LIBCPP_ASSERT(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-32");
+  _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-32");
   *__out_it++ = __value;
 }
 
 template <class _OutIt, input_iterator _InIt>
   requires output_iterator<_OutIt, const iter_value_t<_OutIt>&> && (!same_as<iter_value_t<_OutIt>, iter_value_t<_InIt>>)
 _LIBCPP_HIDE_FROM_ABI constexpr _OutIt __transcode(_InIt __first, _InIt __last, _OutIt __out_it) {
   // The __code_point_view has a basic_string_view interface.
   // When transcoding becomes part of the standard we probably want to
   // look at smarter algorithms.
   // For example, when processing a code point that is encoded in
   // 1 to 3 code units in UTF-8, the result will always be encoded
   // in 1 code unit in UTF-16 (code points that require 4 code
   // units in UTF-8 will require 2 code units in UTF-16).
   //
   // Note if P2728 is accepted types like int may become valid. In that case
   // the __code_point_view should use a span. Libc++ will remove support for
   // char_traits<int>.
+
+  // TODO PRINT Validate with clang-tidy
+  // NOLINTNEXTLINE(bugprone-dangling-handle)
   basic_string_view<iter_value_t<_InIt>> __data{__first, __last};
   __code_point_view<iter_value_t<_InIt>> __view{__data.begin(), __data.end()};
   while (!__view.__at_end())
     __unicode::__encode(__out_it, __view.__consume().__code_point);
   return __out_it;
 }
 
 } // namespace __unicode
 
 #  endif //  _LIBCPP_HAS_NO_UNICODE
 
+namespace __print {
+
+// [print.fun]/2
+//   Effects: If the ordinary literal encoding ([lex.charset]) is UTF-8, equivalent to:
+//     vprint_unicode(stream, fmt.str, make_format_args(args...));
+//   Otherwise, equivalent to:
+//     vprint_nonunicode(stream, fmt.str, make_format_args(args...));
+//
+// Based on the compiler and its compilation flags this value is or is
+// not true. As mentioned in P2093R14 this only affects Windows. The
+// test below could also be done for
+// - GCC using __GNUC_EXECUTION_CHARSET_NAME
+//   https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+// - Clang using __clang_literal_encoding__
+//   https://clang.llvm.org/docs/LanguageExtensions.html#builtin-macros
+//   (note at the time of writing Clang is hard-coded to UTF-8.)
+//
+
+#  ifdef _LIBCPP_HAS_NO_UNICODE
+inline constexpr bool __use_unicode = false;
+#  elif defined(_MSVC_EXECUTION_CHARACTER_SET)
+// This is the same test MSVC STL uses in their implementation of <print>
+// See: https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
+inline constexpr bool __use_unicode = _MSVC_EXECUTION_CHARACTER_SET == 65001;
+#  else
+inline constexpr bool __use_unicode = true;
+#  endif
+
+_LIBCPP_HIDE_FROM_ABI inline bool __is_terminal(FILE* __stream) {
+#  ifdef _WIN32
+  return std::__is_windows_terminal(__stream);
+#  elif __has_include(<unistd.h>)
+  return isatty(fileno(__stream));
+#  else
+#    error "Provide a way to determine whether a FILE* is a terminal"
+#  endif
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl) {
+  _LIBCPP_ASSERT_UNCATEGORIZED(__stream, "__stream is a valid pointer to an output C stream");
+  string __str = std::vformat(__fmt, __args);
+  if (__write_nl)
+    __str.push_back('\n');
+
+  size_t __size = fwrite(__str.data(), 1, __str.size(), __stream);
+  if (__size < __str.size()) {
+    if (std::feof(__stream))
+      std::__throw_system_error(EIO, "EOF while writing the formatted output");
+    std::__throw_system_error(std::ferror(__stream), "failed to write formatted output");
+  }
+}
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+
+// Note these helper functions are mainly used to aid testing.
+// On POSIX systems and Windows the output is no longer considered a
+// terminal when the output is redirected. Typically during testing the
+// output is redirected to be able to capture it. This makes it hard to
+// test this code path.
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_unicode_posix(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
+  // TODO PRINT Should flush errors throw too?
+  if (__is_terminal)
+    std::fflush(__stream);
+
+  __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);
+}
+
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_unicode_windows(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
+  if (!__is_terminal)
+    return __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);
+
+  // TODO PRINT Should flush errors throw too?
+  std::fflush(__stream);
+
+  string __str = std::vformat(__fmt, __args);
+  // UTF-16 uses the same number or less code units than UTF-8.
+  // However the size of the code unit is 16 bits instead of 8 bits.
+  //
+  // The buffer uses the worst-case estimate and should never resize.
+  // However when the string is large this could lead to OOM. Using a
+  // smaller size might work, but since the buffer uses a grow factor
+  // the final size might be larger when the estimate is wrong.
+  //
+  // TODO PRINT profile and improve the speed of this code.
+  __format::__retarget_buffer<wchar_t> __buffer{__str.size()};
+  __unicode::__transcode(__str.begin(), __str.end(), __buffer.__make_output_iterator());
+  if (__write_nl)
+    __buffer.push_back(L'\n');
+
+  [[maybe_unused]] wstring_view __view = __buffer.__view();
+
+  // The macro _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION is used to change
+  // the behavior in the test. This is not part of the public API.
+#      ifdef _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION
+  _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION(__stream, __view);
+#      elif defined(_WIN32)
+  std::__write_to_windows_console(__stream, __view);
+#      else
+  std::__throw_runtime_error("No defintion of _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION and "
+                             "__write_to_windows_console is not available.");
+#      endif
+}
+#    endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_unicode([[maybe_unused]] FILE* __stream,
+                 [[maybe_unused]] string_view __fmt,
+                 [[maybe_unused]] format_args __args,
+                 [[maybe_unused]] bool __write_nl) {
+  _LIBCPP_ASSERT_UNCATEGORIZED(__stream, "__stream is a valid pointer to an output C stream");
+
+  // [print.fun]
+  //   7 - Effects: If stream refers to a terminal capable of displaying
+  //       Unicode, writes out to the terminal using the native Unicode
+  //       API; if out contains invalid code units, the behavior is
+  //       undefined and implementations are encouraged to diagnose it.
+  //       Otherwise writes out to stream unchanged. If the native
+  //       Unicode API is used, the function flushes stream before
+  //       writing out.
+  //   8 - Throws: Any exception thrown by the call to vformat
+  //       ([format.err.report]). system_error if writing to the terminal
+  //       or stream fails. May throw bad_alloc.
+  //   9 - Recommended practice: If invoking the native Unicode API
+  //       requires transcoding, implementations should substitute
+  //       invalid code units with U+FFFD replacement character per the
+  //       Unicode Standard, Chapter 3.9 U+FFFD Substitution in
+  //       Conversion.
+
+  // On non-Windows platforms the Unicode API is the normal file I/O API
+  // so there the call can be forwarded to the non_unicode API. On
+  // Windows there is a different API. This API requires transcoding.
+
+#    ifndef _WIN32
+  __print::__vprint_unicode_posix(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
+#    elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+  __print::__vprint_unicode_windows(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
+#    else
+#      error "Windows builds with wchar_t disabled are not supported."
+#    endif
+}
+
+#  endif // _LIBCPP_HAS_NO_UNICODE
+
+} // namespace __print
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void print(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  if constexpr (__print::__use_unicode)
+    __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
+  else
+    __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  // Note the wording in the Standard is inefficient. The output of
+  // std::format is a std::string which is then copied. This solution
+  // just appends a newline at the end of the output.
+  if constexpr (__print::__use_unicode)
+    __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
+  else
+    __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(FILE* __stream, string_view __fmt, format_args __args) {
+  __print::__vprint_unicode(__stream, __fmt, __args, false);
+}
+#  endif // _LIBCPP_HAS_NO_UNICODE
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args) {
+  __print::__vprint_nonunicode(__stream, __fmt, __args, false);
+}
+
 #endif // _LIBCPP_STD_VER >= 23
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_PRINT

libcxx/include/version

__cpp_lib_nonmember_container_access                    201411L <array> <deque> <forward_list>
                                                                 <unordered_map> <unordered_set> <vector>
 __cpp_lib_not_fn                                        201603L <functional>
 __cpp_lib_null_iterators                                201304L <iterator>
 __cpp_lib_optional                                      202110L <optional>
                                                         201606L // C++17
 __cpp_lib_out_ptr                                       202106L <memory>
 __cpp_lib_parallel_algorithm                            201603L <algorithm> <numeric>
 __cpp_lib_polymorphic_allocator                         201902L <memory_resource>
+__cpp_lib_print                                         202207L <ostream> <print>
 __cpp_lib_quoted_string_io                              201304L <iomanip>
 __cpp_lib_ranges                                        202207L <algorithm> <functional> <iterator>
                                                                 <memory> <ranges>
 __cpp_lib_ranges_as_rvalue                              202207L <ranges>
 __cpp_lib_ranges_chunk                                  202202L <ranges>
 __cpp_lib_ranges_chunk_by                               202202L <ranges>
 __cpp_lib_ranges_iota                                   202202L <numeric>
 __cpp_lib_ranges_join_with                              202202L <ranges>

 # define __cpp_lib_forward_like                         202207L
 # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_mdspan                               202207L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
+// # define __cpp_lib_print                                202207L
 # define __cpp_lib_ranges_as_rvalue                     202207L
 // # define __cpp_lib_ranges_chunk                         202202L
 // # define __cpp_lib_ranges_chunk_by                      202202L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
 // # define __cpp_lib_ranges_to_container                  202202L

libcxx/modules/std/print.cppm

 // -*- 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 <print>
 
 export module std:print;
 export namespace std {
-#if 0
   // [print.fun], print functions
   using std::print;
   using std::println;
 
   using std::vprint_nonunicode;
   using std::vprint_unicode;
-#endif
 } // namespace std

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   legacy_pointer_safety.cpp
   memory.cpp
   memory_resource.cpp
   mutex.cpp
   mutex_destructor.cpp
   new_handler.cpp
   new_helpers.cpp
   optional.cpp
+  print.cpp
   random_shuffle.cpp
   ryu/d2fixed.cpp
   ryu/d2s.cpp
   ryu/f2s.cpp
   shared_mutex.cpp
   stdexcept.cpp
   string.cpp
   support/runtime/exception_fallback.ipp

libcxx/src/print.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <cstdlib>
+#include <print>
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <io.h>
+#  include <windows.h>
+
+#  include <__system_error/system_error.h>
+
+#  include "filesystem/error.h"
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef _WIN32
+_LIBCPP_EXPORTED_FROM_ABI bool __is_windows_terminal(FILE* __stream) {
+  // Note the Standard does this in one call, but it's unclear whether
+  // an invalid handle is allowed when calling GetConsoleMode.
+  //
+  // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/get-osfhandle?view=msvc-170
+  // https://learn.microsoft.com/en-us/windows/console/getconsolemode
+  intptr_t __handle = _get_osfhandle(fileno(__stream));
+  if (__handle == -1)
+    return false;
+
+  unsigned long __mode;
+  return GetConsoleMode(reinterpret_cast<void*>(__handle), &__mode);
+}
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+_LIBCPP_EXPORTED_FROM_ABI void
+__write_to_windows_console([[maybe_unused]] FILE* __stream, [[maybe_unused]] wstring_view __view) {
+  // https://learn.microsoft.com/en-us/windows/console/writeconsole
+  if (WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fileno(__stream))), // clang-format aid
+                    __view.data(),
+                    __view.size(),
+                    nullptr,
+                    nullptr) == 0) {
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    // There is no __throw_system_error overload that takes an error code.
+    throw system_error{filesystem::detail::make_windows_error(GetLastError()), "failed to write formatted output"};
+#    else  // _LIBCPP_HAS_NO_EXCEPTIONS
+    std::abort();
+#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
+}
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+#endif // _WIN32
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_posix.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// REQUIRES: has-unix-headers
+
+// <print>
+
+// Tests the implementation of
+//   void __print::__vprint_unicode_posix(FILE* __stream, string_view __fmt,
+//                                        format_args __args, bool __write_nl,
+//                                        bool __is_terminal);
+//
+// In the library when the stdout is redirected to a file it is no
+// longer considered a terminal and the special terminal handling is no
+// longer executed. By testing this function we can "force" emulate a
+// terminal.
+// Note __write_nl is tested by the public API.
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstdio>
+#include <print>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  std::array<char, 100> buffer;
+  std::ranges::fill(buffer, '*');
+
+  FILE* file = fmemopen(buffer.data(), buffer.size(), "wb");
+  assert(file);
+
+  // Test the file is buffered.
+  std::fprintf(file, "Hello");
+  assert(std::ftell(file) == 5);
+#if defined(TEST_HAS_GLIBC) &&                                                                                         \
+    !(__has_feature(address_sanitizer) || __has_feature(thread_sanitizer) || __has_feature(memory_sanitizer))
+  assert(std::ranges::all_of(buffer, [](char c) { return c == '*'; }));
+#endif
+
+  // Test writing to a "non-terminal" stream does not flush.
+  std::__print::__vprint_unicode_posix(file, " world", std::make_format_args(), false, false);
+  assert(std::ftell(file) == 11);
+#if defined(TEST_HAS_GLIBC) &&                                                                                         \
+    !(__has_feature(address_sanitizer) || __has_feature(thread_sanitizer) || __has_feature(memory_sanitizer))
+  assert(std::ranges::all_of(buffer, [](char c) { return c == '*'; }));
+#endif
+
+  // Test writing to a "terminal" stream flushes before writing.
+  std::__print::__vprint_unicode_posix(file, "!", std::make_format_args(), false, true);
+  assert(std::ftell(file) == 12);
+  assert(std::string_view(buffer.data(), buffer.data() + 11) == "Hello world");
+#if defined(TEST_HAS_GLIBC)
+  // glibc does not flush after a write.
+  assert(buffer[11] != '!');
+#endif
+
+  // Test everything is written when closing the stream.
+  std::fclose(file);
+  assert(std::string_view(buffer.data(), buffer.data() + 12) == "Hello world!");
+
+  return 0;
+}

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_windows.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: no-wide-characters
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// Clang modules do not work with the definiton of _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION
+// XFAIL: modules-build
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// Tests the implementation of
+//   void __print::__vprint_unicode_windows(FILE* __stream, string_view __fmt,
+//                                          format_args __args, bool __write_nl,
+//                                          bool __is_terminal);
+//
+// In the library when the stdout is redirected to a file it is no
+// longer considered a terminal and the special terminal handling is no
+// longer executed. By testing this function we can "force" emulate a
+// terminal.
+// Note __write_nl is tested by the public API.
+
+#include <string_view>
+#include <cstdio>
+#include <algorithm>
+#include <cassert>
+
+void write_to_console(FILE*, std::wstring_view data);
+#define _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION ::write_to_console
+#include <print>
+
+#include "test_macros.h"
+#include "filesystem_test_helper.h"
+#include "make_string.h"
+
+TEST_GCC_DIAGNOSTIC_IGNORED("-Wuse-after-free")
+
+#define SV(S) MAKE_STRING_VIEW(wchar_t, S)
+
+bool calling               = false;
+std::wstring_view expected = L" world";
+
+void write_to_console(FILE*, std::wstring_view data) {
+  assert(calling);
+  assert(data == expected);
+}
+
+scoped_test_env env;
+std::string filename = env.create_file("output.txt");
+
+static void test_basics() {
+  FILE* file = std::fopen(filename.c_str(), "wb");
+  assert(file);
+
+  // Test writing to a "non-terminal" stream does not call WriteConsoleW.
+  std::__print::__vprint_unicode_windows(file, "Hello", std::make_format_args(), false, false);
+  assert(std::ftell(file) == 5);
+
+  // It's not possible to reliably test whether writing to a "terminal" stream
+  // flushes before writing. Testing flushing a closed stream worked on some
+  // platforms, but was unreliable.
+  calling = true;
+  std::__print::__vprint_unicode_windows(file, " world", std::make_format_args(), false, true);
+}
+
+// When the output is a file the data is written as-is.
+// When the output is a "terminal" invalid UTF-8 input is flagged.
+static void test(std::wstring_view output, std::string_view input) {
+  // *** File ***
+  FILE* file = std::fopen(filename.c_str(), "wb");
+  assert(file);
+
+  std::__print::__vprint_unicode_windows(file, input, std::make_format_args(), false, false);
+  assert(std::ftell(file) == static_cast<long>(input.size()));
+  std::fclose(file);
+
+  file = std::fopen(filename.c_str(), "rb");
+  assert(file);
+
+  std::vector<char> buffer(input.size());
+  size_t read = fread(buffer.data(), 1, buffer.size(), file);
+  assert(read == input.size());
+  assert(input == std::string_view(buffer.begin(), buffer.end()));
+  std::fclose(file);
+
+  // *** Terminal ***
+  expected = output;
+  std::__print::__vprint_unicode_windows(file, input, std::make_format_args(), false, true);
+}
+
+static void test() {
+  // *** Test valid UTF-8 ***
+#define TEST(S) test(SV(S), S)
+  TEST("hello world");
+
+  // copied from benchmarks/std_format_spec_string_unicode.bench.cpp
+  TEST("Lorem ipsum dolor sit amet, ne sensibus evertitur aliquando his. Iuvaret fabulas qui ex.");
+  TEST("Lōrem ipsūm dolor sīt æmeÞ, ea vel nostrud feuġǣit, muciūs tēmporiȝusrefērrēnÞur no mel.");
+  TEST("Лорем ипсум долор сит амет, еу диам тамяуам принципес вис, еяуидем цонцептам диспутандо");
+  TEST("入ト年媛ろ舗学ラロ準募ケカ社金スノ屋検れう策他セヲシ引口ぎ集7独ぱクふ出車ぽでぱ円輪ルノ受打わ。");
+  TEST("\U0001f636\u200d\U0001f32b\ufe0f");
+#undef TEST
+
+  // *** Test invalid utf-8 ***
+  test(SV("\ufffd"), "\xc3");
+  test(SV("\ufffd("), "\xc3\x28");
+
+  // surrogate range
+  test(SV("\ufffd"), "\xed\xa0\x80"); // U+D800
+  test(SV("\ufffd"), "\xed\xaf\xbf"); // U+DBFF
+  test(SV("\ufffd"), "\xed\xbf\x80"); // U+DC00
+  test(SV("\ufffd"), "\xed\xbf\xbf"); // U+DFFF
+
+  // beyond valid values
+  test(SV("\ufffd"), "\xf4\x90\x80\x80"); // U+110000
+  test(SV("\ufffd"), "\xf4\xbf\xbf\xbf"); // U+11FFFF
+
+  // Validates  http://unicode.org/review/pr-121.html option 3.
+  test(SV("\u0061\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\u0062"), "\x61\xf1\x80\x80\xe1\x80\xc2\x62");
+}
+
+int main(int, char**) {
+  test_basics();
+  test();
+}

libcxx/test/libcxx/transitive_includes/cxx03.csv

 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
+print array
+print cerrno
+print cmath
 print cstddef
 print cstdint
+print cstdio
+print cstdlib
 print initializer_list
 print limits
+print locale
+print new
+print optional
+print stdexcept
+print string
 print string_view
+print tuple
 print version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx11.csv

 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
+print array
+print cerrno
+print cmath
 print cstddef
 print cstdint
+print cstdio
+print cstdlib
 print initializer_list
 print limits
+print locale
+print new
+print optional
+print stdexcept
+print string
 print string_view
+print tuple
 print version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx14.csv

 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
+print array
+print cerrno
+print cmath
 print cstddef
 print cstdint
+print cstdio
+print cstdlib
 print initializer_list
 print limits
+print locale
+print new
+print optional
+print stdexcept
+print string
 print string_view
+print tuple
 print version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx17.csv

 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
+print array
+print cerrno
+print cmath
 print cstddef
 print cstdint
+print cstdio
+print cstdlib
 print initializer_list
 print limits
+print locale
+print new
+print optional
+print stdexcept
+print string
 print string_view
+print tuple
 print version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx20.csv

 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
+print array
+print cerrno
+print cmath
 print cstddef
 print cstdint
+print cstdio
+print cstdlib
 print initializer_list
 print limits
+print locale
+print new
+print optional
+print stdexcept
+print string
 print string_view
+print tuple
 print version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx23.csv

 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream string
 ostream typeinfo
 ostream version
+print array
+print cerrno
+print cmath
 print cstddef
 print cstdint
+print cstdio
+print cstdlib
 print initializer_list
 print limits
+print locale
+print new
+print optional
+print stdexcept
+print string
 print string_view
+print tuple
 print version
 queue compare
 queue cstddef
 queue cstdint
 queue deque
 queue initializer_list
 queue limits
 queue new

libcxx/test/libcxx/transitive_includes/cxx26.csv

 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
 ostream string
 ostream typeinfo
 ostream version
+print array
+print cerrno
+print cmath
 print cstddef
 print cstdint
+print cstdio
+print cstdlib
 print initializer_list
 print limits
+print locale
+print new
+print optional
+print stdexcept
+print string
 print string_view
+print tuple
 print version
 queue compare
 queue cstddef
 queue cstdint
 queue deque
 queue initializer_list
 queue limits
 queue new

libcxx/test/std/input.output/iostream.format/print.fun/no_file_description.pass.cpp

+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: msvc, target={{.+}}-windows-gnu
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// The FILE returned by fmemopen does not have file descriptor.
+// This means the test could fail when the implementation uses a
+// function that requires a file descriptor, for example write.
+//
+// This tests all print functions which takes a FILE* as argument.
+
+// template<class... Args>
+//   void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+// template<class... Args>
+//   void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+// void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+// void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+
+#include <array>
+#include <cstdio>
+#include <cassert>
+#include <print>
+
+static void test_print() {
+  std::array<char, 100> buffer{0};
+
+  FILE* file = fmemopen(buffer.data(), buffer.size(), "wb");
+  assert(file);
+
+  std::print(file, "hello world{}", '!');
+  long pos = std::ftell(file);
+  std::fclose(file);
+
+  assert(pos > 0);
+  assert(std::string_view(buffer.data(), pos) == "hello world!");
+}
+
+static void test_println() {
+  std::array<char, 100> buffer{0};
+
+  FILE* file = fmemopen(buffer.data(), buffer.size(), "wb");
+  assert(file);
+
+  std::println(file, "hello world{}", '!');
+  long pos = std::ftell(file);
+  std::fclose(file);
+
+  assert(pos > 0);
+  assert(std::string_view(buffer.data(), pos) == "hello world!\n");
+}
+
+static void test_vprint_unicode() {
+  std::array<char, 100> buffer{0};
+
+  FILE* file = fmemopen(buffer.data(), buffer.size(), "wb");
+  assert(file);
+
+  std::vprint_unicode(file, "hello world{}", std::make_format_args('!'));
+  long pos = std::ftell(file);
+  std::fclose(file);
+
+  assert(pos > 0);
+  assert(std::string_view(buffer.data(), pos) == "hello world!");
+}
+
+static void test_vprint_nonunicode() {
+  std::array<char, 100> buffer{0};
+
+  FILE* file = fmemopen(buffer.data(), buffer.size(), "wb");
+  assert(file);
+
+  std::vprint_nonunicode(file, "hello world{}", std::make_format_args('!'));
+  long pos = std::ftell(file);
+  std::fclose(file);
+
+  assert(pos > 0);
+  assert(std::string_view(buffer.data(), pos) == "hello world!");
+}
+
+int main(int, char**) {
+  test_print();
+  test_println();
+  test_vprint_unicode();
+  test_vprint_nonunicode();
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/print.fun/print.file.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// template<class... Args>
+//   void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+
+// In the library when the stdout is redirected to a file it is no
+// longer considered a terminal and the special terminal handling is no
+// longer executed. There are tests in
+//   libcxx/test/libcxx/input.output/iostream.format/print.fun/
+// to validate that behaviour
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdio>
+#include <fstream>
+#include <iterator>
+#include <print>
+#include <string_view>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "print_tests.h"
+#include "test_format_string.h"
+#include "test_macros.h"
+
+scoped_test_env env;
+std::string filename = env.create_file("output.txt");
+
+auto test_file = []<class... Args>(std::string_view expected, test_format_string<char, Args...> fmt, Args&&... args) {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  std::print(file, fmt, std::forward<Args>(args)...);
+  std::fclose(file);
+
+  std::ifstream stream{filename.c_str(), std::ios_base::in | std::ios_base::binary};
+  std::string out(std::istreambuf_iterator<char>{stream}, {});
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>(std::string_view, std::string_view, Args&&...) {
+  // After P2216 most exceptions thrown by std::format become ill-formed.
+  // Therefore this tests does nothing.
+  // A basic ill-formed test is done in format.verify.cpp
+  // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
+};
+
+// Glibc fails writing to a wide stream.
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+static void test_wide_stream() {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  int mode = std::fwide(file, 1);
+  assert(mode > 0);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+        [[maybe_unused]] std::string_view what{"failed to write formatted output"};
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::print(file, "hello"));
+}
+#endif // defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+
+static void test_read_only() {
+  FILE* file = fopen(filename.c_str(), "r");
+  assert(file);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+#ifdef _AIX
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Broken pipe"};
+#else
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Operation not permitted"};
+#endif
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::print(file, "hello"));
+}
+
+static void test_new_line() {
+  // Text does newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "w");
+    assert(file);
+
+    std::print(file, "\n");
+#ifndef _WIN32
+    assert(std::ftell(file) == 1);
+#else
+    assert(std::ftell(file) == 2);
+#endif
+  }
+  // Binary no newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "wb");
+    assert(file);
+
+    std::print(file, "\n");
+    assert(std::ftell(file) == 1);
+  }
+}
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+  test_wide_stream();
+#endif
+  test_read_only();
+  test_new_line();
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/print.fun/print_tests.h

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_STD_INPUT_OUTPUT_IOSTREAM_FORMAT_PRINT_FUN_PRINT_TESTS_H
+#define TEST_STD_INPUT_OUTPUT_IOSTREAM_FORMAT_PRINT_FUN_PRINT_TESTS_H
+
+template <class TestFunction, class ExceptionTest>
+void print_tests(TestFunction check, ExceptionTest check_exception) {
+  // *** Test escaping  ***
+
+  check("{", "{{");
+  check("{:^}", "{{:^}}");
+  check("{: ^}", "{{:{}^}}", ' ');
+  check("{:{}^}", "{{:{{}}^}}");
+  check("{:{ }^}", "{{:{{{}}}^}}", ' ');
+
+  // *** Test argument ID ***
+  check("hello false true", "hello {0:} {1:}", false, true);
+  check("hello true false", "hello {1:} {0:}", false, true);
+
+  // *** Test many arguments ***
+  check(
+      "1234567890\t1234567890",
+      "{}{}{}{}{}{}{}{}{}{}\t{}{}{}{}{}{}{}{}{}{}",
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      0);
+
+  // *** Test embedded NUL character ***
+  using namespace std::literals;
+  check("hello\0world"sv, "hello{}{}", '\0', "world");
+  check("hello\0world"sv, "hello\0{}"sv, "world");
+  check("hello\0world"sv, "hello{}", "\0world"sv);
+
+  // *** Test Unicode ***
+  // 2-byte code points
+  check("\u00a1"sv, "{}"sv, "\u00a1");  // INVERTED EXCLAMATION MARK
+  check("\u07ff"sv, "{:}"sv, "\u07ff"); // NKO TAMAN SIGN
+
+  // 3-byte code points
+  check("\u0800"sv, "{}"sv, "\u0800"); // SAMARITAN LETTER ALAF
+  check("\ufffd"sv, "{}"sv, "\ufffd"); // REPLACEMENT CHARACTER
+
+  // 4-byte code points
+  check("\U00010000"sv, "{}"sv, "\U00010000"); // LINEAR B SYLLABLE B008 A
+  check("\U0010FFFF"sv, "{}"sv, "\U0010FFFF"); // Undefined Character
+
+  // *** Test invalid format strings ***
+  check_exception("The format string terminates at a '{'", "{");
+  check_exception("The replacement field misses a terminating '}'", "{:", 42);
+
+  check_exception("The format string contains an invalid escape sequence", "}");
+  check_exception("The format string contains an invalid escape sequence", "{:}-}", 42);
+
+  check_exception("The format string contains an invalid escape sequence", "} ");
+  check_exception("The arg-id of the format-spec starts with an invalid character", "{-", 42);
+  check_exception("Argument index out of bounds", "hello {}");
+  check_exception("Argument index out of bounds", "hello {0}");
+  check_exception("Argument index out of bounds", "hello {1}", 42);
+}
+
+#endif // TEST_STD_INPUT_OUTPUT_IOSTREAM_FORMAT_PRINT_FUN_PRINT_TESTS_H

libcxx/test/std/input.output/iostream.format/print.fun/println.file.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// template<class... Args>
+//   void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+
+// In the library when the stdout is redirected to a file it is no
+// longer considered a terminal and the special terminal handling is no
+// longer executed. There are tests in
+//   libcxx/test/libcxx/input.output/iostream.format/print.fun/
+// to validate that behaviour
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdio>
+#include <fstream>
+#include <fstream>
+#include <iterator>
+#include <print>
+#include <string_view>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "print_tests.h"
+#include "test_format_string.h"
+#include "test_macros.h"
+
+scoped_test_env env;
+std::string filename = env.create_file("output.txt");
+
+auto test_file = []<class... Args>(std::string_view e, test_format_string<char, Args...> fmt, Args&&... args) {
+  std::string expected = std::string{e} + '\n';
+
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  std::println(file, fmt, std::forward<Args>(args)...);
+  std::fclose(file);
+
+  std::ifstream stream{filename.c_str(), std::ios_base::in | std::ios_base::binary};
+  std::string out(std::istreambuf_iterator<char>{stream}, {});
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt.get(), "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>(std::string_view, std::string_view, Args&&...) {
+  // After P2216 most exceptions thrown by std::format become ill-formed.
+  // Therefore this tests does nothing.
+  // A basic ill-formed test is done in format.verify.cpp
+  // The exceptions are tested by other functions that don't use the basic-format-string as fmt argument.
+};
+
+// Glibc fails writing to a wide stream.
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+static void test_wide_stream() {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  int mode = std::fwide(file, 1);
+  assert(mode > 0);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+        [[maybe_unused]] std::string_view what{"failed to write formatted output"};
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::println(file, "hello"));
+}
+#endif // defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+
+static void test_read_only() {
+  FILE* file = fopen(filename.c_str(), "r");
+  assert(file);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+#ifdef _AIX
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Broken pipe"};
+#else
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Operation not permitted"};
+#endif
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::println(file, "hello"));
+}
+
+static void test_new_line() {
+  // Text does newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "w");
+    assert(file);
+
+    std::println(file, "");
+#ifndef _WIN32
+    assert(std::ftell(file) == 1);
+#else
+    assert(std::ftell(file) == 2);
+#endif
+  }
+  // Binary no newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "wb");
+    assert(file);
+
+    std::println(file, "");
+    assert(std::ftell(file) == 1);
+  }
+}
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+  test_wide_stream();
+#endif
+  test_read_only();
+  test_new_line();
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/print.fun/vprint_nonunicode.file.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdio>
+#include <fstream>
+#include <iterator>
+#include <print>
+#include <string_view>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "print_tests.h"
+#include "test_macros.h"
+
+scoped_test_env env;
+std::string filename = env.create_file("output.txt");
+
+auto test_file = []<class... Args>(std::string_view expected, std::string_view fmt, Args&&... args) {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  std::vprint_nonunicode(file, fmt, std::make_format_args(args...));
+  std::fclose(file);
+
+  std::ifstream stream{filename.c_str(), std::ios_base::in | std::ios_base::binary};
+  std::string out(std::istreambuf_iterator<char>{stream}, {});
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>([[maybe_unused]] std::string_view what,
+                                        [[maybe_unused]] std::string_view fmt,
+                                        [[maybe_unused]] Args&&... args) {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::format_error,
+      [&]([[maybe_unused]] const std::format_error& e) {
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED(
+                "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::vprint_nonunicode(file, fmt, std::make_format_args(args...)));
+
+  fclose(file);
+};
+
+// Glibc fails writing to a wide stream.
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+static void test_wide_stream() {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  int mode = std::fwide(file, 1);
+  assert(mode > 0);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+        [[maybe_unused]] std::string_view what{"failed to write formatted output"};
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::vprint_nonunicode(file, "hello", std::make_format_args()));
+}
+#endif // defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+
+static void test_read_only() {
+  FILE* file = fopen(filename.c_str(), "r");
+  assert(file);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+#ifdef _AIX
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Broken pipe"};
+#else
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Operation not permitted"};
+#endif
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::vprint_nonunicode(file, "hello", std::make_format_args()));
+}
+
+static void test_new_line() {
+  // Text does newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "w");
+    assert(file);
+
+    std::vprint_nonunicode(file, "\n", std::make_format_args());
+#ifndef _WIN32
+    assert(std::ftell(file) == 1);
+#else
+    assert(std::ftell(file) == 2);
+#endif
+  }
+  // Binary no newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "wb");
+    assert(file);
+
+    std::vprint_nonunicode(file, "\n", std::make_format_args());
+    assert(std::ftell(file) == 1);
+  }
+}
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+  test_wide_stream();
+#endif
+  test_read_only();
+  test_new_line();
+
+  return 0;
+}

libcxx/test/std/input.output/iostream.format/print.fun/vprint_unicode.file.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: libcpp-has-no-unicode
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// XFAIL: availability-fp_to_chars-missing
+
+// <print>
+
+// void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+
+// In the library when the stdout is redirected to a file it is no
+// longer considered a terminal and the special terminal handling is no
+// longer executed. There are tests in
+//   libcxx/test/libcxx/input.output/iostream.format/print.fun/
+// to validate that behaviour
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <cstdio>
+#include <fstream>
+#include <iterator>
+#include <print>
+#include <string_view>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "print_tests.h"
+#include "test_macros.h"
+
+scoped_test_env env;
+std::string filename = env.create_file("output.txt");
+
+auto test_file = []<class... Args>(std::string_view expected, std::string_view fmt, Args&&... args) {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  std::vprint_unicode(file, fmt, std::make_format_args(args...));
+  std::fclose(file);
+
+  std::ifstream stream{filename.c_str(), std::ios_base::in | std::ios_base::binary};
+  std::string out(std::istreambuf_iterator<char>{stream}, {});
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+};
+
+auto test_exception = []<class... Args>([[maybe_unused]] std::string_view what,
+                                        [[maybe_unused]] std::string_view fmt,
+                                        [[maybe_unused]] Args&&... args) {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::format_error,
+      [&]([[maybe_unused]] const std::format_error& e) {
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED(
+                "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::vprint_unicode(file, fmt, std::make_format_args(args...)));
+
+  fclose(file);
+};
+
+// Glibc fails writing to a wide stream.
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+static void test_wide_stream() {
+  FILE* file = fopen(filename.c_str(), "wb");
+  assert(file);
+
+  int mode = std::fwide(file, 1);
+  assert(mode > 0);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+        [[maybe_unused]] std::string_view what{"failed to write formatted output"};
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::vprint_unicode(file, "hello", std::make_format_args()));
+}
+#endif // defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+
+static void test_read_only() {
+  FILE* file = fopen(filename.c_str(), "r");
+  assert(file);
+
+  TEST_VALIDATE_EXCEPTION(
+      std::system_error,
+      [&]([[maybe_unused]] const std::system_error& e) {
+#ifdef _AIX
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Broken pipe"};
+#else
+        [[maybe_unused]] std::string_view what{"failed to write formatted output: Operation not permitted"};
+#endif
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      std::vprint_unicode(file, "hello", std::make_format_args()));
+}
+
+static void test_new_line() {
+  // Text does newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "w");
+    assert(file);
+
+    std::vprint_unicode(file, "\n", std::make_format_args());
+#ifndef _WIN32
+    assert(std::ftell(file) == 1);
+#else
+    assert(std::ftell(file) == 2);
+#endif
+  }
+  // Binary no newline translation.
+  {
+    FILE* file = fopen(filename.c_str(), "wb");
+    assert(file);
+
+    std::vprint_unicode(file, "\n", std::make_format_args());
+    assert(std::ftell(file) == 1);
+  }
+}
+
+int main(int, char**) {
+  print_tests(test_file, test_exception);
+
+#if defined(TEST_HAS_GLIBC) && !defined(TEST_HAS_NO_WIDE_CHARACTERS)
+  test_wide_stream();
+#endif
+  test_read_only();
+  test_new_line();
+
+  return 0;
+}

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

 // UNSUPPORTED: no-localization
 
 // <ostream>
 
 // Test the feature test macros defined by <ostream>
 
 /*  Constant             Value
     __cpp_lib_char8_t    201907L [C++20]
+    __cpp_lib_print      202207L [C++23]
 */
 
 #include <ostream>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 #elif TEST_STD_VER == 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
 #   if __cpp_lib_char8_t != 201907L
 #     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when the requirement 'defined(__cpp_char8_t)' is not met!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 #elif TEST_STD_VER == 23
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++23"
 #   endif
 #   if __cpp_lib_char8_t != 201907L
 #     error "__cpp_lib_char8_t should have the value 201907L in c++23"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when the requirement 'defined(__cpp_char8_t)' is not met!"
 #   endif
 # endif
 
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_print
+#     error "__cpp_lib_print should be defined in c++23"
+#   endif
+#   if __cpp_lib_print != 202207L
+#     error "__cpp_lib_print should have the value 202207L in c++23"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_print
+#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
 #elif TEST_STD_VER > 23
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++26"
 #   endif
 #   if __cpp_lib_char8_t != 201907L
 #     error "__cpp_lib_char8_t should have the value 201907L in c++26"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when the requirement 'defined(__cpp_char8_t)' is not met!"
 #   endif
 # endif
 
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_print
+#     error "__cpp_lib_print should be defined in c++26"
+#   endif
+#   if __cpp_lib_print != 202207L
+#     error "__cpp_lib_print should have the value 202207L in c++26"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_print
+#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
 #endif // TEST_STD_VER > 23
 

libcxx/test/std/language.support/support.limits/support.limits.general/print.version.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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// <print>
+
+// Test the feature test macros defined by <print>
+
+/*  Constant           Value
+    __cpp_lib_print    202207L [C++23]
+*/
+
+#include <print>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
+#elif TEST_STD_VER == 23
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_print
+#     error "__cpp_lib_print should be defined in c++23"
+#   endif
+#   if __cpp_lib_print != 202207L
+#     error "__cpp_lib_print should have the value 202207L in c++23"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_print
+#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#elif TEST_STD_VER > 23
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_print
+#     error "__cpp_lib_print should be defined in c++26"
+#   endif
+#   if __cpp_lib_print != 202207L
+#     error "__cpp_lib_print should have the value 202207L in c++26"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_print
+#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 23
+

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

/*  Constant                                         Value
     __cpp_lib_nonmember_container_access             201411L [C++17]
     __cpp_lib_not_fn                                 201603L [C++17]
     __cpp_lib_null_iterators                         201304L [C++14]
     __cpp_lib_optional                               201606L [C++17]
                                                      202110L [C++23]
     __cpp_lib_out_ptr                                202106L [C++23]
     __cpp_lib_parallel_algorithm                     201603L [C++17]
     __cpp_lib_polymorphic_allocator                  201902L [C++20]
+    __cpp_lib_print                                  202207L [C++23]
     __cpp_lib_quoted_string_io                       201304L [C++14]
     __cpp_lib_ranges                                 202207L [C++20]
     __cpp_lib_ranges_as_rvalue                       202207L [C++23]
     __cpp_lib_ranges_chunk                           202202L [C++23]
     __cpp_lib_ranges_chunk_by                        202202L [C++23]
     __cpp_lib_ranges_iota                            202202L [C++23]
     __cpp_lib_ranges_join_with                       202202L [C++23]
     __cpp_lib_ranges_slide                           202202L [C++23]

 # ifdef __cpp_lib_parallel_algorithm
 #   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_polymorphic_allocator
 #   error "__cpp_lib_polymorphic_allocator should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should not be defined before c++20"
 # endif
 

 # ifdef __cpp_lib_parallel_algorithm
 #   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_polymorphic_allocator
 #   error "__cpp_lib_polymorphic_allocator should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++14"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++14"
 # endif
 
 # ifdef __cpp_lib_ranges

 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifdef __cpp_lib_polymorphic_allocator
 #   error "__cpp_lib_polymorphic_allocator should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++17"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++17"
 # endif
 
 # ifdef __cpp_lib_ranges

 #     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_polymorphic_allocator
 #     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_print
+#   error "__cpp_lib_print should not be defined before c++23"
+# endif
+
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++20"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_ranges

 #     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++23"
 #   endif
 # else
 #   ifdef __cpp_lib_polymorphic_allocator
 #     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
 #   endif
 # endif
 
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_print
+#     error "__cpp_lib_print should be defined in c++23"
+#   endif
+#   if __cpp_lib_print != 202207L
+#     error "__cpp_lib_print should have the value 202207L in c++23"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_print
+#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++23"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges

 #     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++26"
 #   endif
 # else
 #   ifdef __cpp_lib_polymorphic_allocator
 #     error "__cpp_lib_polymorphic_allocator should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)' is not met!"
 #   endif
 # endif
 
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_print
+#     error "__cpp_lib_print should be defined in c++26"
+#   endif
+#   if __cpp_lib_print != 202207L
+#     error "__cpp_lib_print should have the value 202207L in c++26"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_print
+#     error "__cpp_lib_print should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++26"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges

libcxx/test/std/utilities/format/format.functions/fill.unicode.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-incomplete-format
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // This version runs the test when the platform has Unicode support.
 // UNSUPPORTED: libcpp-has-no-unicode
 
 // XFAIL: availability-fp_to_chars-missing
 
 // <format>

libcxx/utils/ci/run-buildbot

! grep -rn '[^ -~]' libcxx/include libcxx/src libcxx/test libcxx/benchmarks \
            --exclude 'format_tests.h' \
            --exclude 'format.functions.tests.h' \
            --exclude 'formatter.*.pass.cpp' \
            --exclude 'grep.pass.cpp' \
            --exclude 'locale-specific_form.pass.cpp' \
            --exclude 'ostream.pass.cpp' \
            --exclude 'std_format_spec_string_unicode.bench.cpp' \
            --exclude 'transcoding.pass.cpp' \
+           --exclude 'vprint_unicode_windows.pass.cpp' \
            --exclude 'underflow.pass.cpp' \
            || false
 
     # Reject code with trailing whitespace
     ! grep -rn '[[:blank:]]$' libcxx/include libcxx/src libcxx/test libcxx/benchmarks || false
 ;;
 #
 # Various Standard modes

libcxx/utils/generate_feature_test_macro_components.py

for x in [
         {
             "name": "__cpp_lib_polymorphic_allocator",
             "values": {"c++20": 201902},
             "headers": ["memory_resource"],
             "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
             "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)",
         },
         {
+            "name": "__cpp_lib_print",
+            "values": {"c++23": 202207},
+            "headers": ["ostream", "print"],
+            "unimplemented": True,
+        },
+        {
             "name": "__cpp_lib_quoted_string_io",
             "values": {"c++14": 201304},
             "headers": ["iomanip"],
         },
         {
             "name": "__cpp_lib_ranges",
             "values": {"c++20": 202207},
             "headers": ["algorithm", "functional", "iterator", "memory", "ranges"],

libcxx/utils/libcxx/test/header_information.py

lit_header_restrictions = {
     "experimental/utility": "// UNSUPPORTED: c++03",
     "experimental/vector": "// UNSUPPORTED: c++03",
     "filesystem": "// UNSUPPORTED: no-filesystem, c++03, c++11, c++14",
     "fstream": "// UNSUPPORTED: no-localization, no-filesystem",
     "future": "// UNSUPPORTED: no-threads, c++03",
     "iomanip": "// UNSUPPORTED: no-localization",
     "ios": "// UNSUPPORTED: no-localization",
     "iostream": "// UNSUPPORTED: no-localization",
     "istream": "// UNSUPPORTED: no-localization",
     "latch": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
-    "locale.h": "// UNSUPPORTED: no-localization",
     "locale": "// UNSUPPORTED: no-localization",
+    "locale.h": "// UNSUPPORTED: no-localization",
     "mutex": "// UNSUPPORTED: no-threads, c++03",
     "ostream": "// UNSUPPORTED: no-localization",
+    "print": "// UNSUPPORTED: availability-fp_to_chars-missing", # TODO PRINT investigate
     "regex": "// UNSUPPORTED: no-localization",
     "semaphore": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
     "shared_mutex": "// UNSUPPORTED: no-threads, c++03, c++11",
     "sstream": "// UNSUPPORTED: no-localization",
     "stdatomic.h": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17, c++20",
     "stop_token": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
     "streambuf": "// UNSUPPORTED: no-localization",
     "strstream": "// UNSUPPORTED: no-localization",