[N4917] Add freestanding C++ support for libc++ for support C++23 freestanding

[trcrsired]

Summary

Current GNU libstdc++ supports --disable-hosted-libstdcxx to support freestanding and allow hosted toolchain to use -ffreestanding flag to use freestanding C++. However LLVM libc++ does not provide these features. Leaving C++ extremely difficult for writing operating systems or using libcxx to bootstrap libc (MLIBC for example)

This patch adds a new toggle -DLIBCXX_FREESTANDING to cmake that would allow using libcxx with freestanding. Users can also use native toolchain with libcxx to deploy freestanding one.

Besides what N4917, we also provide extra headers like what libstdc++ does.

//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

// Test that _LIBCPP_FREESTANDING is not defined when -ffreestanding is not passed
// to the compiler but defined when -ffreestanding is passed to the compiler.

// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only %s
// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only -ffreestanding %s

#include <__config>

#if defined(__has_feature)
#  if __has_feature(modules)
#    define _LIBCPP_FREESTANDING_NO_TEST_MODULES
#  endif
#elif defined(__cpp_modules)
#  define _LIBCPP_FREESTANDING_NO_TEST_MODULES
#endif

#if defined(_LIBCPP_FREESTANDING) && !defined(_LIBCPP_FREESTANDING_NO_TEST_MODULES)
#  include <cstddef>
#  include <limits>
#  include <cfloat>
#  include <version>
#  include <cstdint>
#  include <cstdlib>
#  include <new>
#  include <typeinfo>
#  if __has_include(<source_location>)
#    include <source_location>
#  endif
#  include <exception>
#  include <initializer_list>
#  include <compare>
#  include <coroutine>
#  include <cstdarg>
#  include <concepts>
#  include <type_traits>
#  include <bit>
#  include <atomic>
#  include <utility>
#  include <tuple>
#  include <memory>
#  include <functional>
#  include <ratio>
#  include <iterator>
#  include <ranges>
#  include <typeinfo>

/*
We tested these headers are for preventing build issues
*/
#  include <iosfwd>
#  include <cstdio>
#  include <cerrno>
#  include <cstring>
#  include <cmath>
#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
#    include <cwchar>
#  endif
/*
 * libc++ libstdc++ like extensions
 */
#  include <array>
#  include <span>
#  include <algorithm>
#  include <bitset>
#  include <variant>
#  include <optional>
#  include <numbers>
#  include <scoped_allocator>
#  include <typeindex>
#  include <string_view>
#  include <numeric>
#  include <complex>
#  include <chrono>
#  include <charconv>
#  include <expected>
#  include <random>
#  include <any>

/*
 * libc++ Containers Extensions
 */
#  include <vector>
#  include <deque>
#  include <string>
#  include <stack>
#  include <queue>
#  include <list>
#  include <forward_list>
#  include <map>
#  include <set>
#  include <unordered_set>
#  include <unordered_map>
#  if __has_include(<mdspan>)
#    include <mdspan>
#  endif
#  include <valarray>

#  if _LIBCPP_STD_VER < 20
#    include <ciso646>
#    if __has_include(<cstdalign>)
#      include <cstdalign>
#    endif
#    include <cstdbool>
#  endif
#endif

source_location header is missing in libcxx currently and I know it would add in the future by other commits, I won't put them here. We provide all freestanding headers libstdc++ provides for freestanding. We provide one extra header which is string_view. However their functionalities may work very differently in the hosted one.

[philnik]

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

[ldionne]

Thanks for your interest in making libc++ work better on freestanding environments.

The path libc++ has taken so far is to carve parts of libc++ out based on CMake configuration time toggles, like LIBCXX_ENABLE_FILESYSTEM or LIBCXX_ENABLE_LOCALIZATION. Those are general in nature and can be cherry-picked to craft a specific configuration of libc++ that suits the exact need of a platform. In a way, this is more flexible than just a single "freestanding" toggle, and we've used it with great success in various scenarios. Is there a reason why that doesn't suit your needs?

Before pouring too much time into this, I would suggest agreeing on a design first. In particular, I think it would be interesting to have a single "Freestanding" toggle that implements what the C++ Standard describes as "Freestanding", however that should ideally be a composition of more general options (like the ones we have today, e.g. LIBCXX_ENABLE_LOCALIZATION). Also, we need to consider what changes are required in the test suite to support this.

[trcrsired]

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

This will allow a lot of things:

1. Writing windows kernel drivers without tweaking headers to get a toolchain.
2. To allow libcs like mlibc that uses C++ to write libc itself then build a full hosted one. Or you get trouble into chicken egg problem.
3. Allow writing custom operating systems that usually have no libc support.
4. To support truly freestanding environment. Embedded does not necessarily mean freestanding. What we mean is something like GNU or OS kernel.
5. To match the behavior of GNU libstdc++.

See here:
https://github.com/gcc-mirror/gcc/commits/master?after=ab8477af9949a7e6fcaf89c5f1dcf32788accf88+34&branch=master&path%5B%5D=libstdc%2B%2B-v3&qualified_name=refs%2Fheads%2Fmaster

Shortly. I need freestanding toolchains without libc support to make it more flexible.

BTW. libcxx has bugs of freestanding. The LIBCXX_FREESTANDING macro exists but it does not do anything. Many freestanding headers will rely on hosted C++ features which are not standard compliant.

I will ask libstdc++ dev Jonathan Wakely for helping reviewing this patch. Thank you

See: N4917

https://github.com/cplusplus/draft/releases/download/n4917/n4917.pdf

It requires a lot of more features to support for freestanding now. I am fixing this part to support C++23 freestanding.

[jwakely]

In D135911#3856719, @trcrsired wrote:

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

Libc++ is a hosted implementation, and so doesn't have to meet the requirements of a freestanding implementation. There is no ISO C++ compliance problem here.

If libc++ doesn't advertise itself as a freestanding implementation, then the requirements on freestanding implementations are irrelevant to it.

[jwakely]

In D135911#3856719, @trcrsired wrote:

I will ask libstdc++ dev Jonathan Wakely for helping reviewing this patch. Thank you

I'm not interested in doing that.

[ldionne]

To be clear -- I agree there is value in pursuing this as a matter of ISO C++ conformance (so we can claim that we support a Freestanding implementation). However, concretely, it is generally more useful to be able to disable only the parts that a platform doesn't support (or doesn't want to support) instead of picking the "Freestanding" subset as a whole, which may be excluding things that a platform could (and may want to) support.

I still think we should support Freestanding as a matter of ISO C++ conformance, however we should approach solving that problem from the stance that we've taken so far, i.e. by defining general-purpose carve-outs in the library that can be combined to create a specific version of the library that suits a platform's needs.

[trcrsired]

In D135911#3856741, @ldionne wrote:

To be clear -- I agree there is value in pursuing this as a matter of ISO C++ conformance (so we can claim that we support a Freestanding implementation). However, concretely, it is generally more useful to be able to disable only the parts that a platform doesn't support (or doesn't want to support) instead of picking the "Freestanding" subset as a whole, which may be excluding things that a platform could (and may want to) support.

I still think we should support Freestanding as a matter of ISO C++ conformance, however we should approach solving that problem from the stance that we've taken so far, i.e. by defining general-purpose carve-outs in the library that can be combined to create a specific version of the library that suits a platform's needs.

Then what are you going to do for supporting things like writing libc with C++? Or someone tries to use C++ to write their own operating system kernels?

Libc like mlibc they have to recreate their own non standard compliant C++ headers to write libc which adds tons of portability trap. The C++ freestanding headers usually tie specifically to the features of specific compilers. It just adds headache for everyone.

There are no headers at all. Not even cstddef exists. clang and GCC they by default provide freestanding C headers but no freestanding C++ headers.

C++ freestanding has been a long term issue (over 20 years) due to lack of proper support from toolchain. Let's just not make the situation even more deteriorating.

[trcrsired]

Support missed numeric header

[trcrsired]

Add test to freestanding.

Ensure -ffreestanding would work for all headers for hosted toolchain.

Add headers to tests in freestanding.sh

[philnik]

In D135911#3856719, @trcrsired wrote:

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

I don't think it makes sense to pursue building libc++ without a freestanding C library. We'd effectively have to implement it anyways, so we might as well require a freestanding libc. What exactly does libc++ not conform to as a freestanding library? IOW what can't be disabled that requires a hosted environment?

This will allow a lot of things:

1. Writing windows kernel drivers without tweaking headers to get a toolchain.
2. To allow libcs like mlibc that uses C++ to write libc itself then build a full hosted one. Or you get trouble into chicken egg problem.
3. Allow writing custom operating systems that usually have no libc support.
4. To support truly freestanding environment. Embedded does not necessarily mean freestanding. What we mean is something like GNU or OS kernel.

These seem to be generally good ideas, but doesn't answer my question: What problem do you run into when you try to do any of this?

5. To match the behavior of GNU libstdc++.

See here:
https://github.com/gcc-mirror/gcc/commits/master?after=ab8477af9949a7e6fcaf89c5f1dcf32788accf88+34&branch=master&path%5B%5D=libstdc%2B%2B-v3&qualified_name=refs%2Fheads%2Fmaster

I don't see why we should mimic what libstdc++ does.

Shortly. I need freestanding toolchains without libc support to make it more flexible.

BTW. libcxx has bugs of freestanding. The LIBCXX_FREESTANDING macro exists but it does not do anything. Many freestanding headers will rely on hosted C++ features which are not standard compliant.

Assuming you mean _LIBCPP_FREESTANDING, it indeed looks like it doesn't do anything and should be removed. What part of the freestanding library relies on hosted features?

[trcrsired]

In D135911#3856970, @philnik wrote:

In D135911#3856719, @trcrsired wrote:

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

I don't think it makes sense to pursue building libc++ without a freestanding C library. We'd effectively have to implement it anyways, so we might as well require a freestanding libc. What exactly does libc++ not conform to as a freestanding library? IOW what can't be disabled that requires a hosted environment?

This will allow a lot of things:

1. Writing windows kernel drivers without tweaking headers to get a toolchain.
2. To allow libcs like mlibc that uses C++ to write libc itself then build a full hosted one. Or you get trouble into chicken egg problem.
3. Allow writing custom operating systems that usually have no libc support.
4. To support truly freestanding environment. Embedded does not necessarily mean freestanding. What we mean is something like GNU or OS kernel.

