Implement syncstream (p0053)

[Mordante]

Summary

This patch implements std::basic_syncbuf and std::basic_osyncstream as specified in paper p0053r7. For ease of reviewing I am submitting this patch before submitting a patch for std::basic_osyncstream.

Please note, this patch is not 100% complete. I plan on adding more tests (see comments), specifically I plan on adding tests for multithreading and synchronization.

Edit: I decided that it would be far easier for me to keep track of this and make changes that affect both std::basic_syncbuf and std::basic_osyncstream if both were in one patch.

The patch was originally written by @zoecarver

Implements

• P0053R7 - C++ Synchronized Buffered Ostream
• LWG-3127 basic_osyncstream::rdbuf needs a const_cast
• LWG-3334 basic_osyncstream move assignment and destruction calls basic_syncbuf::emit() twice
• LWG-3570 basic_osyncstream::emit should be an unformatted output function
• LWG-3867 Should std::basic_osyncstream's move assignment operator be noexcept?

[mclow.lists]

libcxx/include/syncstream

103

Arrgh. Peter! Two functions with the same name, one returns bool the other void.
Not your problem, though.

[zoecarver]

• Updated mutex for gaurd_lock so that it corresponds to a streambuf.
• Added more thread tests.

[zoecarver]

• update/add to the tests

libcxx/include/syncstream

227

Nothing. If an exception is thrown from emit(), the destructor catches and ignores that exception.

318

I like the verbosity of saying == false. I'll update it, though.

[zoecarver]

• don't use not keyword

[mclow.lists]

libcxx/include/syncstream

202

As a static member variable - when does this get initialized? On first use? before main? Does it get initialized if the user never instantiates a basic_syncbuf?

209

Why unordered_map as opposed to map? Does std::hash< streambuf_type*> have some behavior that you want? [ Note: unordered_map might be the right choice. But you should say why it is the right choice somewhere. ]

280

This adds a default constructed mutex_ptr_type to the map if it doesn't already exist.
I suspect that's not what you wanted.

[mclow.lists]

libcxx/include/syncstream

221

How do entries get removed from __mtx_ptr_map?

[zoecarver]

libcxx/include/syncstream

209

The pointer specialization of std::hash should help with memory usage. Unordered map has a find complexity of O(1) which is the real reason I think it should be used. This stream should be CPU performant above all else, with hundreds of threads trying to access an element, I think the benefit of find speed outweighs the slight increase in memory consumption. Do you agree?

[mclow.lists]

libcxx/include/syncstream

209

The pointer specialization of std::hash should help with memory usage.

How?

Unordered map has a find complexity of O(1) which is the real reason I think it should be used.

Unordered map has a find complexity of O(1) in the best case. O(N) in the worst case. Which one this?

[zoecarver]

libcxx/include/syncstream

209

Unordered map has a find complexity of O(1) in the best case.

Sorry, yes, that is what I meant. I suspect that I will be closer to O(1) because there won't be very many elements.

I ran some basic benchmarks and came up with very similar results. std::unordered_map seems to be roughly 150ms slower (total time 16675ms vs 16521ms). Given this, I will update to use std::map to shrink the memory footprint.

[zoecarver]

libcxx/include/syncstream

202

Yes, because it is initialized out of line, it will be initialized any time this file is included.

I will update this to use an enum and get around the static data member initialization.

221

They don't. I don't think there is any way to say "will any threads ever need to access this streambuf again?"

If there was a way to only keep the streambuf in the static map while the object is active, I would be open to that. But, I am hesitant to do that because I want to keep the read/writes to the map as low as possible.

What would you suggest?

280

I can update this to use contains but, I don't think it matters much. There should never be a scenario where __mtx_ptr_map[__wrapped] doesn't exist. And if there is, then the below code will still pass because mutex_ptr_type == nullptr_t is OK.

[zoecarver]

• use contains
• use function level static
• use map instead of unordered_map

[zoecarver]

Add std::lock_guards to prevent races on the map. I ran with TSAN and got no warnings. I also increased the number of times I run the larger thread tests and now get no errors.

[zoecarver]

libcxx/include/syncstream

221

Given the "new" structure of __mtx_ptr_map, I think I can add a function to remove elements from the map safely. Would this be a good thing to add (the only reason it might not is for performance but, I think stale memory outweighs performance here)?

[zoecarver]

Ping @mclow.lists can you take another look at this?

[mclow.lists]

libcxx/include/syncstream

221

You could store a count, like shared_ptr does. How many sync streams are using this streambuf?

Increment the count on construction, decrement on destruction, remove at zero.

[Mordante]

libcxx/include/iosfwd

103

Can you comment these classes and typedefs have been added in C++20?

libcxx/include/syncstream

53

@mclow.lists Do you know whether these functions should be noexcept? There's a contraction in the standard
http://eel.is/c++draft/syncstream.syncbuf#assign

// [syncstream.syncbuf.assign], assignment and swap
 basic_syncbuf& operator=(basic_syncbuf&&);
 void swap(basic_syncbuf&);

http://eel.is/c++draft/syncstream.syncbuf#assign
basic_syncbuf& operator=(basic_syncbuf&& rhs) noexcept;
void swap(basic_syncbuf& other) noexcept;

The move constructor is not marked as noexcept and neither is emit so I assume [syncstream.syncbuf.assign] is wrong.

227

Minor nit __gaurd -> __guard.

231

Is it intended to use assert in a header?

239

Minor nit __gaurd -> __guard. Please grep for this typo, there's at least one more occurrence.

284

http://eel.is/c++draft/syncstream.syncbuf#assign-1 "Effects : Calls emit()..." I don't see that call.

[zoecarver]

libcxx/include/syncstream

53

See https://cplusplus.github.io/LWG/issue3498 I'm going to leave them as not-noexcept until we determine a resolution for this.

231

Fixed. Changed to a _LIBCPP_ASSERT

284

Good catch!

284

I wonder if the same goes for basic_osyncstream& operator=(basic_osyncstream&&) noexcept;. It seems like that operator just isn't specified at all... another LWG issue :P

[zoecarver]

libcxx/include/syncstream

53

Also, I just realized, the assignment operator 100% has to be noexcept because it calls emit which is designed to sometimes throw.

[zoecarver]

• Address review comments
• Switch back to unordered_map
• Replace shared_ptr with manual ref count

[zoecarver]

• Add comments
• Feature test macros
• Update www/status docs

[zoecarver]

Sorry for being so slow to update this patch. I think all review comments have been addressed, and this is now ready for re-review.

cc @ldionne and @mclow.lists.

[• joe.sylve]

libcxx/include/syncstream

289

This move constructor will lose the existing buffered contents. Is this intended? I'd expect that the __str buffer would also be moved and the base class's pointers adjusted.

[Mordante]

Rebased, updated coding style. fix tests.

Note I still need to do a review of the patch and address the open review comments.
Mainly a test to see the status of the CI.

[Mordante]

CI fixes.

[Mordante]

libcxx/include/syncstream

221

I implemented this part and indeed use a count to. Not cleaning up sound like a memory leak which might affect long running applications that create a lot syncbufs.

289

This comment seems no longer be attached to its original location so not sure what you're referring to. I have noticed several issues with the move assignment and constructor.

[Mordante]

Rebased and lots of improvements

• fixed CI issues
• fixed modules
• added nonmember swap
• fixed member swap signature
• changed implementation for the mutex addresses a review comment

• Added more tests to validate the class, manual review found several issues in the overflow function and move operations
• Testing found more issues, for example in emit
• Removed a non-needed class member for flusing

Implemented 3 LWG issues

• 3334. basic_osyncstream move assignment and destruction calls basic_syncbuf::emit() twice
• 3867. Should std::basic_osyncstream's move assignment operator be noexcept?
• 3570. basic_osyncstream::emit should be an unformatted output function

Marked one LWG as done

• 3127. basic_osyncstream::rdbuf needs a const_cast

[Mordante]

Tab -> space

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[ldionne]

libcxx/include/syncstream

207

It *might* be possible to use a bit in the locale to implement a lock for all streambufs. Something like

diff --git a/libcxx/include/__locale b/libcxx/include/__locale
index ccac748c44e4..4942808ac2bc 100644
--- a/libcxx/include/__locale
+++ b/libcxx/include/__locale
@@ -131,9 +131,11 @@ private:
     static locale& __global();
     bool has_facet(id&) const;
     const facet* use_facet(id&) const;
+};
 
