[libc++] Implement P0627R6 (Function to mark unreachable code)

[• Quuxplusone]

libcxx/include/__utility/unreachable.h

19

@ldionne @mstorsjo perhaps: What's the best way to get this to do __assume(false) on MSVC? Should we introduce a __libcpp_unreachable()?... Oh wait, we already have one. In libcxx/include/cstdlib we have:

#ifdef __GNUC__
#define _LIBCPP_UNREACHABLE() __builtin_unreachable()
#else
#define _LIBCPP_UNREACHABLE() _VSTD::abort()
#endif

Let's do something in this PR to normalize the situation. Perhaps involving __has_builtin, perhaps involving defined(_MSC_VER), but the end result should be that libc++'s std::unreachable is implemented in terms of _LIBCPP_UNREACHABLE.

[mstorsjo]

libcxx/include/__utility/unreachable.h

19

FWIW, in practice, all our cases of "MSVC" in our codebase is clang-cl only, as libcxx isn't usable with MSVC proper - so even in an MSVC/non-GNUC config, it would end up supporting Clang's builtins.

(But a __has_builtin check doesn't hurt of course - and might be needed for other non-Clang, non-GCC compilers, if we support any such).

[philnik]

• Introduce __unreachable() for previous standard versions and remove _LIBCPP_UNREACHABLE()

[ldionne]

We should add a test, at least a .compile.pass.cpp test that we're defining the function and that it returns void. Also:

• We should update the feature-test macro
• We should add a release note for this feature (I want to be aggressive about release-noting the features we implement)
• We should also add a libc++ specific test (should be a .fail.cpp) that executes std::unreachable(), which would confirm that we somehow stop the execution of the program when encountered. Basically, I'd like a test that fails if std::unreachable() were implemented as an empty function. This is libc++ specific since technically, executing it is undefined behavior (but we know what we actually do).

libcxx/include/__utility/unreachable.h

19

I believe we should use __has_builtin(__builtin_unreachable) here instead -- that would avoid hardcoding compiler knowledge.

[philnik]

In D119152#3306155, @ldionne wrote:

We should add a test, at least a .compile.pass.cpp test that we're defining the function and that it returns void. Also:

• We should update the feature-test macro
• We should add a release note for this feature (I want to be aggressive about release-noting the features we implement)
• We should also add a libc++ specific test (should be a .fail.cpp) that executes std::unreachable(), which would confirm that we somehow stop the execution of the program when encountered. Basically, I'd like a test that fails if std::unreachable() were implemented as an empty function. This is libc++ specific since technically, executing it is undefined behavior (but we know what we actually do).

How do you expect the libc++-specific test to look? The compiler won't ignore that there is a __builtin_unreachable in the way and just remove all the code after that. We don't control the behavior in this case. We don't even have to do anything in unreachable(). It can just be empty and marked with [[noreturn]] and it would work pretty much the same. https://godbolt.org/z/GvbnG76nW

[philnik]

• Address comments

[• Quuxplusone]

libcxx/include/__utility/unreachable.h

19

IMHO we should name this function __libcpp_unreachable; just __unreachable seems in danger of stepping on some compiler's builtin or something.
Otherwise, I have no objection to this approach. Looking in <cstdlib>, it turns out that it was already impossible for users to -D_LIBCPP_UNREACHABLE=anything-else, so we're not even breaking any unsupported-but-working thing any user might be doing. And the call sites don't need std:: because it takes no arguments, so ADL isn't a problem.

libcxx/include/charconv

91

Can we remove this? If not, let's at least remove the comment (which is wrong now).

libcxx/include/fstream

188

Can we remove this now? (The answer, if "yes", will depend partly on politics: are we OK with breaking users who #include <fstream> and then call malloc or whatever.)

libcxx/src/filesystem/filesystem_common.h

13

As you probably noticed, right now this file uses #include "..." over #include <...>, and doesn't include any detail headers directly. I think there's no particular reason to preserve these invariants, but probably we want to s/""/<>/ in this file before we start mixing <> into it.

16–17

Can we remove this now?

[ldionne]

In D119152#3306276, @philnik wrote:

How do you expect the libc++-specific test to look? The compiler won't ignore that there is a __builtin_unreachable in the way and just remove all the code after that. We don't control the behavior in this case. We don't even have to do anything in unreachable(). It can just be empty and marked with [[noreturn]] and it would work pretty much the same. https://godbolt.org/z/GvbnG76nW

Sorry, .fail.cpp wasn't accurate. In <test>.pass.cpp:

// XFAIL: *

int main(int, char**) {
  std::unreachable();

  return 0;
}

When you run this, it will do zsh: illegal hardware instruction ./a.out if __builtin_unreachable() is used, and it will call std::abort() otherwise. In both cases, the executable will return with non-zero. And since the test is XFAILed, it will expect that non-zero and be reported as an expected failure.

If we implemented std::unreachable() as an empty body, it would result in "unexpected pass".

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.compile.pass.cpp

9

This needs some standard requirements.

I suggest running just the test you're adding locally under various standard modes (build/bin/llvm-lit -sv libcxx/test/<path-to-test> --param std=c++XX) to shake out basic failures and get faster turn around time.

[• Quuxplusone]

In D119152#3309138, @ldionne wrote:

In D119152#3306276, @philnik wrote:

How do you expect the libc++-specific test to look? [...] https://godbolt.org/z/GvbnG76nW

// XFAIL: *

int main(int, char**) {
  std::unreachable();

  return 0;
}

When you run this, it will do zsh: illegal hardware instruction ./a.out if __builtin_unreachable() is used [...]

I don't think that's guaranteed. __builtin_unreachable() just means "assume false"; it doesn't necessarily translate into a ud2 AFAIK, especially if we're talking about something that will work on both GCC and Clang.
Even on Clang at -O0, it seems to just flow off the unreachable end of main into whatever code follows that in memory: https://godbolt.org/z/fz6hh76P5

However, I think we could do a verify.cpp test: namely,

[[noreturn]] void f() { std::unreachable(); }

should not trigger Clang's diagnostic warning: function declared 'noreturn' should not return [-Winvalid-noreturn]. If it does, that's a bug.

[philnik]

In D119152#3309138, @ldionne wrote:

In D119152#3306276, @philnik wrote:

How do you expect the libc++-specific test to look? The compiler won't ignore that there is a __builtin_unreachable in the way and just remove all the code after that. We don't control the behavior in this case. We don't even have to do anything in unreachable(). It can just be empty and marked with [[noreturn]] and it would work pretty much the same. https://godbolt.org/z/GvbnG76nW

Sorry, .fail.cpp wasn't accurate. In <test>.pass.cpp:

// XFAIL: *

int main(int, char**) {
  std::unreachable();

  return 0;
}

When you run this, it will do zsh: illegal hardware instruction ./a.out if __builtin_unreachable() is used, and it will call std::abort() otherwise. In both cases, the executable will return with non-zero. And since the test is XFAILed, it will expect that non-zero and be reported as an expected failure.

If we implemented std::unreachable() as an empty body, it would result in "unexpected pass".

It will work even with an empty body. [[noreturn]] already informs the compiler that the function never returns. https://godbolt.org/z/qc97n59Kc. In this example The return value is even 0. There is just no way to verify the behavior. https://godbolt.org/z/fPGEYfEWv returns 1. The test is just to unstable.

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.compile.pass.cpp

9

Yeah I sometimes forget.

[ldionne]

In D119152#3309167, @Quuxplusone wrote:

I don't think that's guaranteed. __builtin_unreachable() just means "assume false"; it doesn't necessarily translate into a ud2 AFAIK, especially if we're talking about something that will work on both GCC and Clang.
Even on Clang at -O0, it seems to just flow off the unreachable end of main into whatever code follows that in memory: https://godbolt.org/z/fz6hh76P5

Oh right, that's why I was seeing invalid instruction. For some reason I thought Clang was inserting something like a __builtin_trap(). I stand corrected.

However, I think we could do a verify.cpp test: namely,

[[noreturn]] void f() { std::unreachable(); }

should not trigger Clang's diagnostic warning: function declared 'noreturn' should not return [-Winvalid-noreturn]. If it does, that's a bug.

Yeah, I think that's the best we can do. At least we'll test that unreachable() is marked as [[noreturn]].

[philnik]

libcxx/include/charconv

91

I wouldn't play with the header includes in this PR. We have to go through all headers anyways and remove unused includes.

libcxx/include/fstream

188

Same as above.

libcxx/src/filesystem/filesystem_common.h

13

Would you also be OK with me making a followup PR to clean up all the includes in src/?

[philnik]

• Fix CI

[Mordante]

Thanks for working on this!

libcxx/include/__utility/unreachable.h

11

Please update utils/generate_feature_test_macro_components.py to provide the __cpp_lib_unreachable feature-test macro.

13

std::abort requires #include <cstdlib>.

[philnik]

• Address comments

[philnik]

• rename to __libcpp_unreachable
• Fix modules

[philnik]

• Add test
• Don't rename __unreachable_sentinel

[• Quuxplusone]

LGTM except for the missing .verify.cpp test. (And the accidental sed casualty __libcpp_unreachable_sentinel, which you're already aware of and fixing.)
Once the .verify.cpp test exists, I'd like @ldionne to approve too, since he had requested changes.

libcxx/src/filesystem/filesystem_common.h

13

This is now D119561

libcxx/src/filesystem/operations.cpp

9

In filesystem_common.h you included the top-level <utility>; here and in locale.cpp you included only the detail header. I'm ambivalent whether we should consistently stick with top-level headers or consistently stick with the most granular detail headers; and in the process of making D119561 I discovered that we've already got a mix (although I think the granular ones are all due to @Mordante in <format>-related code). So, I'm ambivalent what to do here. No action required, I guess.

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.compile.pass.cpp

9

However, I think we could do a verify.cpp test: namely,
[[noreturn]] void f() { std::unreachable(); }
should not trigger Clang's diagnostic warning: function declared 'noreturn' should not return [-Winvalid-noreturn]. If it does, that's a bug.

Please add a .verify.cpp test along these lines. I'm not sure exactly how it should look; please just make sure that if you remove [[noreturn]] from __libcpp_unreachable, and re-ninja cxx, and re-run the test, that the test correctly fails.

[ldionne]

LGTM except for my comment about using a proper .verify.cpp test, which I'd like to see addressed.

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.compile.pass.cpp

17

I would like this to be a .verify.cpp test instead, with expected-no-diagnostics. You can look at e.g. libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.lazy.verify.cpp for how we do that.

Otherwise, we're relying on the fact that warnings are turned into errors in the test suite, and I find that to be slightly brittle.

[Mordante]

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.compile.pass.cpp

17

Instead of expected-no-diagnostics we can let clang issue a diagnostic and test for that.
Adding something like https://godbolt.org/z/fvzoonv5v will result in a diagnostic.
ADDITIONAL_COMPILE_FLAGS: -Wunreachable-code will add the required compiler flag to the test.

[philnik]

• Address comments

[ldionne]

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.compile.pass.cpp

17

Either way SGTM.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_stdatomic_h``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_contains``                     ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_resize_and_overwrite``         ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_to_underlying``                       ``202102L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_unreachable``                         *unimplemented*
+    ``__cpp_lib_unreachable``                         ``202202L``
     ================================================= =================
 

libcxx/docs/ReleaseNotes.rst

 see the `releases page <https://llvm.org/releases/>`_.
 
 What's New in Libc++ 15.0.0?
 ============================
 
 New Features
 ------------
 
+ - Implemented P0627R6 (Function to mark unreachable code)
+
 API Changes
 -----------
 
 - The ``_LIBCPP_ABI_UNSTABLE`` macro has been removed in favour of setting
   ``_LIBCPP_ABI_VERSION=2``. This should not have any impact on users because
   they were not supposed to set ``_LIBCPP_ABI_UNSTABLE`` manually, however we
   still feel that it is worth mentioning in the release notes in case some users
   had been doing it.

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2301R1 <https://wg21.link/P2301R1>`__","LWG","Add a ``pmr`` alias for ``std::stacktrace``","October 2021","",""
 "`P2321R2 <https://wg21.link/P2321R2>`__","LWG","``zip``","October 2021","|In Progress|",""
 "`P2340R1 <https://wg21.link/P2340R1>`__","LWG","Clarifying the status of the 'C headers'","October 2021","",""
 "`P2393R1 <https://wg21.link/P2393R1>`__","LWG","Cleaning up ``integer``-class types","October 2021","",""
 "`P2401R0 <https://wg21.link/P2401R0>`__","LWG","Add a conditional ``noexcept`` specification to ``std::exchange``","October 2021","|Complete|","14.0"
 "","","","","",""
 "`P0323R12 <https://wg21.link/P0323R12>`__","LWG","``std::expected``","February 2022","",""
 "`P0533R9 <https://wg21.link/P0533R9>`__","LWG","``constexpr`` for ``<cmath>`` and ``<cstdlib>``","February 2022","",""
-"`P0627R6 <https://wg21.link/P0627R6>`__","LWG","Function to mark unreachable code","February 2022","",""
+"`P0627R6 <https://wg21.link/P0627R6>`__","LWG","Function to mark unreachable code","February 2022","|Complete|","15.0"
 "`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","",""
 "`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","",""
 "`P2255R3 <https://wg21.link/P2255R3>`__","LWG","A type trait to detect reference binding to temporary","February 2022","",""
 "`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","",""
 "`P2387R3 <https://wg21.link/P2387R3>`__","LWG","Pipe support for user-defined range adaptors","February 2022","",""
 "`P2440R1 <https://wg21.link/P2440R1>`__","LWG","``ranges::iota``, ``ranges::shift_left`` and ``ranges::shift_right``","February 2022","",""
 "`P2441R2 <https://wg21.link/P2441R2>`__","LWG","``views::join_view``","February 2022","",""
 "`P2442R1 <https://wg21.link/P2442R1>`__","LWG","Windowing range adaptors: ``views::chunk`` and ``views::slide``","February 2022","",""
 "`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","",""
 "","","","","",""

libcxx/include/CMakeLists.txt

set(files
   __utility/move.h
   __utility/pair.h
   __utility/piecewise_construct.h
   __utility/priority_tag.h
   __utility/rel_ops.h
   __utility/swap.h
   __utility/to_underlying.h
   __utility/transaction.h
+  __utility/unreachable.h
   __variant/monostate.h
   algorithm
   any
   array
   atomic
   barrier
   bit
   bitset

libcxx/include/__filesystem/directory_entry.h

 #include <__errc>
 #include <__filesystem/file_status.h>
 #include <__filesystem/file_time_type.h>
 #include <__filesystem/file_type.h>
 #include <__filesystem/filesystem_error.h>
 #include <__filesystem/operations.h>
 #include <__filesystem/path.h>
 #include <__filesystem/perms.h>
+#include <__utility/unreachable.h>
 #include <chrono>
 #include <cstdint>
 #include <cstdlib>
 #include <iosfwd>
 #include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
file_type __get_sym_ft(error_code* __ec = nullptr) const {
     case _RefreshNonSymlink:
       file_status __st(__data_.__type_);
       if (__ec && !_VSTD_FS::exists(__st))
         *__ec = make_error_code(errc::no_such_file_or_directory);
       else if (__ec)
         __ec->clear();
       return __data_.__type_;
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_type __get_ft(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return __status(__p_, __ec).type();
     case _IterNonSymlink:
     case _RefreshNonSymlink:
     case _RefreshSymlink: {
       file_status __st(__data_.__type_);
       if (__ec && !_VSTD_FS::exists(__st))
         *__ec = make_error_code(errc::no_such_file_or_directory);
       else if (__ec)
         __ec->clear();
       return __data_.__type_;
     }
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status __get_status(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return __status(__p_, __ec);
     case _RefreshNonSymlink:
     case _RefreshSymlink:
       return file_status(__get_ft(__ec), __data_.__non_sym_perms_);
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status __get_symlink_status(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
       return __symlink_status(__p_, __ec);
     case _RefreshNonSymlink:
       return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_);
     case _RefreshSymlink:
     case _RefreshSymlinkUnresolved:
       return file_status(__get_sym_ft(__ec), __data_.__sym_perms_);
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t __get_size(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return _VSTD_FS::__file_size(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       file_status __st(__get_ft(&__m_ec));
       __handle_error("in directory_entry::file_size", __ec, __m_ec);
       if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
         errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
                                                        : errc::not_supported;
         __handle_error("in directory_entry::file_size", __ec,
                        make_error_code(__err_kind));
       }
       return __data_.__size_;
     }
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t __get_nlink(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return _VSTD_FS::__hard_link_count(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       (void)__get_ft(&__m_ec);
       __handle_error("in directory_entry::hard_link_count", __ec, __m_ec);
       return __data_.__nlink_;
     }
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_time_type __get_write_time(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return _VSTD_FS::__last_write_time(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       file_status __st(__get_ft(&__m_ec));
       __handle_error("in directory_entry::last_write_time", __ec, __m_ec);
       if (_VSTD_FS::exists(__st) &&
           __data_.__write_time_ == file_time_type::min())
         __handle_error("in directory_entry::last_write_time", __ec,
                        make_error_code(errc::value_too_large));
       return __data_.__write_time_;
     }
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
 private:
   _Path __p_;
   __cached_data __data_;
 };
 
 class __dir_element_proxy {

libcxx/include/__format/format_arg.h

 #define _LIBCPP___FORMAT_FORMAT_ARG_H
 
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
 #include <__memory/addressof.h>
+#include <__utility/unreachable.h>
 #include <__variant/monostate.h>
 #include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
   case __format::__arg_t::__int:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__int);
   case __format::__arg_t::__long_long:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__long_long);
   case __format::__arg_t::__i128:
 #ifndef _LIBCPP_HAS_NO_INT128
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__i128);
 #else
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
 #endif
   case __format::__arg_t::__unsigned:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__unsigned);
   case __format::__arg_t::__unsigned_long_long:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis),
                          __arg.__unsigned_long_long);
   case __format::__arg_t::__u128:
 #ifndef _LIBCPP_HAS_NO_INT128
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__u128);
 #else
-   _LIBCPP_UNREACHABLE();
+   __libcpp_unreachable();
 #endif
   case __format::__arg_t::__float:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__float);
   case __format::__arg_t::__double:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__double);
   case __format::__arg_t::__long_double:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__long_double);
   case __format::__arg_t::__const_char_type_ptr:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis),
                          __arg.__const_char_type_ptr);
   case __format::__arg_t::__string_view:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__string_view);
   case __format::__arg_t::__ptr:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__ptr);
   case __format::__arg_t::__handle:
     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__handle);
   }