These seem to be generally good ideas, but doesn't answer my question: What problem do you run into when you try to do any of this?

5. To match the behavior of GNU libstdc++.

See here:
https://github.com/gcc-mirror/gcc/commits/master?after=ab8477af9949a7e6fcaf89c5f1dcf32788accf88+34&branch=master&path%5B%5D=libstdc%2B%2B-v3&qualified_name=refs%2Fheads%2Fmaster

I don't see why we should mimic what libstdc++ does.

Shortly. I need freestanding toolchains without libc support to make it more flexible.

BTW. libcxx has bugs of freestanding. The LIBCXX_FREESTANDING macro exists but it does not do anything. Many freestanding headers will rely on hosted C++ features which are not standard compliant.

Assuming you mean _LIBCPP_FREESTANDING, it indeed looks like it doesn't do anything and should be removed. What part of the freestanding library relies on hosted features?

I am sure libcxx does not work with freestanding C headers as base either.
https://en.cppreference.com/w/c/language/conformance

Before C23 (which is not what C++23 accepts),
<float.h> Limits of floating-point types
<iso646.h> (C95) Alternative operator spellings
<limits.h> Ranges of integer types
<stdalign.h> (C11) alignas and alignof convenience macros
<stdarg.h> Variable arguments
<stdbool.h> (C99) Macros for boolean type
<stddef.h> Common macro definitions
<stdint.h> (C99) Fixed-width integer types
<stdnoreturn.h> (C11) noreturn convenience macro

Partially freestanding standard library headers
<string.h> (C23) String handling
Conditionally fully freestanding standard library headers
<fenv.h> (C23) Floating-point environment
<math.h> (C23) Common mathematics functions
Conditionally partially freestanding standard library headers
<stdlib.h> (C23) General utilities: memory management, program utilities, string conversions, random numbers, algorithms

What libcxx requires is something like a full POSIX C library which just assumes you have an operating system. Which does not makes sense.

Things like iostream, threading etc are clearly not something freestanding supports.

Problems? The code just does not compile or linking correctly. Simple.
You do not have any headers to use, no type_traits, no cstddef. Nothing my friend.

libcxx has a long history of assuming how things would work. Often, they are not working. For example, libcxx does not work for x86_64-w64-mingw32 with win32 or mcf thread model. It does not work for MSDOS either. All the features just assume it is a POSIX like platform.

You may talk about newlib, however newlib is not working all environments either (UEFI for example). And they have licensing issues. Still, it makes assumptions on how the toolchain provides headers and they are usually not portable.

If you are not working in freestanding environment as people like I do, then better just accept my commit so people like I who work in that environment would help maintain this part. Everyone will be happy.

[philnik]

In D135911#3856980, @trcrsired wrote:

In D135911#3856970, @philnik wrote:

In D135911#3856719, @trcrsired wrote:

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

I don't think it makes sense to pursue building libc++ without a freestanding C library. We'd effectively have to implement it anyways, so we might as well require a freestanding libc. What exactly does libc++ not conform to as a freestanding library? IOW what can't be disabled that requires a hosted environment?

This will allow a lot of things:

1. Writing windows kernel drivers without tweaking headers to get a toolchain.
2. To allow libcs like mlibc that uses C++ to write libc itself then build a full hosted one. Or you get trouble into chicken egg problem.
3. Allow writing custom operating systems that usually have no libc support.
4. To support truly freestanding environment. Embedded does not necessarily mean freestanding. What we mean is something like GNU or OS kernel.

These seem to be generally good ideas, but doesn't answer my question: What problem do you run into when you try to do any of this?

5. To match the behavior of GNU libstdc++.

See here:
https://github.com/gcc-mirror/gcc/commits/master?after=ab8477af9949a7e6fcaf89c5f1dcf32788accf88+34&branch=master&path%5B%5D=libstdc%2B%2B-v3&qualified_name=refs%2Fheads%2Fmaster

I don't see why we should mimic what libstdc++ does.

Shortly. I need freestanding toolchains without libc support to make it more flexible.

BTW. libcxx has bugs of freestanding. The LIBCXX_FREESTANDING macro exists but it does not do anything. Many freestanding headers will rely on hosted C++ features which are not standard compliant.

Assuming you mean _LIBCPP_FREESTANDING, it indeed looks like it doesn't do anything and should be removed. What part of the freestanding library relies on hosted features?

I am sure libcxx does not work with freestanding C headers as base either.
https://en.cppreference.com/w/c/language/conformance

Before C23 (which is not what C++23 accepts),
<float.h> Limits of floating-point types
<iso646.h> (C95) Alternative operator spellings
<limits.h> Ranges of integer types
<stdalign.h> (C11) alignas and alignof convenience macros
<stdarg.h> Variable arguments
<stdbool.h> (C99) Macros for boolean type
<stddef.h> Common macro definitions
<stdint.h> (C99) Fixed-width integer types
<stdnoreturn.h> (C11) noreturn convenience macro

Partially freestanding standard library headers
<string.h> (C23) String handling
Conditionally fully freestanding standard library headers
<fenv.h> (C23) Floating-point environment
<math.h> (C23) Common mathematics functions
Conditionally partially freestanding standard library headers
<stdlib.h> (C23) General utilities: memory management, program utilities, string conversions, random numbers, algorithms

What libcxx requires is something like a full POSIX C library which just assumes you have an operating system. Which does not makes sense.

Things like iostream, threading etc are clearly not something freestanding supports.

As @ldionne already mentioned, we have flags to disable parts of libc++. Specifically, you can disable threads, monotonic clock, filesystem, random device, localization and wide characters.

[trcrsired]

In D135911#3857023, @philnik wrote:

In D135911#3856980, @trcrsired wrote:

In D135911#3856970, @philnik wrote:

In D135911#3856719, @trcrsired wrote:

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

I don't think it makes sense to pursue building libc++ without a freestanding C library. We'd effectively have to implement it anyways, so we might as well require a freestanding libc. What exactly does libc++ not conform to as a freestanding library? IOW what can't be disabled that requires a hosted environment?

This will allow a lot of things:

1. Writing windows kernel drivers without tweaking headers to get a toolchain.
2. To allow libcs like mlibc that uses C++ to write libc itself then build a full hosted one. Or you get trouble into chicken egg problem.
3. Allow writing custom operating systems that usually have no libc support.
4. To support truly freestanding environment. Embedded does not necessarily mean freestanding. What we mean is something like GNU or OS kernel.

These seem to be generally good ideas, but doesn't answer my question: What problem do you run into when you try to do any of this?

5. To match the behavior of GNU libstdc++.

See here:
https://github.com/gcc-mirror/gcc/commits/master?after=ab8477af9949a7e6fcaf89c5f1dcf32788accf88+34&branch=master&path%5B%5D=libstdc%2B%2B-v3&qualified_name=refs%2Fheads%2Fmaster

I don't see why we should mimic what libstdc++ does.

Shortly. I need freestanding toolchains without libc support to make it more flexible.

BTW. libcxx has bugs of freestanding. The LIBCXX_FREESTANDING macro exists but it does not do anything. Many freestanding headers will rely on hosted C++ features which are not standard compliant.

Assuming you mean _LIBCPP_FREESTANDING, it indeed looks like it doesn't do anything and should be removed. What part of the freestanding library relies on hosted features?

I am sure libcxx does not work with freestanding C headers as base either.
https://en.cppreference.com/w/c/language/conformance

Before C23 (which is not what C++23 accepts),
<float.h> Limits of floating-point types
<iso646.h> (C95) Alternative operator spellings
<limits.h> Ranges of integer types
<stdalign.h> (C11) alignas and alignof convenience macros
<stdarg.h> Variable arguments
<stdbool.h> (C99) Macros for boolean type
<stddef.h> Common macro definitions
<stdint.h> (C99) Fixed-width integer types
<stdnoreturn.h> (C11) noreturn convenience macro

Partially freestanding standard library headers
<string.h> (C23) String handling
Conditionally fully freestanding standard library headers
<fenv.h> (C23) Floating-point environment
<math.h> (C23) Common mathematics functions
Conditionally partially freestanding standard library headers
<stdlib.h> (C23) General utilities: memory management, program utilities, string conversions, random numbers, algorithms

What libcxx requires is something like a full POSIX C library which just assumes you have an operating system. Which does not makes sense.

Things like iostream, threading etc are clearly not something freestanding supports.

As @ldionne already mentioned, we have flags to disable parts of libc++. Specifically, you can disable threads, monotonic clock, filesystem, random device, localization and wide characters.

The problem is that they are not enough. A lot of more you have to disable. Like stdio.h, string.h, stdlib.h, time.h ETC. None of them is freestanding.

[trcrsired]

Fix all potential formating issues and build failure.

[philnik]

In D135911#3857040, @trcrsired wrote:

In D135911#3857023, @philnik wrote:

In D135911#3856980, @trcrsired wrote:

In D135911#3856970, @philnik wrote:

In D135911#3856719, @trcrsired wrote:

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

I don't think it makes sense to pursue building libc++ without a freestanding C library. We'd effectively have to implement it anyways, so we might as well require a freestanding libc. What exactly does libc++ not conform to as a freestanding library? IOW what can't be disabled that requires a hosted environment?

This will allow a lot of things:

1. Writing windows kernel drivers without tweaking headers to get a toolchain.
2. To allow libcs like mlibc that uses C++ to write libc itself then build a full hosted one. Or you get trouble into chicken egg problem.
3. Allow writing custom operating systems that usually have no libc support.
4. To support truly freestanding environment. Embedded does not necessarily mean freestanding. What we mean is something like GNU or OS kernel.

These seem to be generally good ideas, but doesn't answer my question: What problem do you run into when you try to do any of this?

5. To match the behavior of GNU libstdc++.

See here:
https://github.com/gcc-mirror/gcc/commits/master?after=ab8477af9949a7e6fcaf89c5f1dcf32788accf88+34&branch=master&path%5B%5D=libstdc%2B%2B-v3&qualified_name=refs%2Fheads%2Fmaster

I don't see why we should mimic what libstdc++ does.