-    template <class _Facet> friend bool has_facet(const locale&)  _NOEXCEPT;
-    template <class _Facet> friend const _Facet& use_facet(const locale&);
+template <>
+struct __free_bit_traits<locale> {
+    // expose the free bit in `__imp*`
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI locale::facet
diff --git a/libcxx/include/streambuf b/libcxx/include/streambuf
index 095ac7d3ad83..b42fae608a5a 100644
--- a/libcxx/include/streambuf
+++ b/libcxx/include/streambuf
@@ -296,7 +296,9 @@ protected:
     virtual int_type overflow(int_type __c = traits_type::eof());
 
 private:
-    locale __loc_;
+    static_assert(__has_free_bits<locale>);
+    __free_bit_pair<locale, 1> __loc_;
+    // Now implement a lock using that single free bit.
     char_type* __binp_;
     char_type* __ninp_;
     char_type* __einp_;
diff --git a/libcxx/src/locale.cpp b/libcxx/src/locale.cpp
index 59c7ce4d43d6..ade1aa688c4d 100644
--- a/libcxx/src/locale.cpp
+++ b/libcxx/src/locale.cpp
@@ -543,7 +543,7 @@ locale::__imp::make_classic()
     // only one thread can get in here and it only gets in once
     static aligned_storage<sizeof(locale)>::type buf;
     locale* c = reinterpret_cast<locale*>(&buf);
-    c->__locale_ = &make<__imp>(1u);
+    c->__get_locale() = &make<__imp>(1u);
     return *c;
 }

Do you know what other implementations have done? Have they gone through the trouble of finding a lock inside streambufs or do they use a global map?

387

Do we take advantage of what std::string provides (i.e. growth characteristics, SBO, etc..). If we do take advantage of those, then it might be worth using std::string, otherwise I think we might as well use a character buffer we manually manage to save on the duplication of begin/end information.

[Mordante]

libcxx/include/syncstream

207

They use "global" maps. As discussed I think it makes more sense not to do this and mark the feature as experimental. Then investigate whether this alternative approach is worth the hassle. I still think we should finish it before LLVM 18.

387

No basically the SBO is "killed" by "str_.resize(str_.capacity() + 1);" This could be smarter and keep the SBO. I'm not sure how useful SBO is. It only helps if all data flushed fits in the SBO area.

[Mordante]

Addresses review comments and updates tests.

[ldionne]

Thanks a lot for picking up this patch! I have a bunch of comments but this is starting to look pretty good.

libcxx/include/map

1703–1704

Can you file a Github issue and link it here? In the issue you can say something like "we have a potential use-after-move in map::operator[]" and link to https://godbolt.org/z/e1x9c1h6Y.

libcxx/include/syncstream

158

This seems to be a generic utility to lock addresses. We could extract it from <syncstream> and make it generic, and then reuse it from here in <syncstream>. That way we could potentially reuse this code if we have a need for it in the future.

Or we could also maybe even abstract away the fact that we're containing a mutex inside the value_type. Then this would be a generic map from addresses to some payload.

191

operator[] or .find() maybe? Note that operator[] has an unfortunate precedent of default-constructing the key if it's not present in std::map so we might want to be careful about re-using operator[], but this is worth thinking about.

199

If this class represents a by-address lock, perhaps this should be bool __is_locked(void* __ptr).

207

I think this usage of a function-local static is quite interesting. It's really important to have exactly one instance of this object in the program, otherwise the locking won't work as intended. However, I think it is possible to end up with multiple copies of that object right now:

1. If we have two TUs that use different versions of libc++, I think we could end up with e.g. __wrapped_streambuf_mutex::__instance[v1800]::__result and __wrapped_streambuf_mutex::__instance[v1900]::__result.
2. On GCC where we use always_inline, I think this might also end up generating multiple function-local statics but I am not certain about that. The function-local static itself might be linkonce_odr and deduplicated across TUs correctly.

I wonder whether we should instead be stuffing that into the dylib -- that would definitely remove any ambiguity about there being multiple copies of the object. And if we do that, we could also hide the implementation behind a pimpl-like idiom, that way

• we do not have to depend on std::map in syncstream
• we can change to another implementation (e.g. std::flat_map) in the future without impacting our ABI

Concretely, since this is pretty heavyweight anyway, I don't think that we gain much by having these methods defined in headers in the hopes that Clang would inline stuff better.

239

442–445

I think these can be removed since they are in iosfwd already.

525–528

Same, can be removed!

libcxx/test/std/input.output/syncstream/osyncstream/members/get_wrapped.pass.cpp

2

Are we missing a test for rdbuf?

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.move.pass.cpp

18

37

Let's add a test for noexcept-ness since the current WP clearly specifies it, but we might remove it in the future.

55

This tests for implicit-ness too. IMO using std::move here instead of a temporary makes the test clearer, but this is equivalent so your choice.

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.ostream.allocator.pass.cpp

35

const?

43

For explicit.

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.ostream.pass.cpp

35

Reversed arguments.

libcxx/test/std/input.output/syncstream/osyncstream/thread/basic.pass.cpp

19–20

Can you replace this by a short comment explaining what this tests?

libcxx/test/std/input.output/syncstream/osyncstream/types.compile.pass.cpp

39–40

Remove?

libcxx/test/std/input.output/syncstream/syncbuf/special.pass.cpp

1 ↗