-  _LIBCPP_UNREACHABLE();
+  __libcpp_unreachable();
 }
 
 template <class _Context>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg {
 public:
   class _LIBCPP_TEMPLATE_VIS handle;
 
   _LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept

libcxx/include/__format/formatter.h

 #include <__algorithm/copy.h>
 #include <__algorithm/fill_n.h>
 #include <__availability>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/parser_std_format_spec.h>
+#include <__utility/unreachable.h>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
_LIBCPP_ASSERT(__width > __size,
                  "Don't call this function when no padding is required");
   _LIBCPP_ASSERT(
       __align != __format_spec::_Flags::_Alignment::__default,
       "Caller should adjust the default to the value required by the type");
 
   size_t __fill = __width - __size;
   switch (__align) {
   case __format_spec::_Flags::_Alignment::__default:
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
 
   case __format_spec::_Flags::_Alignment::__left:
     return {0, __fill};
 
   case __format_spec::_Flags::_Alignment::__center: {
     // The extra padding is divided per [format.string.std]/3
     // __before = floor(__fill, 2);
     // __after = ceil(__fill, 2);
     size_t __before = __fill / 2;
     size_t __after = __fill - __before;
     return {__before, __after};
   }
   case __format_spec::_Flags::_Alignment::__right:
     return {__fill, 0};
   }
-  _LIBCPP_UNREACHABLE();
+  __libcpp_unreachable();
 }
 
 /**
  * Writes the input to the output with the required padding.
  *
  * Since the output column width is specified the function can be used for
  * ASCII and Unicode input.
  *

libcxx/include/__format/formatter_floating_point.h

 #include <__debug>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/parser_std_format_spec.h>
 #include <__utility/move.h>
+#include <__utility/unreachable.h>
 #include <charconv>
 #include <cmath>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #  include <locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer(__float_buffer<_Fp>& __buffer, _Tp __value, bool __negative,
     case _Flags::_Type::__general_lower_case:
       return __format_spec::__format_buffer_general_lower_case(__buffer, __value, __buffer.__precision(), __first);
 
     case _Flags::_Type::__general_upper_case:
       return __format_spec::__format_buffer_general_upper_case(__buffer, __value, __buffer.__precision(), __first);
 
     default:
       _LIBCPP_ASSERT(false, "The parser should have validated the type");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
   }
 };
 
 } //namespace __format_spec
 
 template <__formatter::__char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<float, _CharT>

libcxx/include/__format/formatter_integral.h

 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/transform.h>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/formatter.h>
 #include <__format/parser_std_format_spec.h>
+#include <__utility/unreachable.h>
 #include <array>
 #include <charconv>
 #include <concepts>
 #include <limits>
 #include <string>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #include <locale>
while (true) {
     if (__ptr != __end) {
       do {
         ++__ptr;
         // Skip grouping with a width of 0.
       } while (*__ptr == 0 && __ptr != __end);
     }
   }
 
-  _LIBCPP_UNREACHABLE();
+  __libcpp_unreachable();
 }
 
 template <class _Parser>
 requires __formatter::__char_type<typename _Parser::char_type>
 class _LIBCPP_TEMPLATE_VIS __formatter_integral : public _Parser {
 public:
   using _CharT = typename _Parser::char_type;
 
__format_unsigned_integral(unsigned_integral auto __value, bool __negative,
     }
     case _Flags::_Type::__hexadecimal_upper_case: {
       array<char, __buffer_size<decltype(__value), 16>()> __array;
       return __format_unsigned_integral(__array.begin(), __array.end(), __value,
                                         __negative, 16, __ctx, "0X");
     }
     default:
       _LIBCPP_ASSERT(false, "The parser should have validated the type");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
   }
 
   template <class _Tp>
   requires(same_as<char, _Tp> || same_as<wchar_t, _Tp>) _LIBCPP_HIDE_FROM_ABI
       auto __write(const _Tp* __first, const _Tp* __last, auto __out_it)
           -> decltype(__out_it) {
 

libcxx/include/__iterator/advance.h

 #define _LIBCPP___ITERATOR_ADVANCE_H
 
 #include <__config>
 #include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
+#include <__utility/unreachable.h>
 #include <concepts>
 #include <cstdlib>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
if constexpr (sized_sentinel_for<_Sp, _Ip>) {
         while (__i != __bound && __n < 0) {
           --__i;
           ++__n;
         }
       }
       return __n;
     }
 
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 };
 
 } // namespace __advance
 
 inline namespace __cpo {
   inline constexpr auto advance = __advance::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ADVANCE_H

libcxx/include/__utility/unreachable.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_UNREACHABLE_H
+#define _LIBCPP___UTILITY_UNREACHABLE_H
+
+#include <__config>
+#include <cstdlib>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __libcpp_unreachable()
+{
+#if __has_builtin(__builtin_unreachable)
+  __builtin_unreachable();
+#else
+  std::abort();
+#endif
+}
+
+#if _LIBCPP_STD_VER > 20
+
+[[noreturn]] _LIBCPP_HIDE_FROM_ABI inline void unreachable() { __libcpp_unreachable(); }
+
+#endif // _LIBCPP_STD_VER > 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif

libcxx/include/array

 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__tuple>
+#include <__utility/unreachable.h>
 #include <algorithm>
-#include <cstdlib> // for _LIBCPP_UNREACHABLE
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
     _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return 0;}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;}
 
     // element access:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator[](size_type) _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference operator[](size_type) const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference at(size_type) {
       __throw_out_of_range("array<T, 0>::at");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference at(size_type) const {
       __throw_out_of_range("array<T, 0>::at");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference front() _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference front() const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference back() _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const_reference back() const _NOEXCEPT {
       _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
 };
 
 
-#if _LIBCPP_STD_VER >= 17
+#if _LIBCPP_STD_VER > 14
 template<class _Tp, class... _Args,
          class = enable_if_t<__all<_IsSame<_Tp, _Args>::value...>::value>
          >
 array(_Tp, _Args...)
   -> array<_Tp, 1 + sizeof...(_Args)>;
 #endif
 
 template <class _Tp, size_t _Size>

libcxx/include/charconv

 */
 
 #include <__availability>
 #include <__bits>
 #include <__charconv/chars_format.h>
 #include <__charconv/from_chars_result.h>
 #include <__charconv/to_chars_result.h>
 #include <__config>