Shortly. I need freestanding toolchains without libc support to make it more flexible.

BTW. libcxx has bugs of freestanding. The LIBCXX_FREESTANDING macro exists but it does not do anything. Many freestanding headers will rely on hosted C++ features which are not standard compliant.

Assuming you mean _LIBCPP_FREESTANDING, it indeed looks like it doesn't do anything and should be removed. What part of the freestanding library relies on hosted features?

I am sure libcxx does not work with freestanding C headers as base either.
https://en.cppreference.com/w/c/language/conformance

Before C23 (which is not what C++23 accepts),
<float.h> Limits of floating-point types
<iso646.h> (C95) Alternative operator spellings
<limits.h> Ranges of integer types
<stdalign.h> (C11) alignas and alignof convenience macros
<stdarg.h> Variable arguments
<stdbool.h> (C99) Macros for boolean type
<stddef.h> Common macro definitions
<stdint.h> (C99) Fixed-width integer types
<stdnoreturn.h> (C11) noreturn convenience macro

Partially freestanding standard library headers
<string.h> (C23) String handling
Conditionally fully freestanding standard library headers
<fenv.h> (C23) Floating-point environment
<math.h> (C23) Common mathematics functions
Conditionally partially freestanding standard library headers
<stdlib.h> (C23) General utilities: memory management, program utilities, string conversions, random numbers, algorithms

What libcxx requires is something like a full POSIX C library which just assumes you have an operating system. Which does not makes sense.

Things like iostream, threading etc are clearly not something freestanding supports.

As @ldionne already mentioned, we have flags to disable parts of libc++. Specifically, you can disable threads, monotonic clock, filesystem, random device, localization and wide characters.

The problem is that they are not enough. A lot of more you have to disable. Like stdio.h, string.h, stdlib.h, time.h ETC. None of them is freestanding.

I think it would make sense to go through the list of C headers and decide on a case-by-case basis whether we want to rely on that header.
For example, it would probably be a good idea to remove any dependencies on stdio.h, but it doesn't make sense to remove dependencies on string.h. It's a very fundamental header and very simple to implement at least a basic version. IMO the C standard should actually require at least a subset of the header in freestanding mode. If there is any environment that doesn't provide the functions we use from that, I think it's reasonable to require the use of LLVM libc (or similar), which provides platform-agnostic implementations for these functions. The implementation there is probably a lot faster than anything we could provide in libc++ without basically duplicating LLVM libc.

[trcrsired]

This patch merge last twos and it should work now

[trcrsired]

I think it would make sense to go through the list of C headers and decide on a case-by-case basis whether we want to rely on that header.
For example, it would probably be a good idea to remove any dependencies on stdio.h, but it doesn't make sense to remove dependencies on string.h. It's a very fundamental header and very simple to implement at least a basic version. IMO the C standard should actually require at least a subset of the header in freestanding mode. If there is any environment that doesn't provide the functions we use from that, I think it's reasonable to require the use of LLVM libc (or similar), which provides platform-agnostic implementations for these functions. The implementation there is probably a lot faster than anything we could provide in libc++ without basically duplicating LLVM libc.

This is exactly what I am talking about that libcxx always makes wrong assumptions. Even those headers exist, you still cannot guarantee they are working headers. There is no reason to make any assumption on the implementations.

Just avoid including those headers in first place. You do not need them tbh.

BTW. you shouldn't need to implement those features either. GCC and clang always assumes memcpy, memmove, memset exist. However any other headers, unless WG14 and WG21 say something, we must avoid them at all costs.

In fact, you cannot even guarantee a correct implementation for memcpy. memcpy is tied to systems too. despite you can easily implement them. However, to implement them efficiently, only users know how to do that.

[trcrsired]

In D135911#3857150, @trcrsired wrote:

I think it would make sense to go through the list of C headers and decide on a case-by-case basis whether we want to rely on that header.
For example, it would probably be a good idea to remove any dependencies on stdio.h, but it doesn't make sense to remove dependencies on string.h. It's a very fundamental header and very simple to implement at least a basic version. IMO the C standard should actually require at least a subset of the header in freestanding mode. If there is any environment that doesn't provide the functions we use from that, I think it's reasonable to require the use of LLVM libc (or similar), which provides platform-agnostic implementations for these functions. The implementation there is probably a lot faster than anything we could provide in libc++ without basically duplicating LLVM libc.

This is exactly what I am talking about that libcxx always makes wrong assumptions. Even those headers exist, you still cannot guarantee they are working headers. There is no reason to make any assumption on the implementations.

Just avoid including those headers in first place. You do not need them tbh.

BTW. you shouldn't need to implement those features either. GCC and clang always assumes memcpy, memmove, memset exist. However any other headers, unless WG14 and WG21 say something, we must avoid them at all costs.

In fact, you cannot even guarantee a correct implementation for memcpy. memcpy is tied to systems too. despite you can easily implement them. However, to implement them efficiently, only users know how to do that.

I recently encounter an example on why detecting headers won't work. pdp11-aout provides its own libc. However that libc was written in 1960s probably, the code just could not compile with a C++ compiler since they use K&R style function declaration. None of those headers can be used. Making any assumptions on how libc works would create all sorts of issues.

That is why a LIBCXX_FREESTANDING toggle would be extremely useful since they avoid any assumptions on how libc is implemented.

[philnik]

! In D135911#3857157, @trcrsired wrote:

! In D135911#3857150, @trcrsired wrote:
I think it would make sense to go through the list of C headers and decide on a case-by-case basis whether we want to rely on that header.
For example, it would probably be a good idea to remove any dependencies on stdio.h, but it doesn't make sense to remove dependencies on string.h. It's a very fundamental header and very simple to implement at least a basic version. IMO the C standard should actually require at least a subset of the header in freestanding mode. If there is any environment that doesn't provide the functions we use from that, I think it's reasonable to require the use of LLVM libc (or similar), which provides platform-agnostic implementations for these functions. The implementation there is probably a lot faster than anything we could provide in libc++ without basically duplicating LLVM libc.

This is exactly what I am talking about that libcxx always makes wrong assumptions. Even those headers exist, you still cannot guarantee they are working headers. There is no reason to make any assumption on the implementations.

How is there no reason to assume that the C implementation is conforming? libc++ isn't aiming to be a C library, it aiming to be a conforming C++ library.

Just avoid including those headers in first place. You do not need them tbh.

We do need them to provide a quality implementation.

BTW. you shouldn't need to implement those features either. GCC and clang always assumes memcpy, memmove, memset exist. However any other headers, unless WG14 and WG21 say something, we must avoid them at all costs.

We definitely shouldn't avoid them at all costs. I see no reason it's not acceptable to require LLVM libc in freestanding if the functionality isn't provided by the native libc.

In fact, you cannot even guarantee a correct implementation for memcpy. memcpy is tied to systems too. despite you can easily implement them. However, to implement them efficiently, only users know how to do that.

We cannot guarantee it, but we can require it. That's not an unreasonable requirement on a C library.

I recently encounter an example on why detecting headers won't work. pdp11-aout provides its own libc. However that libc was written in 1960s probably, the code just could not compile with a C++ compiler since they use K&R style function declaration. None of those headers can be used. Making any assumptions on how libc works would create all sorts of issues.

I don't think it's reasonable to build a 2022 libc++ on a C library from the 1960s. That's not a use-case we aim to support.

That is why a LIBCXX_FREESTANDING toggle would be extremely useful since they avoid any assumptions on how libc is implemented.

If you can't assume anything about the C library it's impossible to implement a conforming freestanding C++ library. As said before, it's absolutely reasonable to assume a conforming C library.

[trcrsired]

In D135911#3856719, @trcrsired wrote:

In D135911#3856699, @philnik wrote:

What exactly is the problem you are trying to solve? libc++ is used in lots of embedded environments, just with parts that aren't possible to implement in that environment disabled.

To allow libcxx to build without libc and to satisfy ISO C++ standard.

This will allow a lot of things:

1. Writing windows kernel drivers without tweaking headers to get a toolchain.
2. To allow libcs like mlibc that uses C++ to write libc itself then build a full hosted one. Or you get trouble into chicken egg problem.
3. Allow writing custom operating systems that usually have no libc support.
4. To support truly freestanding environment. Embedded does not necessarily mean freestanding. What we mean is something like GNU or OS kernel.
5. To match the behavior of GNU libstdc++.

See here:
https://github.com/gcc-mirror/gcc/commits/master?after=ab8477af9949a7e6fcaf89c5f1dcf32788accf88+34&branch=master&path%5B%5D=libstdc%2B%2B-v3&qualified_name=refs%2Fheads%2Fmaster

Shortly. I need freestanding toolchains without libc support to make it more flexible.

BTW. libcxx has bugs of freestanding. The LIBCXX_FREESTANDING macro exists but it does not do anything. Many freestanding headers will rely on hosted C++ features which are not standard compliant.

I will ask libstdc++ dev Jonathan Wakely for helping reviewing this patch. Thank you

See: N4917

https://github.com/cplusplus/draft/releases/download/n4917/n4917.pdf

It requires a lot of more features to support for freestanding now. I am fixing this part to support C++23 freestanding.

The point of freestanding C++ is exactly THERE IS NO libc. Then why bother talking about libc? I do not understand know. In fact freestanding C headers are not a subset freestanding C++ headers by WG21. Why bother talking about that?

[trcrsired]

In D135911#3857212, @philnik wrote:

! In D135911#3857157, @trcrsired wrote:

! In D135911#3857150, @trcrsired wrote:
I think it would make sense to go through the list of C headers and decide on a case-by-case basis whether we want to rely on that header.
For example, it would probably be a good idea to remove any dependencies on stdio.h, but it doesn't make sense to remove dependencies on string.h. It's a very fundamental header and very simple to implement at least a basic version. IMO the C standard should actually require at least a subset of the header in freestanding mode. If there is any environment that doesn't provide the functions we use from that, I think it's reasonable to require the use of LLVM libc (or similar), which provides platform-agnostic implementations for these functions. The implementation there is probably a lot faster than anything we could provide in libc++ without basically duplicating LLVM libc.

This is exactly what I am talking about that libcxx always makes wrong assumptions. Even those headers exist, you still cannot guarantee they are working headers. There is no reason to make any assumption on the implementations.

