[libc++][P0053R7] Add <syncstream> header and implement std::basic_syncbuf

[Mordante]

Summary

Add C++20 header <syncstream> and implement std::basic_syncbuf as described in P0053R7

[abrachet]

This is my first contribution to libcxx/ I tried my best to match style etc but bear with me :)

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

571–572

Not sure why make generate-cxx-abilist touched these, does anyone have any ideas? LLVM_USE_SANITIZER perhaps?

[curdeius]

Hi and thanks for the patch!

Please mark the new tests with // UNSUPPORTED: c++03, c++11, c++14, c++17.
Update and run utils/generate_feature_test_macro_components.py to add __cpp_lib_syncstream feature test macro.
Also please update status page for this paper in docs/.

Update should trigger CI.

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.assign/member_swap.pass.cpp

16 ↗

(On Diff #310026)

You should mark all your tests as UNSUPPORTED: for all previous standards.

[abrachet]

In D92790#2439170, @curdeius wrote:

Hi and thanks for the patch!

Please mark the new tests with // UNSUPPORTED: c++03, c++11, c++14, c++17.
Update and run utils/generate_feature_test_macro_components.py to add __cpp_lib_syncstream feature test macro.

I made this __cpp_lib_syncbuf looks like thats what the macro is supposed to be called, https://en.cppreference.com/w/cpp/feature_test#Library_features

Also please update status page for this paper in docs/.

Update should trigger CI.

Thanks for the suggestions.

[tschuett]

https://github.com/llvm-mirror/libcxx/blob/master/NOTES.TXT#L19-L29

[mclow.lists]

I'm not seeing any coordination between different syncbufs on the same stream here.
My impression was that implementing this required a global registry of streams that had syscstreams associated with them.

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

571–572

If these things have changed sizes, that's an ABI break.

[abrachet]

Add _LIBCPP_VERSION test

[abrachet]

In D92790#2444240, @mclow.lists wrote:

I'm not seeing any coordination between different syncbufs on the same stream here.
My impression was that implementing this required a global registry of streams that had syscstreams associated with them.

syncbuf has an internal __mutex type which maps streambuf_type *'s to mutexes

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

Still not sure why these are here though.

571–572

Looks like it was asan which did this.

[curdeius]

FYI, I've just landed D92656, so now you can use utils/generate_header_tests.py to generate (some) tests for a new header. You might need to modify the script to add condition on _LIBCPP_HAS_NO_THREADS. Anyway, what you did on tests looks good.
Also, notes are now at https://libcxx.llvm.org/docs/Contributing.html.

Just a few comments for the moment, I'll take time to review it a bit later.

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

It all depends on your environment and link flags. Once CI gets triggered you'd be able to get updated ABI lists from artifacts on failed build steps (in Buildkite). You'll probably need to remove these unrelated changes (exception, align_val_t).

571–572

Just to help reviewing, please mark addressed comments as "Done".

[curdeius]

As a general note, the test paths should match the paragraphs in the standard.
So, e.g. libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.assign/member_swap.pass.cpp should be libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.assign/swap.pass.cpp.
@ldionne, please correct me on that if I'm wrong.

Also, you seem to lack a test on the destructor (that it correctly calls emit and doesn't throw).

Anyway, in general, I like your implementation.

libcxx/docs/Cxx2aStatusPaperStatus.csv

196

It would be nice if you added a note on what's implemented and what's not (see Cxx2aStatus.rst).

libcxx/include/syncstream

15

You should also update the synopsis of <iosfwd>. Cf. paragraph 3.2 of the paper.

65–99

I never know, should unimplemented parts be present in the synopsis? @ldionne?

136–138

This ctor should be splitted in two, one of them being explicit and taking 0 or 1 params, cf. synopsis.

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.cons/default.pass.cpp

17 ↗

(On Diff #310725)

Also here, please add tests for explicit. Cf. below.

libcxx/test/std/input.output/stream.buffers/syncbuf/syncbuf.cons/wrapped.pass.cpp

17 ↗

(On Diff #310725)

You should also test that you can't construct it implicitly. You may use test_convertible for that.
You might have a look at D91292.

[abrachet]

• Add note to Cxx2aStatus.rst
• update synopsis of <iosfwd>
• Split ctor
• Update emit_mt.pass.cpp to use more threads
• Fix race condition in getting lock in mutex::mutex
• Fix set_emit_on_sync test which didn’t end with .pass.cpp so it wasn’t being tested previously (oops)
• Move dtor tests from emit test to its own test
• Renamed test files as suggested

[abrachet]

Thanks a lot for the comments @curdeius

libcxx/include/syncstream

15

Thanks, good catch

65–99

I have removed them for now

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

How does CI get triggered for libcxx? You mentioned it in a previous comment, but will that be only after pushing the changes?

[curdeius]

libcxx/docs/Cxx2aStatusPaperStatus.csv

6

You should update the status here instead of adding a new line. BTW, maybe drop R7 in the note.

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

Ahhh, I think I know what may happen. How do you upload the patches? You don't use arcanist, do you?
It seems that the problem when uploading patches through the web GUI is that it removes the set repository (rG LLVM Github Monorepo).
@mstorsjo had the same problems, apparently updating the patch twice (and setting the repo in the middle) triggers the CI if I understood correctly.
@ldionne, can we do something to fix that?
@abrachet, can you try using arcanist (arc)? See https://www.llvm.org/docs/Phabricator.html?highlight=arcanist#id3

[mstorsjo]

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

35–43

Yes - so far, it seems like if the patch already has the repo set, it still looks like it's set while updating the diff (and removing and readding it in the last step doesn't help), but after submitting, it's gone. So I guess one either has to explicitly remove the repo before updating a patch, or update it twice (so that one can re-set the repo the second time, to make CI pick it up again).

FWIW, I don't think the repo setting is something specific to the libcxx hooks, but sounds to me more like a phabricator issue.

[zoecarver]

Hey @abrachet. Thanks for the patch. Just FYI, I've got D67086 which also implements syncbuf. Maybe we can coordinate on how to merge these patches.

[curdeius]

Requesting changes so that it shows up nicely in the review queue.
@abrachet, could you please sync with Zoe and possibly merge your two patches?

[Mordante]

@abrachet are you still interested in this patch. I just restarted work on D67086. Do you want to work together or do you prefer me to finish this project?

[Mordante]

I had a closer look at this patch. I think the other patch now is more complete. Abandoning it to clean up the review queue.

libcxx/docs/Cxx2aStatus.rst

 
 .. note::
 
    .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class], |sect|\ [mem.poly.allocator.class], and |sect|\ [container.node.overview].
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
 
    .. [#note-P0619] P0619: Only ``std::allocator`` part is implemented.
 
+   .. [#note-P0053R7] P0053R7: Only ``std::basic_syncbuf`` part is implemented.
+
 
 .. _issues-status-cxx2a:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx2aStatusIssuesStatus.csv
    :header-rows: 1
    :widths: auto
 
 Last Updated: 24-Nov-2020

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version"
 "`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","",""
 "","","","","",""
 "`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
 "`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
 "`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","|In Progress|","7.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","|In Progress| [#note-P0600]_","7.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"

 "`P2002 <https://wg21.link/P2002>`__","CWG","Defaulted comparison specification cleanups","Prague","* *",""
 "`P2045 <https://wg21.link/P2045>`__","LWG","Missing Mandates for the standard library","Prague","* *",""
 "`P2085 <https://wg21.link/P2085>`__","CWG","Consistent defaulted comparisons","Prague","* *",""
 "`P2091 <https://wg21.link/P2091>`__","LWG","Issues with range access CPOs","Prague","* *",""
 "`P2101 <https://wg21.link/P2101>`__","LWG","'Models' subsumes 'satisfies' (Wording for US298 and US300)","Prague","* *",""
 "`P2102 <https://wg21.link/P2102>`__","LWG","Make 'implicit expression variations' more explicit (Wording for US185)","Prague","* *",""
 "`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
 "`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
+"`P0053R7 <https://wg21.link/P0053R7>`__","LWG","<syncstream>","Albuquerque","|Partial|","12.0"

libcxx/include/CMakeLists.txt

set(files
   support/solaris/floatingpoint.h
   support/solaris/wchar.h
   support/solaris/xlocale.h
   support/win32/limits_msvc_win32.h
   support/win32/locale_win32.h
   support/xlocale/__nop_locale_mgmt.h
   support/xlocale/__posix_l_fallback.h
   support/xlocale/__strtonum_fallback.h
+  syncstream
   system_error
   tgmath.h
   thread
   tuple
   type_traits
   typeindex
   typeinfo
   unordered_map

libcxx/include/iosfwd

 template <class charT, class traits = char_traits<charT> > class basic_filebuf;
 template <class charT, class traits = char_traits<charT> > class basic_ifstream;
 template <class charT, class traits = char_traits<charT> > class basic_ofstream;
 template <class charT, class traits = char_traits<charT> > class basic_fstream;
 
 template <class charT, class traits = char_traits<charT> > class istreambuf_iterator;
 template <class charT, class traits = char_traits<charT> > class ostreambuf_iterator;
 
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
+    class basic_syncbuf;
+
 typedef basic_ios<char>              ios;
 typedef basic_ios<wchar_t>           wios;
 
 typedef basic_streambuf<char>        streambuf;
 typedef basic_istream<char>          istream;
 typedef basic_ostream<char>          ostream;
 typedef basic_iostream<char>         iostream;
 

 typedef basic_ifstream<wchar_t>      wifstream;
 typedef basic_ofstream<wchar_t>      wofstream;
 typedef basic_fstream<wchar_t>       wfstream;
 
 template <class state> class fpos;
 typedef fpos<char_traits<char>::state_type>    streampos;
 typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
 
+typedef basic_syncbuf<char>          syncbuf;
+typedef basic_syncbuf<wchar_t>       wsyncbuf;
+
 }  // std
 
 */
 
 #include <__config>
 #include <wchar.h>  // for mbstate_t
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS basic_fstream;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS istreambuf_iterator;
 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator;
 
+#if _LIBCPP_STD_VER > 17
+
+template <class _CharT, class _Traits = char_traits<_CharT>,
+          class _Allocator = allocator<_CharT> >
+    class _LIBCPP_TEMPLATE_VIS basic_syncbuf;
+
+#endif // _LIBCPP_STD_VER > 17
+
 typedef basic_ios<char>              ios;
 typedef basic_ios<wchar_t>           wios;
 
 typedef basic_streambuf<char>        streambuf;
 typedef basic_istream<char>          istream;
 typedef basic_ostream<char>          ostream;
 typedef basic_iostream<char>         iostream;
 

 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;
 
+#if _LIBCPP_STD_VER > 17
+
+typedef basic_syncbuf<char>          syncbuf;
+typedef basic_syncbuf<wchar_t>       wsyncbuf;
+
+#endif // _LIBCPP_STD_VER > 17
+
 template <class _State>             class _LIBCPP_TEMPLATE_VIS fpos;
 typedef fpos<mbstate_t>    streampos;
 typedef fpos<mbstate_t>    wstreampos;
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
 typedef fpos<mbstate_t>    u8streampos;
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef fpos<mbstate_t>    u16streampos;

libcxx/include/syncstream

+// -*- C++ -*-
+//===-------------------------- syncstream -------------------------------===//
+//
+// 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
+
+namespace std {
+
+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>;
+
+    explicit
+    basic_syncbuf(streambuf_type* obuf = nullptr)
+      : basic_syncbuf(obuf, Allocator()) { }
+    basic_syncbuf(streambuf_type*, const Allocator&);
+    basic_syncbuf(basic_syncbuf&&);
+    ~basic_syncbuf();
+
+    basic_syncbuf& operator=(basic_syncbuf&&);
+    void swap(basic_syncbuf&);
+
+    bool emit();
+    streambuf_type* get_wrapped()    const noexcept;
+    allocator_type  get_allocator()  const noexcept;
+    void            set_emit_on_sync(bool) noexcept;
+
+protected:
+    int sync() override;
+
+private:
+    streambuf_type* wrapped;        // exposition only
+    bool            emit_on_sync{}; // exposition only
+};
+
+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>;
+
+} // namespace std
+
+*/
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#include <__config>
+#include <iosfwd>
+#include <map>
+#include <sstream>
+
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TYPE_VIS 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<char_type, traits_type>;
+
+    using string_type = basic_string<char_type, traits_type, allocator_type>;
+    using stringbuf_type = basic_stringbuf<_CharT, traits_type, allocator_type>;
+
+    explicit basic_syncbuf(streambuf_type* __obuf = nullptr)
+        : basic_syncbuf(__obuf, allocator_type{}) {}
+
+    basic_syncbuf(streambuf_type* __obuf, const allocator_type& __a)
+        : __mtx(__obuf), __buf(string_type{__a}), __wrapped(__obuf) {}
+
+    basic_syncbuf(basic_syncbuf&& __other) noexcept
+        : __mtx(std::move(__other.__mtx)), __buf(std::move(__other.__buf)),
+          __wrapped(__other.__wrapped), __emit_on_sync(__other.__emit_on_sync),
+          __needs_flush(__other.__needs_flush)
+    {
+        __other.__wrapped = nullptr;
+    }
+
+    ~basic_syncbuf()
+    {
+        _no_throw_emit();
+    }
+
+    basic_syncbuf& operator=(basic_syncbuf&& __other) noexcept
+    {
+        _no_throw_emit();
+
+        __mtx = std::move(__other.__mtx);
+        __buf = std::move(__other.__buf);
+        __wrapped = __other.__wrapped;
+        __emit_on_sync = __other.__emit_on_sync;
+        __needs_flush = __other.__needs_flush;
+
+        __other.__wrapped = nullptr;
+
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void swap(basic_syncbuf& __other)
+    {
+        std::swap(__mtx, __other.__mtx);
+        std::swap(__buf, __other.__buf);
+        std::swap(__wrapped, __other.__wrapped);
+        std::swap(__emit_on_sync, __other.__emit_on_sync);
+        std::swap(__needs_flush, __other.__needs_flush);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    bool emit()
+    {
+        if (!__wrapped)
+        {
+            return false;
+        }
+
+        // auto __view = __buf.view(); // C++20
+        // auto __str = std::move(__buf).str(); // C++20
+        decltype(__buf.str()) __str;
+        {
+            stringbuf_type __temp = std::move(__buf);
+            __str = __temp.str();
+        }
+
+        lock_guard<__mutex> __lk{__mtx};
+        if (std::streamsize __size = __str.size())
+        {
+            if (__wrapped->sputn(__str.data(), __size) != __size)
+            {
+                return false;
+            }
+        }
+
+        if (__needs_flush)
+        {
+            __needs_flush = false;
+            return !__wrapped->pubsync();
+        }
+
+        return true;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    streambuf_type* get_wrapped()   const noexcept
+    {
+        return __wrapped;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    allocator_type get_allocator() const noexcept
+    {
+        // return __buf.get_allocator(); // C++20
+        return allocator_type{};
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    void set_emit_on_sync(bool __b) noexcept
+    {
+        __emit_on_sync = __b;
+    }
+
+protected:
+    _LIBCPP_HIDE_FROM_ABI
+    int sync() override
+    {
+        __needs_flush = true;
+        return !__emit_on_sync || emit() ? 0 : traits_type::eof();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    streamsize xsputn(const char_type* __s, streamsize __n) override
+    {
+        return __buf.sputn(__s, __n);
+    }
+
+private:
+    _LIBCPP_HIDE_FROM_ABI
+    void _no_throw_emit() noexcept
+    {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        try
+        {
+#endif // _LIBCPP_NO_EXCEPTIONS
+            emit();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+        }
+#endif // _LIBCPP_NO_EXCEPTIONS
+    }
+
+    struct __mutex
+    {
+        mutex* __mtx;
+
+        __mutex(streambuf_type* __ptr)
+            : __mtx(_get_mutex(__ptr)) {}
+
+        _LIBCPP_HIDE_FROM_ABI
+        static mutex* _get_mutex(streambuf_type* __ptr)
+        {
+            static mutex __lock;
+            static map<streambuf_type*, mutex> __map;
+            lock_guard<mutex> __lk{__lock};
+            return std::addressof(__map[__ptr]);
+        }
+
+        _LIBCPP_HIDE_FROM_ABI
+        void lock()
+        {
+            __mtx->lock();
+        }
+
+        _LIBCPP_HIDE_FROM_ABI
+        void unlock()
+        {
+            __mtx->unlock();
+        }
+
+        _LIBCPP_HIDE_FROM_ABI
+        void swap(__mutex& other)
+        {
+            std::swap(__mtx, other.__mtx);
+        }
+    };
+
+    __mutex __mtx;
+    stringbuf_type __buf;
+    streambuf_type* __wrapped;
+    bool __emit_on_sync{};
+    bool __needs_flush{};
+};
+
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI
+void swap(basic_syncbuf<_CharT, _Traits, _Allocator>& __a,
+          basic_syncbuf<_CharT, _Traits, _Allocator>& __b)
+{
+    __a.swap(__b);
+}
+
+using syncbuf = basic_syncbuf<char>;
+using wsyncbuf = basic_syncbuf<wchar_t>;
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SYNCSTREAM

libcxx/lib/abi/x86_64-unknown-linux-gnu.libcxxabi.v1.stable.exceptions.no_new_in_libcxx.abilist

 {'is_defined': False, 'name': '_ZTVN10__cxxabiv120__si_class_type_infoE', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVN10__cxxabiv121__vmi_class_type_infoE', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt11logic_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt12length_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt12out_of_range', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt13runtime_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt14overflow_error', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZTVSt16invalid_argument', 'size': 0, 'type': 'OBJECT'}
+{'is_defined': False, 'name': '_ZTVSt9exception', 'size': 0, 'type': 'OBJECT'}
 {'is_defined': False, 'name': '_ZdaPv', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_ZdaPvSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_ZdlPv', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZdlPvSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_Znam', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_ZnamSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '_Znwm', 'type': 'FUNC'}
+{'is_defined': False, 'name': '_ZnwmSt11align_val_t', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_allocate_exception', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_begin_catch', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_current_primary_exception', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_decrement_exception_refcount', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_end_catch', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_free_exception', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_guard_abort', 'type': 'FUNC'}
 {'is_defined': False, 'name': '__cxa_guard_acquire', 'type': 'FUNC'}

 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5digitE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5graphE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5lowerE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5printE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5punctE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5spaceE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base5upperE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110ctype_base6xdigitE', 'size': 2, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110defer_lockE', 'size': 1, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110istrstreamD0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__110istrstreamD1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__110istrstreamD2Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE2idE', 'size': 16, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE4intlE', 'size': 1, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE2idE', 'size': 16, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE4intlE', 'size': 1, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE2idE', 'size': 16, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE4intlE', 'size': 1, 'type': 'OBJECT'}

 {'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'size': 112, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'size': 120, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__119__shared_weak_countE', 'size': 56, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__119basic_istringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'size': 80, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__119basic_ostringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'size': 80, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'size': 96, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__120__time_get_c_storageIcEE', 'size': 72, 'type': 'OBJECT'}
+{'is_defined': True, 'name': '_ZTVNSt3__120__time_get_c_storageIwEE', 'size': 72, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__14__fs10filesystem16filesystem_errorE', 'size': 40, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__15ctypeIcEE', 'size': 104, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__15ctypeIwEE', 'size': 136, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__16locale5facetE', 'size': 40, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDiDu11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDsDu11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}
 {'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 96, 'type': 'OBJECT'}

 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
 {'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
 No newline at end of file

libcxx/test/libcxx/double_include.sh.cpp

 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <string.h>
 #include <string_view>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <syncstream>
+#endif
 #include <system_error>
 #include <tgmath.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 #endif
 #include <tuple>
 #include <typeindex>
 #include <typeinfo>

libcxx/test/libcxx/input.output/syncstream/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+inLibcxx = os.path.join('libcxx', 'test', 'libcxx')
+inStd = os.path.join('libcxx', 'test', 'std')
+localConfig = os.path.normpath(os.path.realpath(__file__)).replace(inLibcxx, inStd)
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/input.output/syncstream/version.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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+#include <syncstream>
+
+#include "test_macros.h"
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main(int, char**)
+{
+
+  return 0;
+}

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #include <stdlib.h>
 TEST_MACROS();
 #include <string>
 TEST_MACROS();
 #include <string.h>
 TEST_MACROS();
 #include <string_view>
 TEST_MACROS();
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <syncstream>
+TEST_MACROS();
+#endif
 #include <system_error>
 TEST_MACROS();
 #include <tgmath.h>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 TEST_MACROS();
 #endif

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #include <string.h>
 #include <string_view>
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <syncstream>
+#endif
 #include <system_error>
 #include <tgmath.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 #endif
 #include <tuple>
 #include <typeindex>
 #include <typeinfo>

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.assign/member_swap.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf(const basic_syncbuf& rhs); // implicitly deleted
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    std::syncbuf sbuf{&buf};
+    std::syncbuf nullbuf;
+
+    assert(sbuf.get_wrapped() == &buf);
+    assert(nullbuf.get_wrapped() == nullptr);
+
+    sbuf.swap(nullbuf);
+
+    assert(sbuf.get_wrapped() == nullptr);
+    assert(nullbuf.get_wrapped() == &buf);
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.assign/move_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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf& operator=(basic_syncbuf&&);
+
+#include <syncstream>
+#include <cassert>
+
+#include <iostream>
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    {
+        std::syncbuf sbuf{&buf};
+
+        std::stringbuf buf2;
+        std::syncbuf sbuf2{&buf2};
+
+        sbuf.sputn("DEF", 3);
+        sbuf2.sputn("ABC", 3);
+        
+        assert(buf.str() == "");
+        assert(buf2.str() == "");
+
+        sbuf2 = std::move(sbuf);
+
+        assert(sbuf.get_wrapped() == nullptr);
+        assert(sbuf2.get_wrapped() == &buf);
+
+        assert(buf.str() == "");
+        assert(buf2.str() == "ABC");
+    }
+    assert(buf.str() == "DEF");
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.assign/nonmember_swap.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// template <class charT, class traits, class Allocator>
+// void swap(basic_syncbuf<charT, traits, Allocator>&,
+//           basic_syncbuf<charT, traits, Allocator>&);
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    std::syncbuf sbuf{&buf};
+    std::syncbuf nullbuf;
+
+    assert(sbuf.get_wrapped() == &buf);
+    assert(nullbuf.get_wrapped() == nullptr);
+
+    std::swap(sbuf, nullbuf);
+
+    assert(sbuf.get_wrapped() == nullptr);
+    assert(nullbuf.get_wrapped() == &buf);
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.cons/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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type*, const Allocator&);
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::syncbuf::allocator_type a;
+    std::syncbuf buf{nullptr, a};
+    assert(buf.get_allocator() == a);
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.cons/copy.fail.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf(const basic_syncbuf& rhs); // implicitly deleted
+
+#include <syncstream>
+
+std::syncbuf &get();
+
+int main(int, char**)
+{
+    std::syncbuf sb = get(); // expected-error {{call to implicitly-deleted copy constructor}}
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.cons/default.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// explicit basic_syncbuf(streambuf_type* __obuf = nullptr);
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_convertible.h"
+
+
+int main(int, char**)
+{
+    static_assert(!test_convertible<std::syncbuf, std::stringbuf *>(), "");
+    static_assert(!test_convertible<std::syncbuf, std::nullptr_t>(), "");
+
+    std::syncbuf buf;
+    assert(buf.get_wrapped() == nullptr);
+    assert(buf.get_allocator() == std::allocator<std::syncbuf::char_type>{});
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.cons/explicit.compile.fail.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// explicit basic_syncbuf(streambuf_type* __obuf = nullptr);
+
+#include <syncstream>
+
+
+int main(int, char**)
+{
+    std::stringbuf s;
+    std::syncbuf sb = &s;
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.cons/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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// basic_syncbuf();
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf sbuf;
+    std::syncbuf buf{&sbuf};
+    assert(buf.get_wrapped() == &sbuf);
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.dtor/dtor.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// ~basic_syncbuf();
+
+#include <syncstream>
+#include <cassert>
+
+
+static bool emit_threw;
+
+// std::basic_syncbuf::emit is not virtual, but with a non empty buffer
+// and non null wrapped streambuf, emit will call sputn on the streambuf.
+struct test : public std::stringbuf
+{
+    std::streamsize xsputn(const char *, std::streamsize n) override
+    {
+        emit_threw = true;
+        return n;
+    }
+};
+
+
+int main(int, char**)
+{
+    {
+        try {
+            test t;
+            std::syncbuf s{&t};
+            s.sputn("ABC", 3);
+        } catch (int i) {
+            assert(false);
+        }
+        assert(emit_threw);
+    }
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// bool emit();
+
+#include <syncstream>
+#include <cassert>
+
+
+struct bad_sputn : public std::stringbuf
+{
+    std::streamsize xsputn(const char *, std::streamsize n) override
+    {
+        return n - 1;
+    }
+};
+
+struct bad_sync : public std::stringbuf
+{
+    int sync() override
+    {
+        return -1;
+    }
+};
+
+struct pubsync : public std::syncbuf
+{
+    using std::syncbuf::sync;
+};
+
+int main(int, char**)
+{
+    {
+        std::stringbuf sbuf;
+        {
+            std::syncbuf buf{&sbuf};
+            buf.sputn("world", 5);
+            assert(buf.emit());
+            sbuf.sputn("Hello ", 6);
+        }
+        assert(sbuf.str() == "worldHello ");
+    }
+
+    {
+        std::syncbuf buf{nullptr};
+        assert(!buf.emit());
+    }
+
+    {
+        bad_sputn sbuf;
+        std::syncbuf buf{&sbuf};
+        buf.sputn("ABC", 3);
+        assert(!buf.emit());
+    }
+
+    {
+        bad_sync sbuf;
+        pubsync buf;
+        buf.sputn("ABC", 3);
+        buf.sync();
+        assert(!buf.emit());
+    }
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.members/emit_mt.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// bool emit();
+
+#include <syncstream>
+#include <limits>
+#include <thread>
+#include <vector>
+#include <cassert>
+
+
+static void print_chars(std::streambuf *os, int to_print)
+{
+    std::syncbuf buf{os};
+    char c = to_print;
+    for (int i = 0; i < 10; ++i) {
+        std::this_thread::yield();
+        buf.sputn(&c, 1);
+    }
+}
+
+bool all_contigous_chars(const std::string &str)
+{
+    for (auto it = str.begin(), cur_end = it + 10, end = str.end();
+            it != end; it = cur_end, cur_end += 10) {
+        if (!std::all_of(it, cur_end, [it] (auto c) { return c == *it; }))
+            return false;
+    }
+    return true;
+}
+
+int main(int, char**)
+{
+    std::stringbuf buf;
+    std::vector<std::thread> threads;
+    for (int i = 0; i < std::numeric_limits<unsigned char>::max(); ++i)
+        threads.emplace_back(print_chars, &buf, i);
+
+    for (auto &t : threads)
+        t.join();
+
+    auto str = buf.str();
+    assert(str.size() == 10 * threads.size());
+    assert(all_contigous_chars(str));
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.members/set_emit_on_sync.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf;
+
+// void set_emit_on_sync(bool) noexcept;
+
+#include <syncstream>
+#include <cassert>
+
+bool emit_called;
+
+// std::basic_syncbuf::emit is not virtual, but with a non empty buffer
+// and non null wrapped streambuf, emit will call sputn on the streambuf.
+struct test : public std::stringbuf
+{
+    std::streamsize xsputn(const char *, std::streamsize n) override
+    {
+        emit_called = true;
+        return n;
+    }
+};
+
+struct public_sync : public std::syncbuf
+{
+    using std::syncbuf::syncbuf;
+    using std::syncbuf::sync;
+};
+
+
+int main(int, char**)
+{
+    {
+        test t;
+        public_sync s{&t};
+        s.sputn("ABC", 3);
+        s.sync();
+        assert(!emit_called);
+    }
+    {
+        emit_called = false;
+        test t;
+        public_sync s{&t};
+        s.sputn("ABC", 3);
+        s.set_emit_on_sync(true);
+        s.sync();
+        assert(emit_called); 
+    }
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/syncstream.syncbuf.members/sputn.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
+
+// <syncstream>
+
+// template <class charT,
+//           class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+// class basic_syncbuf : public basic_streambuf<charT, traits>;
+
+// From basic_streambuf<charT, traits>
+// streamsize sputn(const char_type*, streamsize);
+
+// ~basic_syncbuf();
+
+#include <syncstream>
+#include <cassert>
+
+
+int main(int, char**)
+{
+    std::stringbuf sbuf;
+    {
+        std::syncbuf buf{&sbuf};
+        buf.sputn("world", 5);
+        sbuf.sputn("Hello ", 6);
+    }
+    assert(sbuf.str() == "Hello world");
+
+  return 0;
+}

libcxx/test/std/input.output/syncstream/syncstream.syncbuf/types.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
+
+// <syncstream>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_syncstream
+// {
+// public:
+//     // types:
+//     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;
+
+#include <syncstream>
+#include <type_traits>
+
+
+int main(int, char**)
+{
+    static_assert((std::is_same<std::syncbuf::char_type, char>::value), "");
+    static_assert((std::is_same<std::syncbuf::traits_type, std::char_traits<char> >::value), "");
+    static_assert((std::is_same<std::syncbuf::int_type, std::char_traits<char>::int_type>::value), "");
+    static_assert((std::is_same<std::syncbuf::pos_type, std::char_traits<char>::pos_type>::value), "");
+    static_assert((std::is_same<std::syncbuf::off_type, std::char_traits<char>::off_type>::value), "");
+    static_assert((std::is_same<std::syncbuf::traits_type, std::char_traits<char>>::value), "");
+    static_assert((std::is_same<std::syncbuf::allocator_type, std::allocator<char>>::value), "");
+
+    static_assert((std::is_same<std::wsyncbuf::char_type, wchar_t>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::traits_type, std::char_traits<wchar_t> >::value), "");
+    static_assert((std::is_same<std::wsyncbuf::int_type, std::char_traits<wchar_t>::int_type>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::pos_type, std::char_traits<wchar_t>::pos_type>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::off_type, std::char_traits<wchar_t>::off_type>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::traits_type, std::char_traits<wchar_t>>::value), "");
+    static_assert((std::is_same<std::wsyncbuf::allocator_type, std::allocator<wchar_t>>::value), "");
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

# C++2a
     "headers": ["atomic", "memory"],
     "unimplemented": True,
     "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    }, {
     "name": "__cpp_lib_constexpr_dynamic_alloc",
     "values": { "c++2a": int(201907) },
     "headers": ["memory"]
-   },
+   }, {
+    "name": "__cpp_lib_syncbuf",
+    "values": {"c++2a": int(201803) },
+    "headers": ["syncstream"]
+   }
 ]], key=lambda tc: tc["name"])
 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.
 #
 # For example, when threads are not supported, any feature-test-macro test
 # that includes <thread> should be marked as UNSUPPORTED, because including
 # <thread> is a hard error in that case.