+#include <__debug>
 #include <__errc>
+#include <__utility/unreachable.h>
 #include <cmath> // for log2f
 #include <cstdint>
-#include <cstdlib> // for _LIBCPP_UNREACHABLE
+#include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <type_traits>
 
-#include <__debug>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
if (__value < __base_3)
       return __r + 3;
     if (__value < __base_4)
       return __r + 4;
 
     __value /= __base_4;
     __r += 4;
   }
 
-  _LIBCPP_UNREACHABLE();
+  __libcpp_unreachable();
 }
 
 template <typename _Tp>
 _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     false_type)
 {

libcxx/include/cstdlib

 
 #include <__config>
 #include <stdlib.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifdef __GNUC__
-#define _LIBCPP_UNREACHABLE() __builtin_unreachable()
-#else
-#define _LIBCPP_UNREACHABLE() _VSTD::abort()
-#endif
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::size_t _LIBCPP_USING_IF_EXISTS;
 using ::div_t _LIBCPP_USING_IF_EXISTS;
 using ::ldiv_t _LIBCPP_USING_IF_EXISTS;
 using ::lldiv_t _LIBCPP_USING_IF_EXISTS;
 using ::atof _LIBCPP_USING_IF_EXISTS;
 using ::atoi _LIBCPP_USING_IF_EXISTS;

libcxx/include/fstream

 }  // std
 
 */
 
 #include <__availability>
 #include <__config>
 #include <__debug>
 #include <__locale>