How is there no reason to assume that the C implementation is conforming? libc++ isn't aiming to be a C library, it aiming to be a conforming C++ library.

Just avoid including those headers in first place. You do not need them tbh.

We do need them to provide a quality implementation.

BTW. you shouldn't need to implement those features either. GCC and clang always assumes memcpy, memmove, memset exist. However any other headers, unless WG14 and WG21 say something, we must avoid them at all costs.

We definitely shouldn't avoid them at all costs. I see no reason it's not acceptable to require LLVM libc in freestanding if the functionality isn't provided by the native libc.

In fact, you cannot even guarantee a correct implementation for memcpy. memcpy is tied to systems too. despite you can easily implement them. However, to implement them efficiently, only users know how to do that.

We cannot guarantee it, but we can require it. That's not an unreasonable requirement on a C library.

I recently encounter an example on why detecting headers won't work. pdp11-aout provides its own libc. However that libc was written in 1960s probably, the code just could not compile with a C++ compiler since they use K&R style function declaration. None of those headers can be used. Making any assumptions on how libc works would create all sorts of issues.

I don't think it's reasonable to build a 2022 libc++ on a C library from the 1960s. That's not a use-case we aim to support.

That is why a LIBCXX_FREESTANDING toggle would be extremely useful since they avoid any assumptions on how libc is implemented.

If you can't assume anything about the C library it's impossible to implement a conforming freestanding C++ library. As said before, it's absolutely reasonable to assume a conforming C library.

Quality implementation =/= avoid implementation as a whole. What you are doing is basically preventing people for using freestanding C++ for doing what it supposes to do.

Yes it can be implemented. Or it is a bug in the standard.

[trcrsired]

In D135911#3857212, @philnik wrote:

! In D135911#3857157, @trcrsired wrote:

! In D135911#3857150, @trcrsired wrote:
I think it would make sense to go through the list of C headers and decide on a case-by-case basis whether we want to rely on that header.
For example, it would probably be a good idea to remove any dependencies on stdio.h, but it doesn't make sense to remove dependencies on string.h. It's a very fundamental header and very simple to implement at least a basic version. IMO the C standard should actually require at least a subset of the header in freestanding mode. If there is any environment that doesn't provide the functions we use from that, I think it's reasonable to require the use of LLVM libc (or similar), which provides platform-agnostic implementations for these functions. The implementation there is probably a lot faster than anything we could provide in libc++ without basically duplicating LLVM libc.

This is exactly what I am talking about that libcxx always makes wrong assumptions. Even those headers exist, you still cannot guarantee they are working headers. There is no reason to make any assumption on the implementations.

How is there no reason to assume that the C implementation is conforming? libc++ isn't aiming to be a C library, it aiming to be a conforming C++ library.

Just avoid including those headers in first place. You do not need them tbh.

We do need them to provide a quality implementation.

BTW. you shouldn't need to implement those features either. GCC and clang always assumes memcpy, memmove, memset exist. However any other headers, unless WG14 and WG21 say something, we must avoid them at all costs.

We definitely shouldn't avoid them at all costs. I see no reason it's not acceptable to require LLVM libc in freestanding if the functionality isn't provided by the native libc.

In fact, you cannot even guarantee a correct implementation for memcpy. memcpy is tied to systems too. despite you can easily implement them. However, to implement them efficiently, only users know how to do that.

We cannot guarantee it, but we can require it. That's not an unreasonable requirement on a C library.

I recently encounter an example on why detecting headers won't work. pdp11-aout provides its own libc. However that libc was written in 1960s probably, the code just could not compile with a C++ compiler since they use K&R style function declaration. None of those headers can be used. Making any assumptions on how libc works would create all sorts of issues.

I don't think it's reasonable to build a 2022 libc++ on a C library from the 1960s. That's not a use-case we aim to support.

That is why a LIBCXX_FREESTANDING toggle would be extremely useful since they avoid any assumptions on how libc is implemented.

If you can't assume anything about the C library it's impossible to implement a conforming freestanding C++ library. As said before, it's absolutely reasonable to assume a conforming C library.

Tons of building issues with libcxx with GCC now. Probably I will commit a patch to fix build for libcxx on GCC first.

[trcrsired]

A new patch to try to support C++23 freestanding.

charconv is no longer supported for freestanding since std::errc is not freestanding

[trcrsired]

Make feature testing macros reflect freestanding settings.

Trivialize the implementation by implementing part of libc that would not break libcxx.

Add more headers to freestanding.

[trcrsired]

Fix warnings and format

[trcrsired]

Remove _LIBCPP_NO_THREADS error for all headers since it breaks the clang module header system.

[trcrsired]

format issue

[trcrsired]

disable freestanding test for modules since clang does not understand the semantics correctly.

[trcrsired]

barrier should not be defined under hosted environment

[trcrsired]

no longer define _LIBCPP_NO_THREADS when _LIBCPP_FREESTANDING is defined with a hosted toolchain

[trcrsired]

libcxx still does not support module with freestanding due to incorrect assumptions on std module. Disable it

[trcrsired]

Fix incorrect tooltip in cmake

[trcrsired]

Done!!
Finally got all tests passed

[trcrsired]

Can you review the changes here? It should be done. Now libcxx supports freestanding mode. The headers can be installed and deployed without a libc now. This should match libstdc++ now.
-ffreestanding flag will also follow the standard behavior.

[trcrsired]

@jwakely Does this match the behavior of libstdc++? Do you think I need more changes? libcxx support much more headers than libstdc++ for freestanding.

[jwakely]

I already said I'm not interested in reviewing this, stop asking me to.

[trcrsired]

@ldionne @philnik Can you help review this? Many people (like mlibc devs) and I really want to see libcxx work for freestanding. I've added a hosted setting in the generate_feature_test_macro_components.py.

Thank you so much!

[trcrsired]

Update for today's update to libcxx.

Adding more headers to freestanding test.

[trcrsired]

Re add patch for recent patch

[trcrsired]

Fix format issue

[trcrsired]

Finished. Please merge.

[trcrsired]

https://reviews.llvm.org/D140691

Change to new revision D140691

libcxx/CMakeLists.txt

    the shared library they shipped should turn this on and see `include/__availability`
    for more details." OFF)
 option(LIBCXX_ENABLE_CLANG_TIDY "Whether to compile and run clang-tidy checks" OFF)
-
+option(LIBCXX_FREESTANDING
+  "Build libc++ in freestanding mode. This toggle allows the libc++ to work without libc
+   for environments like operating systems kernels or embedded systems." OFF)
+
+if (LIBCXX_FREESTANDING)
+  set(LIBCXX_ENABLE_FILESYSTEM OFF)
+  set(LIBCXX_ENABLE_RANDOM_DEVICE OFF)
+  set(LIBCXX_ENABLE_PARALLEL_ALGORITHMS OFF)
+  set(LIBCXX_ENABLE_SHARED OFF)
+  set(LIBCXX_ENABLE_STATIC OFF)
+  set(CMAKE_C_COMPILER_WORKS ON)
+  set(CMAKE_CXX_COMPILER_WORKS ON)
+  set(LIBCXX_ENABLE_LOCALIZATION OFF)
+  set(LIBCXX_ENABLE_FSTREAM OFF)
+else()
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared-gcc.cfg.in")
 elseif(MINGW)

     set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-static.cfg.in")
   endif()
 endif()
+endif()
+
 set(LIBCXX_TEST_CONFIG "${LIBCXX_DEFAULT_TEST_CONFIG}" CACHE STRING
     "The path to the Lit testing configuration to use when running the tests.
      If a relative path is provided, it is assumed to be relative to '<monorepo>/libcxx/test/configs'.")

 # Benchmark options -----------------------------------------------------------
 option(LIBCXX_INCLUDE_BENCHMARKS "Build the libc++ benchmarks and their dependencies" ON)
 
+if (LIBCXX_FREESTANDING)
+  set(LIBCXX_INCLUDE_BENCHMARKS Off)
+endif()
+
 set(LIBCXX_BENCHMARK_TEST_ARGS_DEFAULT --benchmark_min_time=0.01)
 set(LIBCXX_BENCHMARK_TEST_ARGS "${LIBCXX_BENCHMARK_TEST_ARGS_DEFAULT}" CACHE STRING
     "Arguments to pass when running the benchmarks using check-cxx-benchmarks")

 
 # Ensure LIBCXX_ENABLE_MONOTONIC_CLOCK is set to ON only when
 # LIBCXX_ENABLE_THREADS is on.
-if(LIBCXX_ENABLE_THREADS AND NOT LIBCXX_ENABLE_MONOTONIC_CLOCK)
-  message(FATAL_ERROR "LIBCXX_ENABLE_MONOTONIC_CLOCK can only be set to OFF"
-                      " when LIBCXX_ENABLE_THREADS is also set to OFF.")
+if (LIBCXX_FREESTANDING)
+  set(LIBCXX_ENABLE_THREADS Off)
+  set(LIBCXX_ENABLE_MONOTONIC_CLOCK Off)
+else()
+  if (LIBCXX_ENABLE_THREADS AND NOT LIBCXX_ENABLE_MONOTONIC_CLOCK)
+    message(FATAL_ERROR "LIBCXX_ENABLE_MONOTONIC_CLOCK can only be set to OFF"
+                        " when LIBCXX_ENABLE_THREADS is also set to OFF.")
+  endif()
 endif()
 
 if(NOT LIBCXX_ENABLE_THREADS)

 else()
   config_define(0 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT)
 endif()
+if (LIBCXX_FREESTANDING)
+  config_define(LIBCXX_FREESTANDING _LIBCPP_FREESTANDING)
+endif()
 
 if (LIBCXX_ABI_DEFINES)
   set(abi_defines)

 # Setup Source Code And Tests
 #===============================================================================
 add_subdirectory(include)
+if (NOT LIBCXX_FREESTANDING)
 add_subdirectory(src)
 add_subdirectory(utils)
+endif()
 
 set(LIBCXX_TEST_DEPS "cxx_experimental")
 

libcxx/include/__algorithm/sort.h

   std::__sort<__less<uintptr_t>&, uintptr_t*>((uintptr_t*)__first, (uintptr_t*)__last, __comp);
 }
 
+#ifndef _LIBCPP_FREESTANDING
 extern template _LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&);
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template _LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&);

 extern template _LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&);
 
 extern template _LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&);