(On Diff #557562)

I think this is now tested in cons.pointer.allocator.pass.cpp and cons.move.pass.cpp?

libcxx/test/std/input.output/syncstream/syncbuf/sputc.pass.cpp

149

return 0!

libcxx/test/std/input.output/syncstream/syncbuf/sputn.pass.cpp

132

return 0

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.assign/assign.pass.cpp

18

We don't seem to be testing that this is noexcept, and also I don't think we test the return type + return value of the function (with the usual same_as<basic_syncbuf&> decltype(auto) ret = (assignment); assert(&ret == &obj);).

72–73

106

I think this is a copy-paste, you probably don't need to check this again here. Probably same thing below?

108

Duplicated too. Below as well?

232

Generally speaking, I find it useful to add a short plain english comment explaining these test cases, since what's being tested may not be easy to figure out a few years down the line. I also wouldn't mind if these were defined inline inside test() w/ the comments.

259

288

etc..

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/cons.pointer.allocator.pass.cpp

32

We should make this std::allocator<CharT> const alloc; (below too), that way the test would fail if the constructor were declared as basic_syncbuf(streambuf_type* obuf, Allocator&);, which would pass right now.

34

Here and below, we should use Buf buf = {nullptr, alloc} to test that this is an implicit constructor.

40–42

We could change those to

#ifndef TEST_HAS_NO_THREADS
  LIBCPP_ASSERT(...);
#endif

Non-blocking, just a suggestion if you like that better.

44

So here IIUC, the following would be equally valid:

std::basic_stringbuf<CharT> w;
Buf buf = {&w, alloc};

IMO not reusing basic_syncbuf here would make the test clearer.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/cons.pointer.pass.cpp

33

I think what you want here is

static_assert(!std::convertible_to<std::basic_streambuf<CharT>*, Buf>);

42

My comment above about reusing Buf applies here and everywhere else.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/const.move.pass.cpp

1 ↗

(On Diff #557562)

Name of the file: cons.move.pass.cpp instead of const.move.pass.cpp?

33 ↗

(On Diff #557562)

Buf buf = std::move(b);

For implicit-ness?

44 ↗

(On Diff #557562)

Consider using b1 and b2 or something like that to make it clearer what is what. Just a suggestion.

135 ↗

(On Diff #557562)

Not attached to this file: can we add a dtor.pass.cpp test that ensures that we call emit()?

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/emit.pass.cpp

2

You swapped the filename with the one for set_emit_on_sync.pass.cpp.

28

I can't find a test for sync. There is a protected method sync() but I don't see a test for it either, I think.

30

We should at least run the code buff.set_emit_on_sync, right now we don't even codegen it.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/get_wrapped.pass.cpp

30–31

That way we test the return type properly.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/helpers.h

32–36 ↗

(On Diff #557562)

Can we replace this by the usual test_allocator?

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/set_emit_on_sync.pass.cpp

28

libcxx/test/std/input.output/syncstream/syncbuf/types.compile.pass.cpp

37–42

I think we should remove the third assertion here.

64–65

Same here, remove.

libcxx/test/std/input.output/syncstream/syncbuf/virtuals.pass.cpp

14–18 ↗

(On Diff #557562)

This synopsis is wrong. I think this is the sync test we were looking for earlier.

36 ↗

(On Diff #557562)

Should we comment that this calls buff.sync() under the hood?

[Mordante]

libcxx/include/syncstream

158

I prefer to do this in a followup commit. I feel the commit is already quite large and I prefer generic tools not to be hidden in these commits.

387

I prefer this too for a separate review. Especially since I already have something not generic in the implementation of format. That could benefit from a generic routine. The same for the places that use the now deprecated get_temporary_buffer. That would allow us to properly deprecate that function.

libcxx/test/std/input.output/syncstream/osyncstream/members/get_wrapped.pass.cpp

2

Indeed we are, added it.

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.move.pass.cpp

55

I like the current way slightly better.

[Mordante]

Addresses review comments.

[ldionne]

libcxx/include/syncstream

158

Can we file a Github issue and add a TODO here to look into this? That way, we have something actionable to follow up on in a PR in the near future after shipping this patch.

387

This review is extremely relevant for any attempt to remove temporary_buffer again: https://reviews.llvm.org/D152208

FWIW I think we should 100% do it and we meant to pick this up again but it hasn't happened yet.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Rebased and addresses review comments.

[Mordante]

Seems some of the comments I marked as done were not registered in Phab. Reviewed the entire patch again, all should be done now.

libcxx/include/map

1703–1704

https://github.com/llvm/llvm-project/issues/70696

libcxx/include/syncstream

158

https://github.com/llvm/llvm-project/issues/70697

442–445

Actually this header should provide them. When not doing that the std modules fail, so I reverted this part and the other using.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.assign/assign.pass.cpp

18

Actually it's not a noexcept function per https://cplusplus.github.io/LWG/issue3867. I had already updated the header but not the synopsis here. I added the other return type test.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/const.move.pass.cpp

33 ↗

(On Diff #557562)

As mentioned I prefer this way.

135 ↗

(On Diff #557562)

I've added the test based on the emit test.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/emit.pass.cpp

28

Updated the comment, it was already tested.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/helpers.h

32–36 ↗

(On Diff #557562)

This is again a special allocator. As mentioned during a live review we should look at the number of "test allocators" we have and try to get a good set. I feel that's out of scope for this patch.

libcxx/test/std/input.output/syncstream/syncbuf/types.compile.pass.cpp

37–42

Odd I'm 100% certain I removed them before, seems I did make an error with the previous update.

[ldionne]

I suggest we ship this but guard it under -fexperimental-library since we know there are some things we want to improve. That way there's no risk of shipping it before we're confident about our implementation choices.

libcxx/include/syncstream

2

472

[ldionne]

libcxx/docs/FeatureTestMacroTable.rst

281

We should mention this in a release note (but mention it is experimental).

[Mordante]

Rebased and addresses are review comments.
Give it a CI run to test the change to the experimental library.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_shared_ptr_arrays``                     ``201707L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_shift``                                 ``201806L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_smart_ptr_for_overwrite``               *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_source_location``                       ``201907L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_span``                                  ``202002L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_ssize``                                 ``201902L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_starts_ends_with``                      ``201711L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_string_view``                           ``201803L``
     --------------------------------------------------- -----------------
-    ``__cpp_lib_syncbuf``                               *unimplemented*
+    ``__cpp_lib_syncbuf``                               ``201803L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_three_way_comparison``                  *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_to_address``                            ``201711L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_to_array``                              ``201907L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_type_identity``                         ``201806L``

libcxx/docs/Status/Cxx20Issues.csv

 "`3031 <https://wg21.link/LWG3031>`__","Algorithms and predicates with non-const reference arguments","San Diego","",""
 "`3037 <https://wg21.link/LWG3037>`__","``polymorphic_allocator``\  and incomplete types","San Diego","|Complete|","16.0"
 "`3038 <https://wg21.link/LWG3038>`__","``polymorphic_allocator::allocate``\  should not allow integer overflow to create vulnerabilities","San Diego","|Complete|","14.0"
 "`3054 <https://wg21.link/LWG3054>`__","``uninitialized_copy``\  appears to not be able to meet its exception-safety guarantee","San Diego","|Nothing To Do|",""
 "`3065 <https://wg21.link/LWG3065>`__","LWG 2989 missed that all ``path``\ 's other operators should be hidden friends as well","San Diego","|Complete|",""
 "`3096 <https://wg21.link/LWG3096>`__","``path::lexically_relative``\  is confused by trailing slashes","San Diego","|Complete|",""
 "`3116 <https://wg21.link/LWG3116>`__","``OUTERMOST_ALLOC_TRAITS``\  needs ``remove_reference_t``\ ","San Diego","",""
 "`3122 <https://wg21.link/LWG3122>`__","``__cpp_lib_chrono_udls``\  was accidentally dropped","San Diego","|Complete|",""
-"`3127 <https://wg21.link/LWG3127>`__","``basic_osyncstream::rdbuf``\  needs a ``const_cast``\ ","San Diego","",""
+"`3127 <https://wg21.link/LWG3127>`__","``basic_osyncstream::rdbuf``\ needs a ``const_cast``\ ","San Diego","|Complete|","18.0"
 "`3128 <https://wg21.link/LWG3128>`__","``strstream::rdbuf``\  needs a ``const_cast``\ ","San Diego","|Nothing To Do|",""
 "`3129 <https://wg21.link/LWG3129>`__","``regex_token_iterator``\  constructor uses wrong pointer arithmetic","San Diego","",""
 "`3130 <https://wg21.link/LWG3130>`__","|sect|\ [input.output] needs many ``addressof``\ ","San Diego","",""
 "`3131 <https://wg21.link/LWG3131>`__","``addressof``\  all the things","San Diego","",""
 "`3132 <https://wg21.link/LWG3132>`__","Library needs to ban macros named ``expects``\  or ``ensures``\ ","San Diego","|Nothing To Do|",""
 "`3134 <https://wg21.link/LWG3134>`__","[fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961","San Diego","Resolved by `P1210R0 <https://wg21.link/P1210R0>`__",""
 "`3137 <https://wg21.link/LWG3137>`__","Header for ``__cpp_lib_to_chars``\ ","San Diego","|Complete|",""
 "`3140 <https://wg21.link/LWG3140>`__","``COMMON_REF``\ is unimplementable as specified","San Diego","|Nothing To Do|",""

 "`3325 <https://wg21.link/LWG3325>`__","Constrain return type of transformation function for ``transform_view``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3326 <https://wg21.link/LWG3326>`__","``enable_view``\  has false positives","Prague","|Complete|","15.0","|ranges|"
 "`3327 <https://wg21.link/LWG3327>`__","Format alignment specifiers vs. text direction","Prague","|Nothing To Do|","","|format|"
 "`3328 <https://wg21.link/LWG3328>`__","Clarify that ``std::string``\  is not good for UTF-8","Prague","",""
 "`3329 <https://wg21.link/LWG3329>`__","``totally_ordered_with``\  both directly and indirectly requires ``common_reference_with``\ ","Prague","|Complete|","13.0"
 "`3330 <https://wg21.link/LWG3330>`__","Include ``<compare>``\  from most library headers","Prague","|Complete|","13.0","|spaceship|"
 "`3331 <https://wg21.link/LWG3331>`__","Define ``totally_ordered/_with``\  in terms of ``partially-ordered-with``\ ","Prague","|Complete|","13.0"
 "`3332 <https://wg21.link/LWG3332>`__","Issue in |sect|\ [time.format]","Prague","|Complete|","16.0","|chrono| |format|"
-"`3334 <https://wg21.link/LWG3334>`__","``basic_osyncstream``\  move assignment and destruction calls ``basic_syncbuf::emit()``\  twice","Prague","",""
+"`3334 <https://wg21.link/LWG3334>`__","``basic_osyncstream``\  move assignment and destruction calls ``basic_syncbuf::emit()``\ twice","Prague","|Complete|","18.0"
 "`3335 <https://wg21.link/LWG3335>`__","Resolve C++20 NB comments US 273 and GB 274","Prague","|Complete|","15.0","|ranges|"
 "`3338 <https://wg21.link/LWG3338>`__","Rename ``default_constructible``\  to ``default_initializable``\ ","Prague","|Complete|","13.0"
 "`3340 <https://wg21.link/LWG3340>`__","Formatting functions should throw on argument/format string mismatch in |sect|\ [format.functions]","Prague","|Complete|","14.0","|format|"
 "`3346 <https://wg21.link/LWG3346>`__","``pair``\  and ``tuple``\  copy and move constructor have backwards specification","Prague","",""
 "`3347 <https://wg21.link/LWG3347>`__","``std::pair<T, U>``\  now requires ``T``\  and ``U``\  to be less-than-comparable","Prague","|Complete|","17.0"
 "`3348 <https://wg21.link/LWG3348>`__","``__cpp_lib_unwrap_ref``\  in wrong header","Prague","|Complete|","12.0"
 "`3349 <https://wg21.link/LWG3349>`__","Missing ``__cpp_lib_constexpr_complex``\  for P0415R1","Prague","|Complete|","16.0"
 "`3350 <https://wg21.link/LWG3350>`__","Simplify return type of ``lexicographical_compare_three_way``\ ","Prague","|Complete|","17.0","|spaceship|"

libcxx/docs/Status/Cxx20Papers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version","Labels"
 "`P0463R1 <https://wg21.link/P0463R1>`__","LWG","Endian just Endian","Toronto","|Complete|","7.0"
 "`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","|Complete|","15.0"
 "","","","","","",""
 "`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
-"`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
+"`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","|Complete|","18.0"
 "`P0202R3 <https://wg21.link/P0202R3>`__","LWG","Add constexpr modifiers to functions in <algorithm> and <utility> Headers","Albuquerque","|Complete|","12.0"
 "`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|Complete|","16.0"
 "`P0439R0 <https://wg21.link/P0439R0>`__","LWG","Make ``std::memory_order``\  a scoped enumeration","Albuquerque","|Complete|",""
 "`P0457R2 <https://wg21.link/P0457R2>`__","LWG","String Prefix and Suffix Checking","Albuquerque","|Complete|","6.0"
 "`P0550R2 <https://wg21.link/P0550R2>`__","LWG","Transformation Trait ``remove_cvref``\ ","Albuquerque","|Complete|","6.0"
 "`P0600R1 <https://wg21.link/P0600R1>`__","LWG","nodiscard in the Library","Albuquerque","|Complete|","16.0"
 "`P0616R0 <https://wg21.link/P0616R0>`__","LWG","de-pessimize legacy <numeric> algorithms with std::move","Albuquerque","|Complete|","12.0"
 "`P0653R2 <https://wg21.link/P0653R2>`__","LWG","Utility to convert a pointer to a raw pointer","Albuquerque","|Complete|","6.0"

libcxx/docs/Status/Cxx23Issues.csv

 `3557 <https://wg21.link/LWG3557>`__,"The ``static_cast`` expression in ``convertible_to`` has the wrong operand","October 2021","|Complete|","14.0"
 `3559 <https://wg21.link/LWG3559>`__,"Semantic requirements of ``sized_range`` is circular","October 2021","|Nothing To Do|","","|ranges|"
 `3560 <https://wg21.link/LWG3560>`__,"``ranges::equal`` and ``ranges::is_permutation`` should short-circuit for ``sized_ranges``","October 2021","","","|ranges|"
 `3561 <https://wg21.link/LWG3561>`__,"Issue with internal counter in ``discard_block_engine``","October 2021","",""
 `3563 <https://wg21.link/LWG3563>`__,"``keys_view`` example is broken","October 2021","","","|ranges|"
 `3566 <https://wg21.link/LWG3566>`__,"Constraint recursion for ``operator<=>(optional<T>, U)``","October 2021","|Complete|","17.0","|spaceship|"
 `3567 <https://wg21.link/LWG3567>`__,"Formatting move-only iterators take two","October 2021","|Complete|","16.0","|format| |ranges|"
 `3568 <https://wg21.link/LWG3568>`__,"``basic_istream_view`` needs to initialize ``value_``","October 2021","|Complete|","16.0","|ranges|"
-`3570 <https://wg21.link/LWG3570>`__,"``basic_osyncstream::emit`` should be an unformatted output function","October 2021","",""
+`3570 <https://wg21.link/LWG3570>`__,"``basic_osyncstream::emit`` should be an unformatted output function","October 2021","|Complete|","18.0"
 `3571 <https://wg21.link/LWG3571>`__,"``flush_emit`` should set ``badbit`` if the ``emit`` call fails","October 2021","",""
 `3572 <https://wg21.link/LWG3572>`__,"``copyable-box`` should be fully ``constexpr``","October 2021","|Complete|","14.0","|ranges|"
 `3573 <https://wg21.link/LWG3573>`__,"Missing Throws element for ``basic_string_view(It begin, End end)``","October 2021","|Complete|","14.0"
 `3574 <https://wg21.link/LWG3574>`__,"``common_iterator`` should be completely ``constexpr``-able","October 2021","|Complete|","14.0","|ranges|"
 `3580 <https://wg21.link/LWG3580>`__,"``iota_view``'s ``iterator``'s binary ``operator+`` should be improved","October 2021","|Complete|","14.0","|ranges|"
 `3581 <https://wg21.link/LWG3581>`__,"The range constructor makes ``basic_string_view`` not trivially move constructible","October 2021","|Complete|","14.0","|ranges|"
 `3585 <https://wg21.link/LWG3585>`__,"``variant`` converting assignment with immovable alternative","October 2021","",""
 `3589 <https://wg21.link/LWG3589>`__,"The ``const`` lvalue reference overload of ``get`` for ``subrange`` does not constrain ``I`` to be ``copyable`` when ``N == 0``","October 2021","|Complete|","14.0","|ranges|"

 "`3848 <https://wg21.link/LWG3848>`__","``adjacent_view``, ``adjacent_transform_view`` and ``slide_view`` missing ``base`` accessor","February 2023","","","|ranges|"
 "`3849 <https://wg21.link/LWG3849>`__","``cartesian_product_view::iterator``'s default constructor is overconstrained","February 2023","","","|ranges|"
 "`3850 <https://wg21.link/LWG3850>`__","``views::as_const`` on ``empty_view<T>`` should return ``empty_view<const T>``","February 2023","","","|ranges|"
 "`3851 <https://wg21.link/LWG3851>`__","``chunk_view::inner-iterator`` missing custom ``iter_move`` and ``iter_swap``","February 2023","","","|ranges|"
 "`3853 <https://wg21.link/LWG3853>`__","``basic_const_iterator<volatile int*>::operator->`` is ill-formed","February 2023","","",""
 "`3857 <https://wg21.link/LWG3857>`__","``basic_string_view`` should allow explicit conversion when only traits vary","February 2023","|Complete|","17.0",""
 "`3860 <https://wg21.link/LWG3860>`__","``range_common_reference_t`` is missing","February 2023","|Complete|","17.0","|ranges|"
 "`3866 <https://wg21.link/LWG3866>`__","Bad Mandates for ``expected::transform_error`` overloads","February 2023","|Complete|","17.0",""
-"`3867 <https://wg21.link/LWG3867>`__","Should ``std::basic_osyncstream``'s move assignment operator be ``noexcept``?","February 2023","","",""
+"`3867 <https://wg21.link/LWG3867>`__","Should ``std::basic_osyncstream``'s move assignment operator be ``noexcept``?","February 2023","|Complete|","18.0",""
 "`3441 <https://wg21.link/LWG3441>`__","Misleading note about calls to customization points","February 2023","","",""
 "`3622 <https://wg21.link/LWG3622>`__","Misspecified transitivity of equivalence in §[unord.req.general]","February 2023","","",""
 "`3631 <https://wg21.link/LWG3631>`__","``basic_format_arg(T&&)`` should use ``remove_cvref_t<T>`` throughout","February 2023","|Complete|","17.0",""
 "`3645 <https://wg21.link/LWG3645>`__","``resize_and_overwrite`` is overspecified to call its callback with lvalues","February 2023","|Complete|","14.0",""
 "`3655 <https://wg21.link/LWG3655>`__","The ``INVOKE`` operation and union types","February 2023","|Complete|","18.0",""
 "`3723 <https://wg21.link/LWG3723>`__","``priority_queue::push_range`` needs to ``append_range``","February 2023","","","|ranges|"
 "`3734 <https://wg21.link/LWG3734>`__","Inconsistency in ``inout_ptr`` and ``out_ptr`` for empty case","February 2023","","",""
 "`3772 <https://wg21.link/LWG3772>`__","``repeat_view``'s ``piecewise`` constructor is missing Postconditions","February 2023","","","|ranges|"

libcxx/include/CMakeLists.txt

set(files
   stdio.h
   stdlib.h
   stop_token
   streambuf
   string
   string.h
   string_view
   strstream
+  syncstream
   system_error
   tgmath.h
   thread
   tuple
   type_traits
   typeindex
   typeinfo
   uchar.h

libcxx/include/__std_clang_module

 #  include <streambuf>
 #endif
 #include <string.h>
 #include <string>
 #include <string_view>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #  include <strstream>
 #endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <syncstream>
+#endif
 #include <system_error>
 #include <tgmath.h>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #  include <thread>
 #endif
 #include <tuple>
 #include <type_traits>
 #include <typeindex>

libcxx/include/iosfwd

 typedef basic_ostringstream<wchar_t> wostringstream;
 typedef basic_stringstream<wchar_t>  wstringstream;
 
 typedef basic_filebuf<wchar_t>       wfilebuf;
 typedef basic_ifstream<wchar_t>      wifstream;
 typedef basic_ofstream<wchar_t>      wofstream;
 typedef basic_fstream<wchar_t>       wfstream;
 
 template <class state> class fpos;
 using streampos  = fpos<char_traits<char>::state_type>;
 using wstreampos = fpos<char_traits<wchar_t>::state_type>;
 using u8streampos = fpos<char_traits<char8_t>::state_type>; // C++20
 using u16streampos = fpos<char_traits<char16_t>::state_type>;
 using u32streampos = fpos<char_traits<char32_t>::state_type>;
 
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_syncbuf;                          // C++20
+
+using syncbuf = basic_syncbuf<char>;              // C++20
+using wsyncbuf = basic_syncbuf<wchar_t>;          // C++20
+
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_osyncstream;                      // C++20
+
+using osyncstream = basic_osyncstream<char>;      // C++20
+using wosyncstream = basic_osyncstream<wchar_t>;  // C++20
+
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__fwd/fstream.h>
 #include <__fwd/ios.h>

 typedef fpos<mbstate_t>    wstreampos;
 #endif
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 typedef fpos<mbstate_t>    u8streampos;
 #endif
 typedef fpos<mbstate_t>    u16streampos;
 typedef fpos<mbstate_t>    u32streampos;
 
+#if _LIBCPP_STD_VER >= 20
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_syncbuf;
+
+using syncbuf  = basic_syncbuf<char>;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wsyncbuf = basic_syncbuf<wchar_t>;
+#endif
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_osyncstream;
+
+using osyncstream  = basic_osyncstream<char>;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wosyncstream = basic_osyncstream<wchar_t>;
+#endif
+
+#endif // _LIBCPP_STD_VER >=20
+
 // Include other forward declarations here
 template <class _Tp, class _Alloc = allocator<_Tp> >
 class _LIBCPP_TEMPLATE_VIS vector;
 
 template <class _CharT, class _Traits>
 class __save_flags
 {
     typedef basic_ios<_CharT, _Traits> __stream_type;

libcxx/include/map

return __tree_.__emplace_unique_key_args(__k,
         _VSTD::forward_as_tuple(__k),
         _VSTD::forward_as_tuple()).first->__get_value().second;
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 _Tp&
 map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k)
 {
+    // TODO investigate this clang-tidy warning.
+    // NOLINTNEXTLINE(bugprone-use-after-move)
     return __tree_.__emplace_unique_key_args(__k,
         _VSTD::piecewise_construct,
         _VSTD::forward_as_tuple(_VSTD::move(__k)),
         _VSTD::forward_as_tuple()).first->__get_value().second;
 }
 
 #else // _LIBCPP_CXX03_LANG
 

libcxx/include/streambuf

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__fwd/streambuf.h>
+#include <climits>
 #include <ios>
 #include <iosfwd>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/syncstream

+// -*- C++ -*-
+//===--------------------------- sstream ----------------------------------===//
+//
+// 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_SYNCSTREAM
+#define _LIBCPP_SYNCSTREAM
+
+/*
+    syncstream synopsis
+
+#include <ostream>  // see [ostream.syn]
+
+namespace std {
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf;
+
+    // [syncstream.syncbuf.special], specialized algorithms
+    template<class charT, class traits, class Allocator>
+      void swap(basic_syncbuf<charT, traits, Allocator>&,
+                basic_syncbuf<charT, traits, Allocator>&);
+
+    using syncbuf = basic_syncbuf<char>;
+    using wsyncbuf = basic_syncbuf<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream;
+
+    using osyncstream = basic_osyncstream<char>;
+    using wosyncstream = basic_osyncstream<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf : public basic_streambuf<charT, traits> {
+    public:
+        using char_type      = charT;
+        using int_type       = typename traits::int_type;
+        using pos_type       = typename traits::pos_type;
+        using off_type       = typename traits::off_type;
+        using traits_type    = traits;
+        using allocator_type = Allocator;
+
+        using streambuf_type = basic_streambuf<charT, traits>;
+
+        // [syncstream.syncbuf.cons], construction and destruction
+        explicit basic_syncbuf(streambuf_type* obuf = nullptr)
+          : basic_syncbuf(obuf, Allocator()) {}
+        basic_syncbuf(streambuf_type*, const Allocator&);
+        basic_syncbuf(basic_syncbuf&&);
+        ~basic_syncbuf();
+
+        // [syncstream.syncbuf.assign], assignment and swap
+        basic_syncbuf& operator=(basic_syncbuf&&);
+        void swap(basic_syncbuf&);
+
+        // [syncstream.syncbuf.members], member functions
+        bool emit();
+        streambuf_type* get_wrapped() const noexcept;
+        allocator_type get_allocator() const noexcept;
+        void set_emit_on_sync(bool) noexcept;
+
+    protected:
+        // [syncstream.syncbuf.virtuals], overridden virtual functions
+        int sync() override;
+
+    private:
+        streambuf_type* wrapped;    // exposition only
+        bool emit_on_sync{};        // exposition only
+    };
+
+    // [syncstream.syncbuf.special], specialized algorithms
+    template<class charT, class traits, class Allocator>
+    void swap(basic_syncbuf<charT, traits, Allocator>&,
+              basic_syncbuf<charT, traits, Allocator>&);
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream : public basic_ostream<charT, traits> {
+    public:
+        using char_type   = charT;
+        using int_type    = typename traits::int_type;
+        using pos_type    = typename traits::pos_type;
+        using off_type    = typename traits::off_type;
+        using traits_type = traits;
+
+        using allocator_type = Allocator;
+        using streambuf_type = basic_streambuf<charT, traits>;
+        using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
+
+        // [syncstream.osyncstream.cons], construction and destruction
+        basic_osyncstream(streambuf_type*, const Allocator&);
+        explicit basic_osyncstream(streambuf_type* obuf)
+          : basic_osyncstream(obuf, Allocator()) {}
+        basic_osyncstream(basic_ostream<charT, traits>& os, const Allocator& allocator)
+          : basic_osyncstream(os.rdbuf(), allocator) {}
+        explicit basic_osyncstream(basic_ostream<charT, traits>& os)
+          : basic_osyncstream(os, Allocator()) {}
+        basic_osyncstream(basic_osyncstream&&) noexcept;
+        ~basic_osyncstream();
+
+        // [syncstream.osyncstream.assign], assignment
+        basic_osyncstream& operator=(basic_osyncstream&&);
+
+        // [syncstream.osyncstream.members], member functions
+        void emit();
+        streambuf_type* get_wrapped() const noexcept;
+        syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
+
+    private:
+        syncbuf_type sb;    // exposition only
+    };
+}
+
+*/
+
+#include <__config>
+#include <__utility/move.h>
+#include <iosfwd> // required for declaration of default arguments
+#include <string>
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  include <map>
+#  include <mutex>
+#  include <shared_mutex>
+#endif
+
+// standard-mandated includes
+
+// [syncstream.syn]
+#include <ostream>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+// [syncstream.syncbuf.overview]/1
+//   Class template basic_syncbuf stores character data written to it,
+//   known as the associated output, into internal buffers allocated
+//   using the object's allocator. The associated output is transferred
+//   to the wrapped stream buffer object *wrapped when emit() is called
+//   or when the basic_syncbuf object is destroyed. Such transfers are
+//   atomic with respect to transfers by other basic_syncbuf objects
+//   with the same wrapped stream buffer object.
+//
+// This helper singleton is used to implement the required
+// synchronisation guarantees.
+#  ifndef _LIBCPP_HAS_NO_THREADS
+class __wrapped_streambuf_mutex {
+  _LIBCPP_HIDE_FROM_ABI __wrapped_streambuf_mutex() = default;
+
+public:
+  __wrapped_streambuf_mutex(const __wrapped_streambuf_mutex&)            = delete;
+  __wrapped_streambuf_mutex& operator=(const __wrapped_streambuf_mutex&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI void __inc_reference([[maybe_unused]] void* __ptr) {
+    _LIBCPP_ASSERT_INTERNAL(__ptr != nullptr, "non-wrapped streambufs are never written to");
+    unique_lock __lock{__mutex_};
+    ++__lut_[reinterpret_cast<uintptr_t>(__ptr)].__count;
+  }
+
+  // pre: __ptr is in __lut_
+  _LIBCPP_HIDE_FROM_ABI void __dec_reference([[maybe_unused]] void* __ptr) noexcept {
+    unique_lock __lock{__mutex_};
+
+    auto __it = __get_it(__ptr);
+    if (__it->second.__count == 1)
+      __lut_.erase(__it);
+    else
+      --__it->second.__count;
+  }
+
+  // TODO
+  // This function causes emit() aquire two mutexes:
+  // - __mutex_ shared
+  // _ __get_it(__ptr)->second.__mutex exclusive
+  //
+  // Instead store a pointer to __get_it(__ptr)->second.__mutex when
+  // calling __inc_reference.
+  //
+  // pre: __ptr is in __lut_
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI lock_guard<mutex> __get_lock([[maybe_unused]] void* __ptr) noexcept {
+    shared_lock __lock{__mutex_};
+    return lock_guard{__get_it(__ptr)->second.__mutex};
+  }
+
+  // This function is used for testing.
+  //
+  // It is allowed to call this function with a non-registered pointer.
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t __get_count([[maybe_unused]] void* __ptr) noexcept {
+    _LIBCPP_ASSERT_INTERNAL(__ptr != nullptr, "non-wrapped streambufs are never written to");
+    shared_lock __lock{__mutex_};
+
+    auto __it = __lut_.find(reinterpret_cast<uintptr_t>(__ptr));
+    return __it != __lut_.end() ? __it->second.__count : 0;
+  }
+
+  [[nodiscard]] static _LIBCPP_HIDE_FROM_ABI __wrapped_streambuf_mutex& __instance() noexcept {
+    static __wrapped_streambuf_mutex __result;
+    return __result;
+  }
+
+private:
+  struct __value {
+    mutex __mutex;
+    size_t __count{0};
+  };
+
+  shared_mutex __mutex_;
+  map<uintptr_t, __value> __lut_;
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI map<uintptr_t, __value>::iterator __get_it(void* __ptr) noexcept {
+    _LIBCPP_ASSERT_INTERNAL(__ptr != nullptr, "non-wrapped streambufs are never written to");
+
+    auto __it = __lut_.find(reinterpret_cast<uintptr_t>(__ptr));
+    _LIBCPP_ASSERT_INTERNAL(__it != __lut_.end(), "using a wrapped streambuf that has not been registered");
+    _LIBCPP_ASSERT_INTERNAL(__it->second.__count >= 1, "found an inactive streambuf wrapper");
+    return __it;
+  }
+};
+#  endif // _LIBCPP_HAS_NO_THREADS
+
+// basic_syncbuf
+
+// The class uses a basic_string<_CharT, _Traits, _Allocator> as
+// internal buffer. Per [syncstream.syncbuf.cons]/4
+//   Remarks: A copy of allocator is used to allocate memory for
+//   internal buffers holding the associated output.
+//
+// Therefore the allocator used in the constructor is passed to the
+// basic_string. The class does not keep a copy of this allocator.
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_syncbuf : public basic_streambuf<_CharT, _Traits> {
+public:
+  using char_type      = _CharT;
+  using traits_type    = _Traits;
+  using int_type       = typename traits_type::int_type;
+  using pos_type       = typename traits_type::pos_type;
+  using off_type       = typename traits_type::off_type;
+  using allocator_type = _Allocator;
+
+  using streambuf_type = basic_streambuf<_CharT, _Traits>;
+
+  // [syncstream.syncbuf.cons], construction and destruction
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_syncbuf(streambuf_type* __obuf = nullptr)
+      : basic_syncbuf(__obuf, _Allocator()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf(streambuf_type* __obuf, _Allocator const& __alloc)
+      : __wrapped_(__obuf), __str_(__alloc) {
+    __inc_reference();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf(basic_syncbuf&& __other)
+      : __wrapped_(__other.get_wrapped()), __str_(std::move(__other.__str_)), __emit_on_sync_(__other.__emit_on_sync_) {
+    __move_common(__other);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~basic_syncbuf() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      emit();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+    }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __dec_reference();
+  }
+
+  // [syncstream.syncbuf.assign], assignment and swap
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf& operator=(basic_syncbuf&& __other) {
+    // The function is specified to call emit. This call should
+    // propagate the exception thrown.
+    emit();
+    __dec_reference();
+
+    __wrapped_      = __other.get_wrapped();
+    __str_          = std::move(__other.__str_);
+    __emit_on_sync_ = __other.__emit_on_sync_;
+
+    __move_common(__other);
+
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_syncbuf& __other) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        allocator_traits<_Allocator>::propagate_on_container_swap::value || get_allocator() == __other.get_allocator(),
+        "violates the mandated swap precondition");
+
+    basic_syncbuf __tmp(std::move(__other));
+    __other = std::move(*this);
+    *this   = std::move(__tmp);
+  }
+
+  // [syncstream.syncbuf.members], member functions
+
+  _LIBCPP_HIDE_FROM_ABI bool emit() { return emit(false); }
+
+  _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __wrapped_; }
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
+
+  _LIBCPP_HIDE_FROM_ABI void set_emit_on_sync(bool __b) noexcept { __emit_on_sync_ = __b; }
+
+protected:
+  // [syncstream.syncbuf.virtuals], overridden virtual functions
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  int sync() override {
+    if (__emit_on_sync_ && !emit(true))
+      return -1;
+    return 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  int_type overflow(int_type __c = traits_type::eof()) override {
+    if (traits_type::eq_int_type(__c, traits_type::eof()))
+      return traits_type::not_eof(__c);
+
+    if (this->pptr() == this->epptr()) {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      try {
+#  endif
+        size_t __size = __str_.size();
+        __str_.resize(__str_.capacity() + 1);
+        _LIBCPP_ASSERT_INTERNAL(__str_.size() > __size, "the buffer hasn't grown");
+
+        char_type* __p = static_cast<char_type*>(__str_.data());
+        this->setp(__p, __p + __str_.size());
+        this->pbump(__size);
+
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        return traits_type::eof();
+      }
+#  endif
+    }
+
+    return this->sputc(traits_type::to_char_type(__c));
+  }
+
+private:
+  streambuf_type* __wrapped_;
+
+  // TODO Use a more generic buffer.
+  // That buffer should be light with almost no additional headers. Then
+  // it can be use here, the __retarget_buffer, and place that use
+  // the now deprecated get_temporary_buffer
+
+  basic_string<_CharT, _Traits, _Allocator> __str_;
+  bool __emit_on_sync_{false};
+
+  _LIBCPP_HIDE_FROM_ABI bool emit(bool __flush) {
+    if (!__wrapped_)
+      return false;
+
+#  ifndef _LIBCPP_HAS_NO_THREADS
+    lock_guard<mutex> __lock = __wrapped_streambuf_mutex::__instance().__get_lock(__wrapped_);
+#  endif
+
+    bool __result = true;
+    if (this->pptr() != this->pbase()) {
+      _LIBCPP_ASSERT_INTERNAL(this->pbase() && this->pptr() && this->epptr(), "all put area pointers shold be valid");
+
+      // The __str_ does not know how much of its buffer is used. This
+      // information is extracted from the information of the base class.
+      __result &= (__wrapped_->sputn(this->pbase(), this->pptr() - this->pbase()) != -1);
+      // Clears the buffer, but keeps the contents (and) size of the
+      // internal buffer.
+      this->setp(this->pbase(), this->epptr());
+    }
+
+    if (__flush)
+      __result &= (__wrapped_->pubsync() != -1);
+
+    return __result;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __move_common(basic_syncbuf& __other) {
+    // Adjust the put area pointers to our buffer.
+    char_type* __p = static_cast<char_type*>(__str_.data());
+    this->setp(__p, __p + __str_.size());
+    this->pbump(__other.pptr() - __other.pbase());
+
+    // Clear __other_ so the destructor will act as a NOP.
+    __other.setp(nullptr, nullptr);
+    __other.__wrapped_ = nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __inc_reference() {
+#  ifndef _LIBCPP_HAS_NO_THREADS
+    if (__wrapped_)
+      __wrapped_streambuf_mutex::__instance().__inc_reference(__wrapped_);
+#  endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __dec_reference() noexcept {
+#  ifndef _LIBCPP_HAS_NO_THREADS
+    if (__wrapped_)
+      __wrapped_streambuf_mutex::__instance().__dec_reference(__wrapped_);
+#  endif
+  }
+};
+
+using std::syncbuf;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using std::wsyncbuf;
+#  endif
+
+// [syncstream.syncbuf.special], specialized algorithms
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI void
+swap(basic_syncbuf<_CharT, _Traits, _Allocator>& __lhs, basic_syncbuf<_CharT, _Traits, _Allocator>& __rhs) {
+  __lhs.swap(__rhs);
+}
+
+// basic_osyncstream
+
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_osyncstream : public basic_ostream<_CharT, _Traits> {
+public:
+  using char_type   = _CharT;
+  using traits_type = _Traits;
+  using int_type    = typename traits_type::int_type;
+  using pos_type    = typename traits_type::pos_type;
+  using off_type    = typename traits_type::off_type;
+
+  using allocator_type = _Allocator;
+  using streambuf_type = basic_streambuf<char_type, traits_type>;
+  using syncbuf_type   = basic_syncbuf<char_type, traits_type, allocator_type>;
+
+  // [syncstream.osyncstream.cons], construction and destruction
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(streambuf_type* __obuf, allocator_type const& __alloc)
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__obuf, __alloc) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_osyncstream(streambuf_type* __obuf)
+      : basic_osyncstream(__obuf, allocator_type()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(basic_ostream<char_type, traits_type>& __os, allocator_type const& __alloc)
+      : basic_osyncstream(__os.rdbuf(), __alloc) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_osyncstream(basic_ostream<char_type, traits_type>& __os)
+      : basic_osyncstream(__os, allocator_type()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(basic_osyncstream&& __other) noexcept
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(std::move(__other.__sb_)) {
+    this->set_rdbuf(std::addressof(__sb_));
+  }
+
+  // [syncstream.osyncstream.assign], assignment
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream& operator=(basic_osyncstream&& __other) = default;
+
+  // [syncstream.osyncstream.members], member functions
+
+  _LIBCPP_HIDE_FROM_ABI void emit() {
+    // The basic_ostream::put places the sentry in a try
+    // catch, this does not match the wording of the standard
+    // [ostream.unformatted]
+    // TODO validate other unformatte output functions.
+    typename basic_ostream<char_type, traits_type>::sentry __s(*this);
+    if (__s) {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      try {
+#  endif
+
+        if (__sb_.emit() == false)
+          this->setstate(ios::badbit);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        this->__set_badbit_and_consider_rethrow();
+      }
+#  endif
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __sb_.get_wrapped(); }
+
+  _LIBCPP_HIDE_FROM_ABI syncbuf_type* rdbuf() const noexcept {
+    return const_cast<syncbuf_type*>(std::addressof(__sb_));
+  }
+
+private:
+  syncbuf_type __sb_;
+};
+
+using std::osyncstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using std::wosyncstream;
+#  endif
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_SYNCSTREAM

libcxx/include/version

 # if __has_builtin(__builtin_source_location) && !(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER <= 1403)
 #   define __cpp_lib_source_location                    201907L
 # endif
 # define __cpp_lib_span                                 202002L
 # define __cpp_lib_ssize                                201902L
 # define __cpp_lib_starts_ends_with                     201711L
 # undef  __cpp_lib_string_view
 # define __cpp_lib_string_view                          201803L
-// # define __cpp_lib_syncbuf                              201803L
+# define __cpp_lib_syncbuf                              201803L
 // # define __cpp_lib_three_way_comparison                 201907L
 # define __cpp_lib_to_address                           201711L
 # define __cpp_lib_to_array                             201907L
 # define __cpp_lib_type_identity                        201806L
 # define __cpp_lib_unwrap_ref                           201811L
 #endif
 
 #if _LIBCPP_STD_VER >= 23

libcxx/modules/std.cppm.in

 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #  include <streambuf>
 #endif
 #include <string>
 #include <string_view>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #  include <strstream>
 #endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <syncstream>
+#endif
 #include <system_error>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #  include <thread>
 #endif
 #include <tuple>
 #include <type_traits>
 #include <typeindex>
 #include <typeinfo>

 #  error "update the header information for <spanstream> in libcxx/utils/generate_std_cppm_in.py"
 #endif //   __has_include(<spanstream>)
 #if __has_include(<stacktrace>)
 #  error "update the header information for <stacktrace> in libcxx/utils/generate_std_cppm_in.py"
 #endif //   __has_include(<stacktrace>)
 #if __has_include(<stdfloat>)
 #  error "update the header information for <stdfloat> in libcxx/utils/generate_std_cppm_in.py"
 #endif //   __has_include(<stdfloat>)
-#if __has_include(<syncstream>)
-#  error "update the header information for <syncstream> in libcxx/utils/generate_std_cppm_in.py"
-#endif //   __has_include(<syncstream>)
 #if __has_include(<text_encoding>)
 #  error "update the header information for <text_encoding> in libcxx/utils/generate_std_cppm_in.py"
 #endif //   __has_include(<text_encoding>)
 
 export module std;
 
 @LIBCXX_MODULE_STD_INCLUDE_SOURCES@

libcxx/modules/std/iosfwd.inc

export namespace std {
   using std::streampos;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   using std::wstreampos;
 #endif
   using std::u16streampos;
   using std::u32streampos;
   using std::u8streampos;
 
+  using std::basic_osyncstream;
+  using std::basic_syncbuf;
+
   using std::istreambuf_iterator;
   using std::ostreambuf_iterator;
 
+  using std::osyncstream;
+  using std::syncbuf;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wosyncstream;
+  using std::wsyncbuf;
+#endif
+
   using std::fpos;
 } // namespace std

libcxx/modules/std/syncstream.inc

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
-#if 0
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
   using std::basic_syncbuf;
 
   // [syncstream.syncbuf.special], specialized algorithms
   using std::swap;
 
   using std::syncbuf;
 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   using std::wsyncbuf;
 #  endif
   using std::basic_osyncstream;
 
   using std::osyncstream;
 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   using std::wosyncstream;
 #  endif
-#endif
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
 } // namespace std

libcxx/test/libcxx/transitive_includes/cxx03.csv

 stop_token cstdint
 stop_token cstring
 stop_token ctime
 stop_token iosfwd
 stop_token limits
 stop_token ratio
 stop_token type_traits
 stop_token version
+streambuf climits
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

 string_view limits
 string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
+syncstream cstddef
+syncstream iosfwd
+syncstream map
+syncstream mutex
+syncstream ostream
+syncstream shared_mutex
+syncstream string
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string

libcxx/test/libcxx/transitive_includes/cxx11.csv

 stop_token cstdint
 stop_token cstring
 stop_token ctime
 stop_token iosfwd
 stop_token limits
 stop_token ratio
 stop_token type_traits
 stop_token version
+streambuf climits
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

 string_view limits
 string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
+syncstream cstddef
+syncstream iosfwd
+syncstream map
+syncstream mutex
+syncstream ostream
+syncstream shared_mutex
+syncstream string
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string

libcxx/test/libcxx/transitive_includes/cxx14.csv

 stop_token cstdint
 stop_token cstring
 stop_token ctime
 stop_token iosfwd
 stop_token limits
 stop_token ratio
 stop_token type_traits
 stop_token version
+streambuf climits
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

 string_view limits
 string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
+syncstream cstddef
+syncstream iosfwd
+syncstream map
+syncstream mutex
+syncstream ostream
+syncstream shared_mutex
+syncstream string
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string

libcxx/test/libcxx/transitive_includes/cxx17.csv

 stop_token cstdint
 stop_token cstring
 stop_token ctime
 stop_token iosfwd
 stop_token limits
 stop_token ratio
 stop_token type_traits
 stop_token version
+streambuf climits
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

 string_view limits
 string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
+syncstream cstddef
+syncstream iosfwd
+syncstream map
+syncstream mutex
+syncstream ostream
+syncstream shared_mutex
+syncstream string
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string

libcxx/test/libcxx/transitive_includes/cxx20.csv

 stop_token cstdint
 stop_token cstring
 stop_token ctime
 stop_token iosfwd
 stop_token limits
 stop_token ratio
 stop_token type_traits
 stop_token version
+streambuf climits
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

 string_view limits
 string_view new
 string_view stdexcept
 string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
+syncstream cstddef
+syncstream iosfwd
+syncstream map
+syncstream mutex
+syncstream ostream
+syncstream shared_mutex
+syncstream string
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string

libcxx/test/libcxx/transitive_includes/cxx23.csv

 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
 stop_token limits
 stop_token ratio
 stop_token version
+streambuf climits
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef
 string cstdint
 string cstdio

 string_view iosfwd
 string_view limits
 string_view new
 string_view stdexcept
 string_view version
 strstream istream
 strstream ostream
 strstream version
+syncstream cstddef
+syncstream iosfwd
+syncstream map
+syncstream mutex
+syncstream ostream
+syncstream shared_mutex
+syncstream string
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error stdexcept
 system_error string
 system_error version
 thread array
 thread atomic

libcxx/test/libcxx/transitive_includes/cxx26.csv

 stop_token atomic
 stop_token cstddef
 stop_token cstdint
 stop_token cstring
 stop_token ctime
 stop_token limits
 stop_token ratio
 stop_token version
+streambuf climits
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef
 string cstdint
 string cstdio

 string_view iosfwd
 string_view limits
 string_view new
 string_view stdexcept
 string_view version
 strstream istream
 strstream ostream
 strstream version
+syncstream cstddef
+syncstream iosfwd
+syncstream map
+syncstream mutex
+syncstream ostream
+syncstream shared_mutex
+syncstream string
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error stdexcept
 system_error string
 system_error version
 thread array
 thread atomic

libcxx/test/std/input.output/syncstream/osyncstream/assign.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: no-localization
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// basic_osyncstream& operator=(basic_osyncstream&& rhs);
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+
+template <class CharT, bool propagate>
+static void test() {
+  using Traits    = std::char_traits<CharT>;
+  using Allocator = std::conditional_t<propagate, other_allocator<CharT>, test_allocator<CharT>>;
+  static_assert(std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value == propagate);
+
+  using OS = std::basic_osyncstream<CharT, Traits, Allocator>;
+
+  std::basic_stringbuf<CharT, Traits, Allocator> base1;
+  std::basic_stringbuf<CharT, Traits, Allocator> base2;
+
+  {
+    OS out1{&base1, Allocator{42}};
+    assert(out1.get_wrapped() == &base1);
+
+    typename OS::syncbuf_type* sb1 = out1.rdbuf();
+    assert(sb1->get_wrapped() == &base1);
+    assert(sb1->get_allocator().get_data() == 42);
+
+    out1 << CharT('A');
+
+    static_assert(!noexcept(out1.operator=(std::move(out1)))); // LWG-3867
+    OS out2{&base2, Allocator{99}};
+
+    out2 << CharT('Z');
+
+    // Validate the data is still in the syncbuf and not in the stringbuf.
+    assert(base1.str().empty());
+    assert(base2.str().empty());
+
+    out2 = std::move(out1);
+
+    // Since sb2 is overwritten by the move its data should be in its stringbuf.
+    assert(base1.str().empty());
+    assert(base2.str().size() == 1);
+    assert(base2.str()[0] == CharT('Z'));
+
+    assert(out2.get_wrapped() == &base1);
+
+    typename OS::syncbuf_type* sb2 = out2.rdbuf();
+    assert(sb2->get_wrapped() == &base1);
+    if constexpr (std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value)
+      assert(sb2->get_allocator().get_data() == 42);
+    else
+      assert(sb2->get_allocator().get_data() == 99);
+
+    assert(out1.get_wrapped() == nullptr);
+    assert(sb1->get_wrapped() == nullptr);
+
+    // The data written to 2 will be stored in sb1. The write happens after the destruction.
+    out2 << CharT('B');
+    assert(base1.str().empty());
+  }
+
+  assert(base1.str().size() == 2);
+  assert(base1.str()[0] == CharT('A'));
+  assert(base1.str()[1] == CharT('B'));
+  assert(base2.str().size() == 1);
+  assert(base2.str()[0] == CharT('Z'));
+}
+
+template <class CharT>
+static void test() {
+  test<CharT, true>();
+  test<CharT, false>();
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/osyncstream/members/emit.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: no-localization
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// void emit();
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+void test() {
+  using OS = std::basic_osyncstream<CharT>;
+  using SS = std::basic_ostringstream<CharT>;
+  CharT c  = 'f';
+
+  SS ss;
+  OS out(ss);
+  out << c;
+  assert(ss.str().empty());
+  out.emit();
+  assert(ss.str()[0] == c);
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+}

libcxx/test/std/input.output/syncstream/osyncstream/members/get_wrapped.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: no-localization
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// streambuf_type* get_wrapped() const noexcept;
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+void test() {
+  std::basic_stringbuf<CharT> base;
+  const std::basic_osyncstream<CharT> out{&base};
+  assert(out.get_wrapped() == &base);
+  ASSERT_NOEXCEPT(out.get_wrapped());
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/osyncstream/members/rdbuf.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: no-localization
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// syncbuf_type* rdbuf() const noexcept
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+void test() {
+  const std::basic_osyncstream<CharT> out{nullptr};
+  assert(out.rdbuf() != nullptr);
+  ASSERT_NOEXCEPT(out.rdbuf());
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.move.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: no-localization
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// basic_osyncstream(basic_osyncstream&&) noexcept;
+
+// TODO Why is this noexcept?
+// Does the reasoning for https://cplusplus.github.io/LWG/issue3867 not hold true here?
+
+#include <cassert>
+#include <sstream>
+#include <syncstream>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "test_allocator.h"
+
+template <class CharT>
+void test() {
+  {
+    using OS = std::basic_osyncstream<CharT>;
+    using W  = std::basic_syncbuf<CharT>;
+
+    const std::allocator<CharT> alloc;
+    {
+      OS os = {OS{nullptr, alloc}};
+      assert(os.get_wrapped() == nullptr);
+      assert(os.rdbuf()->get_wrapped() == nullptr);
+      assert(os.rdbuf()->get_allocator() == alloc);
+      ASSERT_NOEXCEPT(OS{std::move(os)});
+    }
+    {
+      W w;
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 0);
+#endif
+      {
+        OS os = {OS{&w, alloc}};
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+        assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 1);
+#endif
+        assert(os.get_wrapped() == &w);
+        assert(os.rdbuf()->get_wrapped() == &w);
+        assert(os.rdbuf()->get_allocator() == alloc);
+      }
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 0);
+#endif
+    }
+  }
+
+  {
+    using OS = std::basic_osyncstream<CharT, constexpr_char_traits<CharT>>;
+    using W  = std::basic_stringbuf<CharT, constexpr_char_traits<CharT>>;
+
+    const std::allocator<CharT> alloc;
+    {
+      OS os = {OS{nullptr, alloc}};
+      assert(os.get_wrapped() == nullptr);
+      assert(os.rdbuf()->get_wrapped() == nullptr);
+      assert(os.rdbuf()->get_allocator() == alloc);
+    }
+    {
+      W w;
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 0);
+#endif
+      {
+        OS os = {OS{&w, alloc}};
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+        assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 1);
+#endif
+        assert(os.get_wrapped() == &w);
+        assert(os.rdbuf()->get_wrapped() == &w);
+        assert(os.rdbuf()->get_allocator() == alloc);
+      }
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 0);
+#endif
+    }
+  }
+
+  {
+    using OS = std::basic_osyncstream<CharT, constexpr_char_traits<CharT>, test_allocator<CharT>>;
+    using W  = std::basic_stringbuf<CharT, constexpr_char_traits<CharT>, test_allocator<CharT>>;
+
+    const test_allocator<CharT> alloc;
+    {
+      OS os = {OS{nullptr, alloc}};
+      assert(os.get_wrapped() == nullptr);
+      assert(os.rdbuf()->get_wrapped() == nullptr);
+      assert(os.rdbuf()->get_allocator() == alloc);
+    }
+    {
+      W w;
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 0);
+#endif
+      {
+        OS os = {OS{&w, alloc}};
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+        assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 1);
+#endif
+        assert(os.get_wrapped() == &w);
+        assert(os.rdbuf()->get_wrapped() == &w);
+        assert(os.rdbuf()->get_allocator() == alloc);
+      }
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(&w) == 0);
+#endif
+    }
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.ostream.allocator.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: no-localization
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// basic_osyncstream(basic_ostream& os, const Allocator& allocator);
+
+#include <cassert>
+#include <concepts>
+#include <syncstream>
+#include <sstream>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "test_allocator.h"
+
+template <class CharT>
+void test() {
+  {
+    using OS = std::basic_osyncstream<CharT>;
+    using W  = std::basic_ostringstream<CharT>;
+
+    const std::allocator<CharT> alloc;
+
+    {
+      W w;
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 0);
+#endif
+      {
+        OS os = {w, alloc};
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+        assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 1);
+#endif
+        assert(os.get_wrapped() == w.rdbuf());
+        assert(os.rdbuf()->get_wrapped() == w.rdbuf());
+        assert(os.rdbuf()->get_allocator() == alloc);
+      }
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 0);
+#endif
+    }
+  }
+  {
+    using OS = std::basic_osyncstream<CharT, constexpr_char_traits<CharT>>;
+    using W  = std::basic_ostringstream<CharT, constexpr_char_traits<CharT>>;
+
+    const std::allocator<CharT> alloc;
+    {
+      W w;
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 0);
+#endif
+      {
+        OS os = {w.rdbuf(), alloc};
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+        assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 1);
+#endif
+        assert(os.get_wrapped() == w.rdbuf());
+        assert(os.rdbuf()->get_wrapped() == w.rdbuf());
+        assert(os.rdbuf()->get_allocator() == alloc);
+      }
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 0);
+#endif
+    }
+  }
+
+  {
+    using OS = std::basic_osyncstream<CharT, constexpr_char_traits<CharT>, test_allocator<CharT>>;
+    using W  = std::basic_ostringstream<CharT, constexpr_char_traits<CharT>, test_allocator<CharT>>;
+
+    const test_allocator<CharT> alloc;
+    {
+      W w;
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 0);
+#endif
+      {
+        OS os = {w.rdbuf(), alloc};
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+        assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 1);
+#endif
+        assert(os.get_wrapped() == w.rdbuf());
+        assert(os.rdbuf()->get_wrapped() == w.rdbuf());
+        assert(os.rdbuf()->get_allocator() == alloc);
+      }
+#if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_THREADS)
+      assert(std::__wrapped_streambuf_mutex::__instance().__get_count(w.rdbuf()) == 0);
+#endif
+    }
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.ostream.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: no-localization
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// explicit basic_osyncstream(basic_ostream&  os);
+
+#include <cassert>
+#include <concepts>
+#include <syncstream>
+#include <sstream>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.h"
+#include "test_allocator.h"
+
+template <class CharT>
+void test() {
+  {
+    using OS = std::basic_osyncstream<CharT>;
+    using W  = std::basic_ostringstream<CharT>;
+
+    static_assert(!std::convertible_to<std::basic_ostream<CharT>&, OS>);
+    static_assert(std::