+#include <__utility/unreachable.h>
 #include <cstdio>
 #include <cstdlib>
 #include <istream>
 #include <ostream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif
 
const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(
   case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
     return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
   case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
   case ios_base::in | ios_base::app | ios_base::binary:
     return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
   default:
     return nullptr;
   }
-  _LIBCPP_UNREACHABLE();
+  __libcpp_unreachable();
 }
 
 template <class _CharT, class _Traits>
 basic_filebuf<_CharT, _Traits>*
 basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 {
     basic_filebuf<_CharT, _Traits>* __rt = nullptr;
     if (__file_ == nullptr)

libcxx/include/module.modulemap

module __utility {
       module move                { private header "__utility/move.h" }
       module pair                { private header "__utility/pair.h" }
       module piecewise_construct { private header "__utility/piecewise_construct.h" }
       module priority_tag        { private header "__utility/priority_tag.h" }
       module rel_ops             { private header "__utility/rel_ops.h" }
       module swap                { private header "__utility/swap.h" }
       module to_underlying       { private header "__utility/to_underlying.h" }
       module transaction         { private header "__utility/transaction.h" }
+      module unreachable         { private header "__utility/unreachable.h" }
     }
   }
   module valarray {
     header "valarray"
     export initializer_list
     export *
   }
   module variant {

libcxx/include/utility

 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/priority_tag.h>
 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
 #include <__utility/to_underlying.h>
 #include <__utility/transaction.h>
+#include <__utility/unreachable.h>
 #include <compare>
 #include <initializer_list>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_UTILITY

libcxx/include/version

 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
 // # define __cpp_lib_stacktrace                           202011L
 // # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
 # define __cpp_lib_string_resize_and_overwrite          202110L
 # define __cpp_lib_to_underlying                        202102L
-// # define __cpp_lib_unreachable                          202202L
+# define __cpp_lib_unreachable                          202202L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

libcxx/src/filesystem/filesystem_common.h

 //===----------------------------------------------------------------------===////
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===////
 
 #ifndef FILESYSTEM_COMMON_H
 #define FILESYSTEM_COMMON_H
 
 #include "__config"
 #include "array"
 #include "chrono"
 #include "climits"
 #include "cstdarg"
-#include "cstdlib"
 #include "ctime"
 #include "filesystem"
 #include "ratio"
 #include "system_error"
+#include <utility>
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 #endif
 
 #if !defined(_LIBCPP_WIN32API)
T report(const error_code& ec) const {
     switch (bool(p1_) + bool(p2_)) {
     case 0:
       __throw_filesystem_error(what, ec);
     case 1:
       __throw_filesystem_error(what, *p1_, ec);
     case 2:
       __throw_filesystem_error(what, *p1_, *p2_, ec);
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 0)
   void report_impl(const error_code& ec, const char* msg, va_list ap) const {
     if (ec_) {
       *ec_ = ec;
       return;
     }
     string what =
         string("in ") + func_name_ + ": " + format_string_impl(msg, ap);
     switch (bool(p1_) + bool(p2_)) {
     case 0:
       __throw_filesystem_error(what, ec);
     case 1:
       __throw_filesystem_error(what, *p1_, ec);
     case 2:
       __throw_filesystem_error(what, *p1_, *p2_, ec);
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
   T report(const error_code& ec, const char* msg, ...) const {
     va_list ap;
     va_start(ap, msg);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {

libcxx/src/filesystem/operations.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__utility/unreachable.h>
 #include "filesystem"
 #include "array"
 #include "iterator"
 #include "string_view"
 #include "type_traits"
 #include "vector"
 #include "cstdlib"
 #include "climits"
case PS_InFilenames: {
       }
       return makeState(PS_InTrailingSep, Start, SepEnd);
     }
 
     case PS_InTrailingSep:
       return makeState(PS_AtEnd);
 
     case PS_AtEnd:
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
   }
 
   void decrement() noexcept {
     const PosPtr REnd = getBeforeFront();
     const PosPtr RStart = getCurrentTokenStartPos() - 1;
     if (RStart == REnd) // we're decrementing the begin
       return makeState(PS_BeforeBegin);
case PS_InFilenames: {
       }
       TkStart = consumeName(SepEnd, REnd);
       return makeState(PS_InFilenames, TkStart + 1, SepEnd + 1);
     }
     case PS_InRootDir:
       return makeState(PS_InRootName, Path.data(), RStart + 1);
     case PS_InRootName:
     case PS_BeforeBegin:
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
   }
 
   /// \brief Return a view with the "preferred representation" of the current
   ///   element. For example trailing separators are represented as a '.'
   string_view_t operator*() const noexcept {
     switch (State) {
     case PS_BeforeBegin:
     case PS_AtEnd:
       return PS("");
     case PS_InRootDir:
       if (RawEntry[0] == '\\')
         return PS("\\");
       else
         return PS("/");
     case PS_InTrailingSep:
       return PS("");
     case PS_InRootName:
     case PS_InFilenames:
       return RawEntry;
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   explicit operator bool() const noexcept {
     return State != PS_BeforeBegin && State != PS_AtEnd;
   }
 
   PathParser& operator++() noexcept {
     increment();
PosPtr getNextTokenStartPos() const noexcept {
     case PS_InRootName:
     case PS_InRootDir:
     case PS_InFilenames:
       return &RawEntry.back() + 1;
     case PS_InTrailingSep:
     case PS_AtEnd:
       return getAfterBack();
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   /// \brief Return a pointer to the first character in the currently lexed
   ///   element.
   PosPtr getCurrentTokenStartPos() const noexcept {
     switch (State) {
     case PS_BeforeBegin:
     case PS_InRootName:
       return &Path.front();
     case PS_InRootDir:
     case PS_InFilenames:
     case PS_InTrailingSep:
       return &RawEntry.front();
     case PS_AtEnd:
       return &Path.back() + 1;
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }
 
   // Consume all consecutive separators.
   PosPtr consumeAllSeparators(PosPtr P, PosPtr End) const noexcept {
     if (P == nullptr || P == End || !isSeparator(*P))
       return nullptr;
     const int Inc = P < End ? 1 : -1;
     P += Inc;
case 0:
       return detail::format_string("filesystem error: %s", derived_what);
     case 1:
       return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "]",
                                    derived_what, path1().c_str());
     case 2:
       return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "] [" PATH_CSTR_FMT "]",
                                    derived_what, path1().c_str(), path2().c_str());
     }
-    _LIBCPP_UNREACHABLE();
+    __libcpp_unreachable();
   }();
 }
 
 static path __do_absolute(const path& p, path* cwd, error_code* ec) {
   if (ec)
     ec->clear();
   if (p.is_absolute())
     return p;
bool __fs_is_empty(const path& p, error_code* ec) {
   else if (is_directory(st)) {
     auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
     if (ec && *ec)
       return false;
     return it == directory_iterator{};
   } else if (is_regular_file(st))
     return static_cast<uintmax_t>(pst.st_size) == 0;
 
-  _LIBCPP_UNREACHABLE();
+  __libcpp_unreachable();
 }
 
 static file_time_type __extract_last_write_time(const path& p, const StatT& st,
                                                 error_code* ec) {
   using detail::fs_time;
   ErrorHandler<file_time_type> err("last_write_time", ec, &p);
 
   auto ts = detail::extract_mtime(st);
case PK_DotDot: {
       break;
     }
     case PK_Dot:
     case PK_TrailingSep: {
       MaybeNeedTrailingSep = true;
       break;
     }
     case PK_None:
-      _LIBCPP_UNREACHABLE();
+      __libcpp_unreachable();
     }
   }
   // [fs.path.generic]p6.8: If the path is empty, add a dot.
   if (Parts.empty())
     return PS(".");
 
   // [fs.path.generic]p6.7: If the last filename is dot-dot, remove any
   // trailing directory-separator.

libcxx/src/locale.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
 //
 //===----------------------------------------------------------------------===//
 
 // On Solaris, we need to define something to make the C99 parts of localeconv
 // visible.
 #ifdef __sun__
 #define _LCONV_C99
 #endif
 
+#include <__utility/unreachable.h>
 #include "algorithm"
 #include "clocale"
 #include "codecvt"
 #include "cstdio"
 #include "cstdlib"
 #include "cstring"
 #include "locale"
 #include "string"
#else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
   // translate into a different single byte.
   if (is_narrow_non_breaking_space(ptr) || is_non_breaking_space(ptr)) {
     dest = ' ';
     return true;
   }
 
   return false;
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-  _LIBCPP_UNREACHABLE();
+  __libcpp_unreachable();
 }
 
 
 // numpunct<char> && numpunct<wchar_t>
 
 locale::id numpunct< char  >::id;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 locale::id numpunct<wchar_t>::id;

libcxx/src/strstream.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__utility/unreachable.h>
 #include "strstream"
 #include "algorithm"
 #include "climits"
 #include "cstring"
 #include "cstdlib"
 #include "__debug"
 #include "__undef_macros"
 
if (legal)
             break;
         case ios::cur:
             newoff = (pos_in ? gptr() : pptr()) - eback();
             break;
         case ios::end:
             newoff = seekhigh - eback();
             break;
         default:
-            _LIBCPP_UNREACHABLE();
+            __libcpp_unreachable();
         }
         newoff += __off;
         if (0 <= newoff && newoff <= seekhigh - eback())
         {
             char* newpos = eback() + newoff;
             if (pos_in)
                 setg(eback(), newpos, _VSTD::max(newpos, egptr()));
             if (pos_out)

libcxx/test/libcxx/diagnostics/detail.headers/utility/unreachable.module.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__utility/unreachable.h'}}
+#include <__utility/unreachable.h>

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

 
 # ifndef __cpp_lib_tuples_by_type
 #   error "__cpp_lib_tuples_by_type should be defined in c++2b"
 # endif
 # if __cpp_lib_tuples_by_type != 201304L
 #   error "__cpp_lib_tuples_by_type should have the value 201304L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_unreachable
-#     error "__cpp_lib_unreachable should be defined in c++2b"
-#   endif
-#   if __cpp_lib_unreachable != 202202L
-#     error "__cpp_lib_unreachable should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_unreachable
-#     error "__cpp_lib_unreachable should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_unreachable
+#   error "__cpp_lib_unreachable should be defined in c++2b"
+# endif
+# if __cpp_lib_unreachable != 202202L
+#   error "__cpp_lib_unreachable should have the value 202202L in c++2b"
+# endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

 
 # ifndef __cpp_lib_unordered_map_try_emplace
 #   error "__cpp_lib_unordered_map_try_emplace should be defined in c++2b"
 # endif
 # if __cpp_lib_unordered_map_try_emplace != 201411L
 #   error "__cpp_lib_unordered_map_try_emplace should have the value 201411L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_unreachable
-#     error "__cpp_lib_unreachable should be defined in c++2b"
-#   endif
-#   if __cpp_lib_unreachable != 202202L
-#     error "__cpp_lib_unreachable should have the value 202202L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_unreachable
-#     error "__cpp_lib_unreachable should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_unreachable
+#   error "__cpp_lib_unreachable should be defined in c++2b"
+# endif
+# if __cpp_lib_unreachable != 202202L
+#   error "__cpp_lib_unreachable should have the value 202202L in c++2b"
+# endif
 
 # ifndef __cpp_lib_unwrap_ref
 #   error "__cpp_lib_unwrap_ref should be defined in c++2b"
 # endif
 # if __cpp_lib_unwrap_ref != 201811L
 #   error "__cpp_lib_unwrap_ref should have the value 201811L in c++2b"
 # endif
 

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <utility>
+#include <type_traits>
+
+static_assert(std::is_same_v<decltype(std::unreachable()), void>);

libcxx/test/std/utilities/utility/utility.unreachable/unreachable.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <utility>
+
+[[noreturn]] void unreachable() { std::unreachable(); } // expected-no-diagnostics

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_unordered_map_try_emplace",
     "values": { "c++17": 201411 },
     "headers": ["unordered_map"],
   }, {
     "name": "__cpp_lib_unreachable",
     "values": { "c++2b": 202202 },
     "headers": ["utility"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_unwrap_ref",
     "values": { "c++20": 201811 },
     "headers": ["functional"],
   }, {
     "name": "__cpp_lib_variant",
     "values": { "c++17": 202102 },
     "headers": ["variant"],