+#endif
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Comp>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20

libcxx/include/__config

 // generate identifiers that must be unique for every released libc++ version.
 #  define _LIBCPP_VERSIONED_IDENTIFIER _LIBCPP_CONCAT(v, _LIBCPP_VERSION)
 
-#  if __STDC_HOSTED__ == 0
+#  if __STDC_HOSTED__ == 0 && !defined(_LIBCPP_FREESTANDING)
 #    define _LIBCPP_FREESTANDING
 #  endif
 

 #  endif
 
 // Need to detect which libc we're using if we're on Linux.
-#  if defined(__linux__)
+#  if defined(__linux__) && __has_include(<features.h>)
 #    include <features.h>
 #    if defined(__GLIBC_PREREQ)
 #      define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)

 #    endif // defined(__GLIBC_PREREQ)
 #  endif   // defined(__linux__)
 
-#  if defined(__MVS__)
+#  if defined(__MVS__) && __has_include(<features.h>)
 #    include <features.h> // for __NATIVE_ASCII_F
 #  endif
 

 #    endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #  endif   // __BYTE_ORDER__
 
-#  ifdef __FreeBSD__
+#  if defined(__FreeBSD__) && __has_include(<sys/endian.h>) && __has_include(<osreldate.h>)
 #    include <sys/endian.h>
 #    include <osreldate.h>
 #    if _BYTE_ORDER == _LITTLE_ENDIAN

 #    endif // _BYTE_ORDER == _LITTLE_ENDIAN
 #  endif   // __FreeBSD__
 
-#  if defined(__NetBSD__) || defined(__OpenBSD__)
+#  if (defined(__NetBSD__) || defined(__OpenBSD__)) && __has_include(<sys/endian.h>)
 #    include <sys/endian.h>
 #    if _BYTE_ORDER == _LITTLE_ENDIAN
 #      define _LIBCPP_LITTLE_ENDIAN

 #    define _LIBCPP_HAS_OPEN_WITH_WCHAR
 #  endif // defined(_WIN32)
 
-#  ifdef __sun__
+#  if defined(__sun__) && __has_include(<sys/isa_defs.h>)
 #    include <sys/isa_defs.h>
 #    ifdef _LITTLE_ENDIAN
 #      define _LIBCPP_LITTLE_ENDIAN

 #    define _LIBCPP_USING_DEV_RANDOM
 #  endif
 
-#  if !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
+#  if !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN) && __has_include(<endian.h>)
 #    include <endian.h>
 #    if __BYTE_ORDER == __LITTLE_ENDIAN
 #      define _LIBCPP_LITTLE_ENDIAN

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #cmakedefine01 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT
 #cmakedefine _LIBCPP_ENABLE_DEBUG_MODE
+#cmakedefine _LIBCPP_FREESTANDING
 
 // __USE_MINGW_ANSI_STDIO gets redefined on MinGW
 #ifdef __clang__

libcxx/include/__thread/poll_with_backoff.h

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-static _LIBCPP_CONSTEXPR const int __libcpp_polling_count = 64;
-
 // Polls a thread for a condition given by a predicate, and backs off based on a backoff policy
 // before polling again.
 //

 //
 // - __max_elapsed is the maximum duration to try polling for. If the maximum duration is exceeded,
 //   the polling loop will return false to report a timeout.
+#ifdef _LIBCPP_FREESTANDING
+template <class _Fn, class _BFn>
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __libcpp_thread_poll_with_backoff(_Fn&& __f, _BFn&&) {
+  for (;;) {
+    if (__f())
+      return true; // _Fn completion means success
+  }
+}
+template <class _Fn, class _BFn>
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool
+__libcpp_thread_poll_with_backoff(_Fn&& __f, _BFn&& __bf, chrono::nanoseconds) {
+  return __libcpp_thread_poll_with_backoff(__f, __bf);
+}
+#else
+static _LIBCPP_CONSTEXPR const int __libcpp_polling_count = 64;
 template<class _Fn, class _BFn>
 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
 bool __libcpp_thread_poll_with_backoff(_Fn&& __f, _BFn&& __bf, chrono::nanoseconds __max_elapsed = chrono::nanoseconds::zero()) {
-    auto const __start = chrono::high_resolution_clock::now();
-    for (int __count = 0;;) {
-      if (__f())
-        return true; // _Fn completion means success
-      if (__count < __libcpp_polling_count) {
-        __count += 1;
-        continue;
-      }
-      chrono::nanoseconds const __elapsed = chrono::high_resolution_clock::now() - __start;
-      if (__max_elapsed != chrono::nanoseconds::zero() && __max_elapsed < __elapsed)
-          return false; // timeout failure
-      if (__bf(__elapsed))
-        return false; // _BFn completion means failure
     }
+    chrono::nanoseconds const __elapsed = chrono::high_resolution_clock::now() - __start;
+    if (__max_elapsed != chrono::nanoseconds::zero() && __max_elapsed < __elapsed)
+      return false; // timeout failure
+    if (__bf(__elapsed))
+      return false; // _BFn completion means failure
+  }
 }
-
+#endif
 // A trivial backoff policy that always immediately returns the control to
 // the polling loop.
 //

libcxx/include/chrono

 // [time.syn]
 #include <compare>
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) && _LIBCPP_STD_VER > 17
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) && _LIBCPP_STD_VER > 17 &&     \
+    !defined(_LIBCPP_FREESTANDING)
 #  include <__chrono/formatter.h>
 #  include <__chrono/ostream.h>
 #  include <__chrono/parser_std_format_spec.h>

libcxx/include/complex

 #include <type_traits>
 #include <version>
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <sstream> // for std::basic_ostringstream
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_FREESTANDING)
+#  include <sstream> // for std::basic_ostringstream
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

     return complex<_Tp>(__z.imag(), -__z.real());
 }
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_FREESTANDING)
 template<class _Tp, class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)

libcxx/include/cstdio

 
 using ::fopen _LIBCPP_USING_IF_EXISTS;
 using ::freopen _LIBCPP_USING_IF_EXISTS;
+#ifndef _LIBCPP_FREESTANDING
 using ::remove _LIBCPP_USING_IF_EXISTS;
+#endif
 using ::rename _LIBCPP_USING_IF_EXISTS;
 using ::tmpfile _LIBCPP_USING_IF_EXISTS;
 using ::tmpnam _LIBCPP_USING_IF_EXISTS;

libcxx/include/ctime

 #  ifdef _LIBCPP_TIME_H
 #    error "If libc++ starts defining <time.h>, the __has_include check should move to libc++'s <time.h>"
 #  endif
+#else
+#  include <cstdint>
+extern "C" {
+typedef ::std::uint_least64_t time_t;
+}
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/cwchar

 #if __has_builtin(__builtin_wcslen)
   return __builtin_wcslen(__str);
 #else
+#  ifndef _LIBCPP_FREESTANDING
   if (!__libcpp_is_constant_evaluated())
     return std::wcslen(__str);
+#  endif
 
   size_t __len = 0;
   for (; *__str != L'\0'; ++__str)

 #if __has_builtin(__builtin_wmemcmp)
   return __builtin_wmemcmp(__lhs, __rhs, __count);
 #else
+#  ifndef _LIBCPP_FREESTANDING
   if (!__libcpp_is_constant_evaluated())
     return std::wmemcmp(__lhs, __rhs, __count);
+#  endif
 
   for (; __count; --__count, ++__lhs, ++__rhs) {
     if (*__lhs < *__rhs)

 #if __has_feature(cxx_constexpr_string_builtins)
   return __builtin_wmemchr(__str, __char, __count);
 #else
+#  ifndef _LIBCPP_FREESTANDING
   if (!__libcpp_is_constant_evaluated())
     return std::wmemchr(__str, __char, __count);
+#  endif
 
   for (; __count; --__count) {
     if (*__str == __char)

libcxx/include/errno.h

 
 #if __has_include_next(<errno.h>)
 #  include_next <errno.h>
+#else
+
+/* Adjusted to the linux asm/errno.h */
+#  define EPERM 1            /* Operation not permitted */
+#  define ENOENT 2           /* No such file or directory */
+#  define ESRCH 3            /* No such process */
+#  define EINTR 4            /* Interrupted system call */
+#  define EIO 5              /* I/O error */
+#  define ENXIO 6            /* No such device or address */
+#  define E2BIG 7            /* Arg list too long */
+#  define ENOEXEC 8          /* Exec format error */
+#  define EBADF 9            /* Bad file number */
+#  define ECHILD 10          /* No child processes */
+#  define EAGAIN 11          /* Try again */
+#  define ENOMEM 12          /* Out of memory */
+#  define EACCES 13          /* Permission denied */
+#  define EFAULT 14          /* Bad address */
+#  define ENOTBLK 15         /* Block device required */
+#  define EBUSY 16           /* Device or resource busy */
+#  define EEXIST 17          /* File exists */
+#  define EXDEV 18           /* Cross-device link */
+#  define ENODEV 19          /* No such device */
+#  define ENOTDIR 20         /* Not a directory */
+#  define EISDIR 21          /* Is a directory */
+#  define EINVAL 22          /* Invalid argument */
+#  define ENFILE 23          /* File table overflow */
+#  define EMFILE 24          /* Too many open files */
+#  define ENOTTY 25          /* Not a typewriter */
+#  define ETXTBSY 26         /* Text file busy */
+#  define EFBIG 27           /* File too large */
+#  define ENOSPC 28          /* No space left on device */
+#  define ESPIPE 29          /* Illegal seek */
+#  define EROFS 30           /* Read-only file system */
+#  define EMLINK 31          /* Too many links */
+#  define EPIPE 32           /* Broken pipe */
+#  define EDOM 33            /* Math argument out of domain of func */
+#  define ERANGE 34          /* Math result not representable */
+#  define EDEADLK 35         /* Resource deadlock would occur */
+#  define ENAMETOOLONG 36    /* File name too long */
+#  define ENOLCK 37          /* No record locks available */
+#  define ENOSYS 38          /* Function not implemented */
+#  define ENOTEMPTY 39       /* Directory not empty */
+#  define ELOOP 40           /* Too many symbolic links encountered */
+#  define EWOULDBLOCK EAGAIN /* Operation would block */
+#  define ENOMSG 42          /* No message of desired type */
+#  define EIDRM 43           /* Identifier removed */
+#  define ECHRNG 44          /* Channel number out of range */
+#  define EL2NSYNC 45        /* Level 2 not synchronized */
+#  define EL3HLT 46          /* Level 3 halted */
+#  define EL3RST 47          /* Level 3 reset */
+#  define ELNRNG 48          /* Link number out of range */
+#  define EUNATCH 49         /* Protocol driver not attached */
+#  define ENOCSI 50          /* No CSI structure available */
+#  define EL2HLT 51          /* Level 2 halted */
+#  define EBADE 52           /* Invalid exchange */
+#  define EBADR 53           /* Invalid request descriptor */
+#  define EXFULL 54          /* Exchange full */
+#  define ENOANO 55          /* No anode */
+#  define EBADRQC 56         /* Invalid request code */
+#  define EBADSLT 57         /* Invalid slot */
+#  define EDEADLOCK EDEADLK
+#  define EBFONT 59          /* Bad font file format */
+#  define EFTYPE EBFONT      /* Inappropriate file type or format */
+#  define ENOSTR 60          /* Device not a stream */
+#  define ENODATA 61         /* No data available */
+#  define ETIME 62           /* Timer expired */
+#  define ENOSR 63           /* Out of streams resources */
+#  define ENONET 64          /* Machine is not on the network */
+#  define ENOPKG 65          /* Package not installed */
+#  define EREMOTE 66         /* Object is remote */
+#  define ENOLINK 67         /* Link has been severed */
+#  define EADV 68            /* Advertise error */
+#  define ESRMNT 69          /* Srmount error */
+#  define ECOMM 70           /* Communication error on send */
+#  define EPROTO 71          /* Protocol error */
+#  define EMULTIHOP 72       /* Multihop attempted */
+#  define EDOTDOT 73         /* RFS specific error */
+#  define EBADMSG 74         /* Not a data message */
+#  define EOVERFLOW 75       /* Value too large for defined data type */
+#  define ENOTUNIQ 76        /* Name not unique on network */
+#  define EBADFD 77          /* File descriptor in bad state */
+#  define EREMCHG 78         /* Remote address changed */
+#  define ELIBACC 79         /* Can not access a needed shared library */
+#  define ELIBBAD 80         /* Accessing a corrupted shared library */
+#  define ELIBSCN 81         /* .lib section in a.out corrupted */
+#  define ELIBMAX 82         /* Attempting to link in too many shared libraries */
+#  define ELIBEXEC 83        /* Cannot exec a shared library directly */
+#  define EILSEQ 84          /* Illegal byte sequence */
+#  define ERESTART 85        /* Interrupted system call should be restarted */
+#  define ESTRPIPE 86        /* Streams pipe error */
+#  define EUSERS 87          /* Too many users */
+#  define ENOTSOCK 88        /* Socket operation on non-socket */
+#  define EDESTADDRREQ 89    /* Destination address required */
+#  define EMSGSIZE 90        /* Message too long */
+#  define EPROTOTYPE 91      /* Protocol wrong type for socket */
+#  define ENOPROTOOPT 92     /* Protocol not available */
+#  define EPROTONOSUPPORT 93 /* Protocol not supported */
+#  define ESOCKTNOSUPPORT 94 /* Socket type not supported */
+#  define EOPNOTSUPP 95      /* Operation not supported on transport endpoint */
+#  define EPFNOSUPPORT 96    /* Protocol family not supported */
+#  define EAFNOSUPPORT 97    /* Address family not supported by protocol */
+#  define EADDRINUSE 98      /* Address already in use */
+#  define EADDRNOTAVAIL 99   /* Cannot assign requested address */
+#  define ENETDOWN 100       /* Network is down */
+#  define ENETUNREACH 101    /* Network is unreachable */
+#  define ENETRESET 102      /* Network dropped connection because of reset */
+#  define ECONNABORTED 103   /* Software caused connection abort */
+#  define ECONNRESET 104     /* Connection reset by peer */
+#  define ENOBUFS 105        /* No buffer space available */
+#  define EISCONN 106        /* Transport endpoint is already connected */
+#  define ENOTCONN 107       /* Transport endpoint is not connected */
+#  define ESHUTDOWN 108      /* Cannot send after transport endpoint shutdown */
+#  define ETOOMANYREFS 109   /* Too many references: cannot splice */
+#  define ETIMEDOUT 110      /* Connection timed out */
+#  define ECONNREFUSED 111   /* Connection refused */
+#  define EHOSTDOWN 112      /* Host is down */
+#  define EHOSTUNREACH 113   /* No route to host */
+#  define EALREADY 114       /* Operation already in progress */
+#  define EINPROGRESS 115    /* Operation now in progress */
+#  define ESTALE 116         /* Stale NFS file handle */
+#  define EUCLEAN 117        /* Structure needs cleaning */
+#  define ENOTNAM 118        /* Not a XENIX named type file */
+#  define ENAVAIL 119        /* No XENIX semaphores available */
+#  define EISNAM 120         /* Is a named type file */
+#  define EREMOTEIO 121      /* Remote I/O error */
+#  define EDQUOT 122         /* Quota exceeded */
+
+#  define ENOMEDIUM 123    /* No medium found */
+#  define EMEDIUMTYPE 124  /* Wrong medium type */
+#  define ECANCELED 125    /* Operation Canceled */
+#  define ENOKEY 126       /* Required key not available */
+#  define EKEYEXPIRED 127  /* Key has expired */
+#  define EKEYREVOKED 128  /* Key has been revoked */
+#  define EKEYREJECTED 129 /* Key was rejected by service */
+
+#  define EOWNERDEAD 130      /* Owner died */
+#  define ENOTRECOVERABLE 131 /* State not recoverable */
+
+/* Widely known to be a synonym in Linux.  */
+#  define ENOTSUP EOPNOTSUPP
+
+#  define __ELASTERROR 2000 /* Users can add values starting here */
 #endif
 
 #ifdef __cplusplus

libcxx/include/functional

 #include <__functional/bind_front.h>
 #include <__functional/binder1st.h>
 #include <__functional/binder2nd.h>
-#include <__functional/boyer_moore_searcher.h>
+#ifndef _LIBCPP_FREESTANDING
+#  include <__functional/boyer_moore_searcher.h>
+#endif
 #include <__functional/compose.h>
 #include <__functional/default_searcher.h>
 #include <__functional/function.h>

libcxx/include/math.h

 
 #  if __has_include_next(<math.h>)
 #    include_next <math.h>
+#  else
+#    define NAN __builtin_nanf("")
+#    define INFINITY __builtin_inff()
+#    define FP_NAN 0
+#    define FP_INFINITE 1
+#    define FP_ZERO 2
+#    define FP_SUBNORMAL 3
+#    define FP_NORMAL 4
 #  endif
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 
 // We support including .h headers inside 'extern "C"' contexts, so switch
 // back to C++ linkage before including these C++ headers.

 
 } // extern "C++"
 
-#endif // __cplusplus
+#  endif // __cplusplus
 
 #else // _LIBCPP_MATH_H
 

libcxx/include/new

 #endif
 }
 
-#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
+#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && !defined(_LIBCPP_FREESTANDING)
 // Low-level helpers to call the aligned allocation and deallocation functions
 // on the target platform. This is used to implement libc++'s own memory
 // allocation routines -- if you need to allocate memory inside the library,

libcxx/include/stdio.h

 
 #  if __has_include_next(<stdio.h>)
 #    include_next <stdio.h>
+#  else
+#    ifndef EOF
+#      define EOF (-1)
+#    endif
 #  endif
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 
-#undef getc
-#undef putc
-#undef clearerr
-#undef feof
-#undef ferror
+#    undef getc
+#    undef putc
+#    undef clearerr
+#    undef feof
+#    undef ferror
 
-#endif
+#  endif
 
 #endif // _LIBCPP_STDIO_H

libcxx/include/stdlib.h

 
 #  if __has_include_next(<stdlib.h>)
 #    include_next <stdlib.h>
+#  else
+
+#    ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#    endif
+#    ifndef EXIT_FAILURE
+#      define EXIT_FAILURE 1
+#    endif
+#    ifdef __cplusplus
+extern "C" {
+#    endif
+// freestanding C++
+// 17.6, start and termination
+_LIBCPP_NORETURN void abort() _NOEXCEPT;
+int at_quick_exit(void (*)(void)) _NOEXCEPT;
+_LIBCPP_NORETURN void exit(int);
+_LIBCPP_NORETURN void _Exit(int) _NOEXCEPT;
+_LIBCPP_NORETURN void quick_exit(int) _NOEXCEPT;
+#    ifdef __cplusplus
+}
+#    endif
 #  endif
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 extern "C++" {
 // abs
-
-#ifdef abs
-# undef abs
-#endif
-#ifdef labs
-# undef labs
-#endif
-#ifdef llabs
-# undef llabs
-#endif
+#    ifdef abs
+#      undef abs
+#    endif
+#    ifdef labs
+#      undef labs
+#    endif
+#    ifdef llabs
+#      undef llabs
+#    endif
 
 // MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
-#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__)
+#    if !defined(_LIBCPP_MSVCRT) && !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY long abs(long __x) _NOEXCEPT {
   return __builtin_labs(__x);
 }
 inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {
   return __builtin_llabs(__x);
 }
-#endif // !defined(_LIBCPP_MSVCRT) && !defined(__sun__)
+#    endif // !defined(_LIBCPP_MSVCRT) && !defined(__sun__)
 
-#if !defined(__sun__)
+#    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float abs(float __lcpp_x) _NOEXCEPT {
   return __builtin_fabsf(__lcpp_x); // Use builtins to prevent needing math.h
 }

 abs(long double __lcpp_x) _NOEXCEPT {
   return __builtin_fabsl(__lcpp_x);
 }
-#endif // !defined(__sun__)
+#    endif // !defined(__sun__)
 
 // div
 
-#ifdef div
-# undef div
-#endif
-#ifdef ldiv
-# undef ldiv
-#endif
-#ifdef lldiv
-# undef lldiv
-#endif
-
+#    ifdef div
+#      undef div
+#    endif
+#    ifdef ldiv
+#      undef ldiv
+#    endif
+#    ifdef lldiv
+#      undef lldiv
+#    endif
+#    ifndef _LIBCPP_FREESTANDING
 // MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
-#if !defined(_LIBCPP_MSVCRT) && !defined(__sun__)
+#      if !defined(_LIBCPP_MSVCRT) && !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY ldiv_t div(long __x, long __y) _NOEXCEPT {
   return ::ldiv(__x, __y);
 }
-#if !(defined(__FreeBSD__) && !defined(__LONG_LONG_SUPPORTED))
+#        if !(defined(__FreeBSD__) && !defined(__LONG_LONG_SUPPORTED))
 inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x,
                                              long long __y) _NOEXCEPT {
   return ::lldiv(__x, __y);
 }
-#endif
-#endif // _LIBCPP_MSVCRT / __sun__
+#        endif
+#      endif
+#    endif // _LIBCPP_MSVCRT / __sun__
 } // extern "C++"
-#endif // __cplusplus
+#  endif   // __cplusplus
 
 #endif // _LIBCPP_STDLIB_H

libcxx/include/string.h

 
 #if __has_include_next(<string.h>)
 #  include_next <string.h>
+#else
+#  include <stddef.h>
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+void* memcpy(void*, void const*, size_t);
+void* memmove(void*, void const*, size_t);
+void* memset(void*, int, size_t);
+int memcmp(void const*, void const*, size_t);
+#  ifdef __cplusplus
+}
+#  endif
 #endif
 
 // MSVCRT, GNU libc and its derivates may already have the correct prototype in

libcxx/include/version

 # define __cpp_lib_make_reverse_iterator                201402L
 # define __cpp_lib_make_unique                          201304L
 # define __cpp_lib_null_iterators                       201304L
-# define __cpp_lib_quoted_string_io                     201304L
+# ifndef LIBCXX_FREESTANDING
+#   define __cpp_lib_quoted_string_io                   201304L
+# endif
 # define __cpp_lib_result_of_sfinae                     201210L
 # define __cpp_lib_robust_nonmodifying_seq_ops          201304L
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)
-#   define __cpp_lib_shared_timed_mutex                 201402L
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)
+#     define __cpp_lib_shared_timed_mutex               201402L
+#   endif
 # endif
 # define __cpp_lib_string_udls                          201304L
 # define __cpp_lib_transformation_trait_aliases         201304L

 # define __cpp_lib_byte                                 201603L
 # define __cpp_lib_chrono                               201611L
 # define __cpp_lib_clamp                                201603L
-# define __cpp_lib_enable_shared_from_this              201603L
+# ifndef LIBCXX_FREESTANDING
+#   define __cpp_lib_enable_shared_from_this            201603L
+# endif
 // # define __cpp_lib_execution                            201603L
-# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
-#   define __cpp_lib_filesystem                         201703L
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
+#     define __cpp_lib_filesystem                       201703L
+#   endif
 # endif
 # define __cpp_lib_gcd_lcm                              201606L
 # if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)

 # define __cpp_lib_make_from_tuple                      201606L
 # define __cpp_lib_map_try_emplace                      201411L
 // # define __cpp_lib_math_special_functions               201603L
-# define __cpp_lib_memory_resource                      201603L
+# ifndef LIBCXX_FREESTANDING
+#   define __cpp_lib_memory_resource                    201603L
+# endif
 # define __cpp_lib_node_extract                         201606L
 # define __cpp_lib_nonmember_container_access           201411L
 # define __cpp_lib_not_fn                               201603L
 # define __cpp_lib_optional                             201606L
-// # define __cpp_lib_parallel_algorithm                   201603L
+# ifndef LIBCXX_FREESTANDING
+// #   define __cpp_lib_parallel_algorithm                 201603L
+# endif
 # define __cpp_lib_raw_memory_algorithms                201606L
 # define __cpp_lib_sample                               201603L
-# define __cpp_lib_scoped_lock                          201703L
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)
-#   define __cpp_lib_shared_mutex                       201505L
+# ifndef LIBCXX_FREESTANDING
+#   define __cpp_lib_scoped_lock                        201703L
+# endif
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)
+#     define __cpp_lib_shared_mutex                     201505L
+#   endif
+# endif
+# ifndef LIBCXX_FREESTANDING
+#   define __cpp_lib_shared_ptr_arrays                  201611L
+# endif
+# ifndef LIBCXX_FREESTANDING
+#   define __cpp_lib_shared_ptr_weak_type               201606L
 # endif
-# define __cpp_lib_shared_ptr_arrays                    201611L
-# define __cpp_lib_shared_ptr_weak_type                 201606L
 # define __cpp_lib_string_view                          201606L
 // # define __cpp_lib_to_chars                             201611L
 # undef  __cpp_lib_transparent_operators

 // # define __cpp_lib_atomic_float                         201711L
 # define __cpp_lib_atomic_lock_free_type_aliases        201907L
 // # define __cpp_lib_atomic_ref                           201806L
-// # define __cpp_lib_atomic_shared_ptr                    201711L
+# ifndef LIBCXX_FREESTANDING
+// #   define __cpp_lib_atomic_shared_ptr                  201711L
+# endif
 # define __cpp_lib_atomic_value_initialization          201911L
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   define __cpp_lib_atomic_wait                        201907L
 # endif
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
-#   define __cpp_lib_barrier                            201907L
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
+#     define __cpp_lib_barrier                          201907L
+#   endif
 # endif
 # define __cpp_lib_bind_front                           201907L
 # define __cpp_lib_bit_cast                             201806L

 # define __cpp_lib_erase_if                             202002L
 # undef  __cpp_lib_execution
 // # define __cpp_lib_execution                            201902L
-# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
-// #   define __cpp_lib_format                             202106L
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+// #     define __cpp_lib_format                           202106L
+#   endif
 # endif
 # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_int_pow2                             202002L

 // # define __cpp_lib_is_layout_compatible                 201907L
 # define __cpp_lib_is_nothrow_convertible               201806L
 // # define __cpp_lib_is_pointer_interconvertible          201907L
-# if !defined(_LIBCPP_HAS_NO_THREADS)
-// #   define __cpp_lib_jthread                            201911L
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_HAS_NO_THREADS)
+// #     define __cpp_lib_jthread                          201911L
+#   endif
 # endif
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)
-#   define __cpp_lib_latch                              201907L
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)
+#     define __cpp_lib_latch                            201907L
+#   endif
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
-# define __cpp_lib_polymorphic_allocator                201902L
+# ifndef LIBCXX_FREESTANDING
+#   define __cpp_lib_polymorphic_allocator              201902L
+# endif
 # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_remove_cvref                         201711L
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)
-#   define __cpp_lib_semaphore                          201907L
+# ifndef LIBCXX_FREESTANDING
+#   if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)
+#     define __cpp_lib_semaphore                        201907L
+#   endif
 # endif
+# ifndef LIBCXX_FREESTANDING
 # undef  __cpp_lib_shared_ptr_arrays
-# define __cpp_lib_shared_ptr_arrays                    201707L
+#   define __cpp_lib_shared_ptr_arrays                  201707L
+# endif
 # define __cpp_lib_shift                                201806L
-// # define __cpp_lib_smart_ptr_for_overwrite              202002L
+# ifndef LIBCXX_FREESTANDING
+// #   define __cpp_lib_smart_ptr_for_overwrite            202002L
+# endif
 // # define __cpp_lib_source_location                      201907L
 # define __cpp_lib_span                                 202002L
 # define __cpp_lib_ssize                                201902L
 # define __cpp_lib_starts_ends_with                     201711L
 # undef  __cpp_lib_string_view
 # define __cpp_lib_string_view                          201803L
-// # define __cpp_lib_syncbuf                              201803L
+# ifndef LIBCXX_FREESTANDING
+// #   define __cpp_lib_syncbuf                            201803L
+# endif
 // # define __cpp_lib_three_way_comparison                 201907L
 # define __cpp_lib_to_address                           201711L
 # define __cpp_lib_to_array                             201907L

 // # define __cpp_lib_ranges_to_container                  202202L
 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L
-// # define __cpp_lib_spanstream                           202106L
-// # define __cpp_lib_stacktrace                           202011L
+# ifndef LIBCXX_FREESTANDING
+// #   define __cpp_lib_spanstream                         202106L
+# endif
+# ifndef LIBCXX_FREESTANDING
+// #   define __cpp_lib_stacktrace                         202011L
+# endif
 # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
 # define __cpp_lib_string_resize_and_overwrite          202110L

libcxx/include/wchar.h

 
 #  if __has_include_next(<wchar.h>)
 #    include_next <wchar.h>
+#  else
+#    ifdef __cplusplus
+extern "C" {
+#    endif
+typedef unsigned wint_t;
+#    ifndef WEOF
+#      define WEOF (wint_t)(-1)
+#    endif
+struct mbstate_t {};
+#    ifdef __cplusplus
+}
+#    endif
 #  endif
 
 // Determine whether we have const-correct overloads for wcschr and friends.
-#if defined(_WCHAR_H_CPLUSPLUS_98_CONFORMANCE_)
-#  define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
-#elif defined(__GLIBC_PREREQ)
-#  if __GLIBC_PREREQ(2, 10)
-#    define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
-#  endif
-#elif defined(_LIBCPP_MSVCRT)
-#  if defined(_CRT_CONST_CORRECT_OVERLOADS)
+#  if defined(_WCHAR_H_CPLUSPLUS_98_CONFORMANCE_)
 #    define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+#  elif defined(__GLIBC_PREREQ)
+#    if __GLIBC_PREREQ(2, 10)
+#      define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+#    endif
+#  elif defined(_LIBCPP_MSVCRT)
+#    if defined(_CRT_CONST_CORRECT_OVERLOADS)
+#      define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+#    endif
 #  endif
-#endif
 
-#if defined(__cplusplus) && !defined(_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
+#  if defined(__cplusplus) && !defined(_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD) &&  \
+      !defined(_LIBCPP_FREESTANDING)
 extern "C++" {
 inline _LIBCPP_INLINE_VISIBILITY
 wchar_t* __libcpp_wcschr(const wchar_t* __s, wchar_t __c) {return (wchar_t*)wcschr(__s, __c);}

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
       wchar_t* wmemchr(      wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
 }
-#endif
+#  endif
 
-#if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT_LIKE) || defined(__MVS__))
+#  if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT_LIKE) || defined(__MVS__)) && !defined(_LIBCPP_FREESTANDING)
 extern "C" {
 size_t mbsnrtowcs(wchar_t *__restrict __dst, const char **__restrict __src,
                   size_t __nmc, size_t __len, mbstate_t *__restrict __ps);
 size_t wcsnrtombs(char *__restrict __dst, const wchar_t **__restrict __src,
                   size_t __nwc, size_t __len, mbstate_t *__restrict __ps);
 }  // extern "C"
-#endif  // __cplusplus && (_LIBCPP_MSVCRT || __MVS__)
+#  endif // __cplusplus && (_LIBCPP_MSVCRT || __MVS__)
 
 #endif // _LIBCPP_WCHAR_H

libcxx/test/libcxx/libcpp_freestanding.sh.cpp

 // to the compiler but defined when -ffreestanding is passed to the compiler.
 
 // RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only -ffreestanding -DFREESTANDING %s
+// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only -ffreestanding %s
 
 #include <__config>
 
-#if defined(FREESTANDING) != defined(_LIBCPP_FREESTANDING)
-#error _LIBCPP_FREESTANDING should be defined in freestanding mode and not \
-       defined in non-freestanding mode
+#if defined(__has_feature)
+#  if __has_feature(modules)
+#    define _LIBCPP_FREESTANDING_NO_TEST_MODULES
+#  endif
+#elif defined(__cpp_modules)
+#  define _LIBCPP_FREESTANDING_NO_TEST_MODULES
+#endif
+
+#if defined(_LIBCPP_FREESTANDING) && !defined(_LIBCPP_FREESTANDING_NO_TEST_MODULES)
+#  include <cstddef>
+#  include <limits>
+#  include <cfloat>
+#  include <version>
+#  include <cstdint>
+#  include <cstdlib>
+#  include <new>
+#  include <typeinfo>
+#  if __has_include(<source_location>)
+#    include <source_location>
+#  endif
+#  include <exception>
+#  include <initializer_list>
+#  include <compare>
+#  include <coroutine>
+#  include <cstdarg>
+#  include <concepts>
+#  include <type_traits>
+#  include <bit>
+#  include <atomic>
+#  include <utility>
+#  include <tuple>
+#  include <memory>
+#  include <functional>
+#  include <ratio>
+#  include <iterator>
+#  include <ranges>
+#  include <typeinfo>
+
+/*
+We tested these headers are for preventing build issues
+*/
+#  include <iosfwd>
+#  include <cstdio>
+#  include <cerrno>
+#  include <cstring>
+#  include <cmath>
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    include <cwchar>
+#  endif
+/*
+ * libc++ libstdc++ like extensions
+ */
+#  include <array>
+#  include <span>
+#  include <algorithm>
+#  include <bitset>
+#  include <variant>
+#  include <optional>
+#  include <numbers>
+#  include <scoped_allocator>
+#  include <typeindex>
+#  include <string_view>
+#  include <numeric>
+#  include <complex>
+#  include <chrono>
+#  include <charconv>
+#  include <expected>
+#  include <random>
+#  include <any>
+
+/*
+ * libc++ Containers Extensions
+ */
+#  include <vector>
+#  include <deque>
+#  include <string>
+#  include <stack>
+#  include <queue>
+#  include <list>
+#  include <forward_list>
+#  include <map>
+#  include <set>
+#  include <unordered_set>
+#  include <unordered_map>
+#  if __has_include(<mdspan>)
+#    include <mdspan>
+#  endif
+#  include <valarray>
+
+#  if _LIBCPP_STD_VER < 20
+#    include <ciso646>
+#    if __has_include(<cstdalign>)
+#      include <cstdalign>
+#    endif
+#    include <cstdbool>
+#  endif
 #endif

libcxx/utils/generate_feature_test_macro_components.py

 #                   is only used when a feature isn't fully implemented. Once
 #                   you've fully implemented the feature, you should remove
 #                   this field.
+# hosted            We do not define this macro in freestanding mode.
 # ================  ============================================================
 feature_test_macros = [ add_version_header(x) for x in [
   {

     "values": { "c++20": 201711 },
     "headers": ["atomic"],
     "unimplemented": True,
+    "hosted": True,
   }, {
     "name": "__cpp_lib_atomic_value_initialization",
     "values": { "c++20": 201911 },

     "headers": ["barrier"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
+     "hosted": True,
   }, {
     "name": "__cpp_lib_bind_back",
     "values": { "c++2b": 202202 },

     "name": "__cpp_lib_enable_shared_from_this",
     "values": { "c++17": 201603 },
     "headers": ["memory"],
+    "hosted": True,
   }, {
     "name": "__cpp_lib_endian",
     "values": { "c++20": 201907 },

     "values": { "c++17": 201703 },
     "headers": ["filesystem"],
     "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)",
-    "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)"
+    "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)",
+    "hosted": True,
   }, {
     "name": "__cpp_lib_format",
     "values": {

     "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)",
     "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)",
     "unimplemented": True,
+    "hosted": True,
   }, {
     "name": "__cpp_lib_forward_like",
     "values": { "c++2b": 202207 },

     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "unimplemented": True,
+    "hosted": True,
   }, {
     "name": "__cpp_lib_latch",
     "values": { "c++20": 201907 },
     "headers": ["latch"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)",
+    "hosted": True,
   }, {
     "name": "__cpp_lib_launder",
     "values": { "c++17": 201606 },

     "name": "__cpp_lib_memory_resource",
     "values": { "c++17": 201603 },
     "headers": ["memory_resource"],
+    "hosted": True,
   }, {
     "name": "__cpp_lib_move_only_function",
     "values": { "c++2b": 202110 },

     "values": { "c++17": 201603 },
     "headers": ["algorithm", "numeric"],
     "unimplemented": True,
+      "hosted": True,
   }, {
     "name": "__cpp_lib_polymorphic_allocator",
     "values": { "c++20": 201902 },
     "headers": ["memory_resource"],
+    "hosted": True,
   }, {
     "name": "__cpp_lib_quoted_string_io",
     "values": { "c++14": 201304 },
     "headers": ["iomanip"],
+    "hosted": True,
   }, {
     "name": "__cpp_lib_ranges",
     "values": { "c++20": 201811 },

     "name": "__cpp_lib_scoped_lock",
     "values": { "c++17": 201703 },
     "headers": ["mutex"],
+    "hosted": True,
   }, {
     "name": "__cpp_lib_semaphore",
     "values": { "c++20": 201907 },
     "headers": ["semaphore"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)",
+    "hosted": True,
   }, {
     "name": "__cpp_lib_shared_mutex",
     "values": { "c++17": 201505 },
     "headers": ["shared_mutex"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
+    "hosted": True,
   }, {
     "name": "__cpp_lib_shared_ptr_arrays",
     "values": { "c++17": 201611, "c++20": 201707 },
     "headers": ["memory"],
+    "hosted": True,
   }, {
     "name": "__cpp_lib_shared_ptr_weak_type",
     "values": { "c++17": 201606 },
     "headers": ["memory"],
+    "hosted": True,
   }, {
     "name": "__cpp_lib_shared_timed_mutex",
     "values": { "c++14": 201402 },
     "headers": ["shared_mutex"],
     "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)",
+    "hosted": True,
   }, {
     "name": "__cpp_lib_shift",
     "values": { "c++20": 201806 },

     "values": { "c++20": 202002 },
     "headers": ["memory"],
     "unimplemented": True,
+    "hosted": True,
   }, {
     "name": "__cpp_lib_source_location",
     "values": { "c++20": 201907 },

     "values": { "c++2b": 202106 },
     "headers": ["spanstream"],
     "unimplemented": True,
+    "hosted": True,
   }, {
     "name": "__cpp_lib_ssize",
     "values": { "c++20": 201902 },

     "values": { "c++2b": 202011 },
     "headers": ["stacktrace"],
     "unimplemented": True,
+    "hosted": True,
   }, {
     "name": "__cpp_lib_starts_ends_with",
     "values": { "c++20": 201711 },

     "values": { "c++20": 201803 },
     "headers": ["syncstream"],
     "unimplemented": True,
+    "hosted": True,
   }, {
     "name": "__cpp_lib_three_way_comparison",
     "values": { "c++20": 201907 },

 assert feature_test_macros == sorted(feature_test_macros, key=lambda tc: tc["name"])
 assert all(tc["headers"] == sorted(tc["headers"]) for tc in feature_test_macros)
 assert all(("libcxx_guard" in tc) == ("test_suite_guard" in tc) for tc in feature_test_macros)
-assert all(all(key in ["name", "values", "headers", "libcxx_guard", "test_suite_guard", "unimplemented"] for key in tc.keys()) for tc in feature_test_macros)
+assert all(all(key in ["name", "values", "headers", "libcxx_guard", "test_suite_guard", "unimplemented", "hosted"] for key in tc.keys()) for tc in feature_test_macros)
 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.

   for tc in feature_test_macros:
     if std not in tc["values"]:
       continue
+    ishosted = "hosted" in tc.keys()
     inner_indent = 1
+    if ishosted:
+      result += "# ifndef LIBCXX_FREESTANDING\n"
+      inner_indent += 2
     if 'test_suite_guard' in tc.keys():
-      result += "# if %s\n" % tc["libcxx_guard"]
+      ishosted_test_guard = "# if %s\n"
+      if ishosted:
+        ishosted_test_guard = "#   if %s\n"
+      result += ishosted_test_guard % tc["libcxx_guard"]
       inner_indent += 2
     if get_value_before(tc["values"], std) is not None:
       assert 'test_suite_guard' not in tc.keys()

     result += line
     result += "\n"
     if 'test_suite_guard' in tc.keys():
+      if ishosted:
+        result += "#   endif\n"
+      else:
+        result += "# endif\n"
+    if ishosted:
       result += "# endif\n"
   return result.strip()