[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

    to provide compile-time errors when using features unavailable on some version of
    the shared library they shipped should turn this on and see `include/__availability`
    for more details." OFF)
-
-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++-mingw.cfg.in")
-elseif(WIN32) # clang-cl
-  if (LIBCXX_ENABLE_SHARED)
-    set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared-clangcl.cfg.in")
-  else()
-    set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-static-clangcl.cfg.in")
-  endif()
+option(LIBCXX_FREESTANDING OFF
+  "Build libc++ with freestanding headers. This toggle allows the libc to work for
+  freestanding environments like operating systems kernels or embedded systems.")
+
+if (LIBCXX_FREESTANDING)
+  set(LIBCXX_ENABLE_FILESYSTEM 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)
 else()
-  if (LIBCXX_ENABLE_SHARED)
-    set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared.cfg.in")
+  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++-mingw.cfg.in")
+  elseif(WIN32) # clang-cl
+    if (LIBCXX_ENABLE_SHARED)
+      set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared-clangcl.cfg.in")
+    else()
+      set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-static-clangcl.cfg.in")
+    endif()
   else()
-    set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-static.cfg.in")
+    if (LIBCXX_ENABLE_SHARED)
+      set(LIBCXX_DEFAULT_TEST_CONFIG "llvm-libc++-shared.cfg.in")
+    else()
+      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'.")
-if (NOT IS_ABSOLUTE "${LIBCXX_TEST_CONFIG}")
-  set(LIBCXX_TEST_CONFIG "${CMAKE_CURRENT_SOURCE_DIR}/test/configs/${LIBCXX_TEST_CONFIG}")
-endif()
-message(STATUS "Using libc++ testing configuration: ${LIBCXX_TEST_CONFIG}")
-set(LIBCXX_TEST_PARAMS "" CACHE STRING
-    "A list of parameters to run the Lit test suite with.")
-
-# Benchmark options -----------------------------------------------------------
-option(LIBCXX_INCLUDE_BENCHMARKS "Build the libc++ benchmarks and their dependencies" ON)
-
-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")
-
-set(LIBCXX_BENCHMARK_NATIVE_STDLIB "" CACHE STRING
-        "Build the benchmarks against the specified native STL.
-         The value must be one of libc++/libstdc++")
-set(LIBCXX_BENCHMARK_NATIVE_GCC_TOOLCHAIN "" CACHE STRING
-    "Use alternate GCC toolchain when building the native benchmarks")
-
-if (LIBCXX_BENCHMARK_NATIVE_STDLIB)
-  if (NOT (LIBCXX_BENCHMARK_NATIVE_STDLIB STREQUAL "libc++"
-        OR LIBCXX_BENCHMARK_NATIVE_STDLIB STREQUAL "libstdc++"))
-    message(FATAL_ERROR "Invalid value for LIBCXX_BENCHMARK_NATIVE_STDLIB: "
-            "'${LIBCXX_BENCHMARK_NATIVE_STDLIB}'")
+  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'.")
+  if (NOT IS_ABSOLUTE "${LIBCXX_TEST_CONFIG}")
+    set(LIBCXX_TEST_CONFIG "${CMAKE_CURRENT_SOURCE_DIR}/test/configs/${LIBCXX_TEST_CONFIG}")
+  endif()
+  message(STATUS "Using libc++ testing configuration: ${LIBCXX_TEST_CONFIG}")
+  set(LIBCXX_TEST_PARAMS "" CACHE STRING
+      "A list of parameters to run the Lit test suite with.")
+
+  # Benchmark options -----------------------------------------------------------
+  option(LIBCXX_INCLUDE_BENCHMARKS "Build the libc++ benchmarks and their dependencies" ON)
+
+  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")
+
+  set(LIBCXX_BENCHMARK_NATIVE_STDLIB "" CACHE STRING
+          "Build the benchmarks against the specified native STL.
+          The value must be one of libc++/libstdc++")
+  set(LIBCXX_BENCHMARK_NATIVE_GCC_TOOLCHAIN "" CACHE STRING
+      "Use alternate GCC toolchain when building the native benchmarks")
+
+  if (LIBCXX_BENCHMARK_NATIVE_STDLIB)
+    if (NOT (LIBCXX_BENCHMARK_NATIVE_STDLIB STREQUAL "libc++"
+          OR LIBCXX_BENCHMARK_NATIVE_STDLIB STREQUAL "libstdc++"))
+      message(FATAL_ERROR "Invalid value for LIBCXX_BENCHMARK_NATIVE_STDLIB: "
+              "'${LIBCXX_BENCHMARK_NATIVE_STDLIB}'")
+    endif()
   endif()
 endif()
-
 option(LIBCXX_INCLUDE_DOCS "Build the libc++ documentation." ${LLVM_INCLUDE_DOCS})
 set(LIBCXX_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}" CACHE STRING
     "Define suffix of library directory name (32/64)")
 option(LIBCXX_INSTALL_HEADERS "Install the libc++ headers." ON)
+if(NOT LIBCXX_FREESTANDING)
 option(LIBCXX_INSTALL_LIBRARY "Install the libc++ library." ON)
 cmake_dependent_option(LIBCXX_INSTALL_STATIC_LIBRARY
   "Install the static libc++ library." ON

 cmake_dependent_option(LIBCXX_INSTALL_SHARED_LIBRARY
   "Install the shared libc++ library." ON
   "LIBCXX_ENABLE_SHARED;LIBCXX_INSTALL_LIBRARY" OFF)
+endif()
 
 option(LIBCXX_ABI_UNSTABLE "Use the unstable ABI of libc++. This is equivalent to specifying LIBCXX_ABI_VERSION=n, where n is the not-yet-stable version." OFF)
 if (LIBCXX_ABI_UNSTABLE)

 set(LIBCXX_COVERAGE_LIBRARY "" CACHE STRING
     "The Profile-rt library used to build with code coverage")
 
+if (LIBCXX_FREESTANDING)
+set(LIBCXX_ENABLE_THREADS OFF)
+set(LIBCXX_ENABLE_MONOTONIC_CLOCK OFF)
+endif()
+
 set(LIBCXX_CONFIGURE_IDE_DEFAULT OFF)
 if (XCODE OR MSVC_IDE)
   set(LIBCXX_CONFIGURE_IDE_DEFAULT ON)

 
 # Ensure LIBCXX_ENABLE_MONOTONIC_CLOCK is set to ON only when
 # LIBCXX_ENABLE_THREADS is on.
+if (NOT LIBCXX_FREESTANDING)
 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.")

     message(FATAL_ERROR "LIBCXX_HAS_WIN32_THREAD_API can only be set to ON"
                         " when LIBCXX_ENABLE_THREADS is also set to ON.")
   endif()
-
 endif()
 
 if (LIBCXX_HAS_EXTERNAL_THREAD_API)

 if (LIBCXX_ABI_FORCE_ITANIUM AND LIBCXX_ABI_FORCE_MICROSOFT)
   message(FATAL_ERROR "Only one of LIBCXX_ABI_FORCE_ITANIUM and LIBCXX_ABI_FORCE_MICROSOFT can be specified.")
 endif ()
-
+endif ()
 #===============================================================================
 # Configure System
 #===============================================================================

     # default libunwind (which may be missing still).
     target_add_link_flags_if_supported(${target} PRIVATE "--unwindlib=none")
   endif()
-
+  if (NOT LIBCXX_FREESTANDING)
   if (LIBCXX_HAS_SYSTEM_LIB)
     target_link_libraries(${target} PRIVATE System)
   endif()

     # Required for standards-complaint wide character formatting functions
     # (e.g. `printfw`/`scanfw`)
     target_link_libraries(${target} PRIVATE iso_stdio_wide_specifiers)
     endif()
-
   if (ANDROID AND ANDROID_PLATFORM_LEVEL LESS 21)
     target_link_libraries(${target} PUBLIC android_support)
   endif()
   target_link_libraries(${target} PUBLIC "${LIBCXX_ADDITIONAL_LIBRARIES}")
+  endif()
 endfunction()
 
 # Windows-related flags =======================================================

   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)
   foreach (abi_define ${LIBCXX_ABI_DEFINES})

 # Setup Source Code And Tests
 #===============================================================================
 add_subdirectory(include)
+if (NOT LIBCXX_FREESTANDING)
 add_subdirectory(src)
 add_subdirectory(utils)
 

   add_subdirectory(test)
   add_subdirectory(lib/abi)
 endif()
+endif()
 
 if (LIBCXX_INCLUDE_DOCS)
   add_subdirectory(docs)

libcxx/include/__algorithm/sort.h

   __less<uintptr_t> __comp;
   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/__compare/strong_order.h

 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/priority_tag.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <cmath>
+#endif
 #include <cstdint>
 #include <limits>
 #include <type_traits>

             noexcept(noexcept(strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
             -> decltype(      strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
             { return          strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
-
+#ifndef _LIBCPP_FREESTANDING
         template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
             requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
         _LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering

                 }
             }
         }
-
+#endif
         template<class _Tp, class _Up>
             requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
         _LIBCPP_HIDE_FROM_ABI static constexpr auto

libcxx/include/__compare/weak_order.h

 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/priority_tag.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <cmath>
+#endif
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER

             -> decltype(      weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
             { return          weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
 
+#ifndef _LIBCPP_FREESTANDING
         template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
             requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
         _LIBCPP_HIDE_FROM_ABI static constexpr weak_ordering

                 }
             }
         }
+#endif
 
         template<class _Tp, class _Up>
             requires is_same_v<decay_t<_Tp>, decay_t<_Up>>

libcxx/include/__config

 #  define _LIBCPP_COMPILER_GCC
 #endif
 
+#  if __STDC_HOSTED__ == 0
+#    undef _LIBCPP_FREESTANDING
+#    define _LIBCPP_FREESTANDING
+#  endif
+
 #ifdef __cplusplus
 
 // _LIBCPP_VERSION represents the version of libc++, which matches the version of LLVM.

 // generate identifiers that must be unique for every released libc++ version.
 #  define _LIBCPP_VERSIONED_IDENTIFIER _LIBCPP_CONCAT(v, _LIBCPP_VERSION)
 
-#  if __STDC_HOSTED__ == 0
-#    define _LIBCPP_FREESTANDING
-#  endif
-
 #  ifndef _LIBCPP_STD_VER
 #    if __cplusplus <= 201103L
 #      define _LIBCPP_STD_VER 11

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

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

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

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/__random/uniform_int_distribution.h

 #include <bit>
 #include <cstddef>
 #include <cstdint>
+#ifndef _LIBCPP_FREESTANDING
 #include <iosfwd>
+#endif
 #include <limits>
 #include <type_traits>
 

     return static_cast<result_type>(__u + __p.a());
 }
 
+#ifndef _LIBCPP_FREESTANDING
+
 template <class _CharT, class _Traits, class _IT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,

         __x.param(param_type(__a, __b));
     return __is;
 }
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 

libcxx/include/__string/char_traits.h

 #include <__type_traits/is_constant_evaluated.h>
 #include <cstddef>
 #include <cstdint>
+#ifndef _LIBCPP_FREESTANDING
 #include <cstdio>
+#endif
 #include <iosfwd>
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) && !defined(_LIBCPP_FREESTANDING)
 #   include <cwchar> // for wmemcpy
 #endif
 

 {
     using char_type  = _CharT;
     using int_type   = int;
+#ifndef _LIBCPP_FREESTANDING
     using off_type   = streamoff;
     using pos_type   = streampos;
     using state_type = mbstate_t;
-
+#endif
     static inline void _LIBCPP_CONSTEXPR_SINCE_CXX17
         assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT

     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR_SINCE_CXX20
     char_type*       assign(char_type* __s, size_t __n, char_type __a);
-
+#if defined(EOF)
     static inline _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+#endif
     static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
         {return char_type(__c);}
     static inline _LIBCPP_CONSTEXPR int_type  to_int_type(char_type __c) _NOEXCEPT
         {return int_type(__c);}
     static inline _LIBCPP_CONSTEXPR bool      eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
+#if defined(EOF)
     static inline _LIBCPP_CONSTEXPR int_type  eof() _NOEXCEPT
         {return int_type(EOF);}
+#endif
 };
 
 template <class _CharT>

 {
     using char_type           = char;
     using int_type            = int;
+#ifndef _LIBCPP_FREESTANDING
     using off_type            = streamoff;
     using pos_type            = streampos;
     using state_type          = mbstate_t;
+#endif
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif

         std::fill_n(__s, __n, __a);
         return __s;
     }
-
+#if defined(EOF)
     static inline _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+#endif
     static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
         {return char_type(__c);}
     static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
         {return int_type((unsigned char)__c);}
     static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
+#if defined(EOF)
     static inline _LIBCPP_CONSTEXPR int_type  eof() _NOEXCEPT
         {return int_type(EOF);}
+#endif
 };
 
 inline _LIBCPP_CONSTEXPR_SINCE_CXX17

 struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
 {
     using char_type           = wchar_t;
+#if defined(WEOF)
     using int_type            = wint_t;
     using off_type            = streamoff;
     using pos_type            = streampos;
     using state_type          = mbstate_t;
+#endif
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif

         std::fill_n(__s, __n, __a);
         return __s;
     }
-
+#if defined(WEOF)
     static inline _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
     static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
         {return char_type(__c);}
     static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
         {return int_type(__c);}
+
     static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
         {return int_type(WEOF);}
+#endif
 };
 
 inline _LIBCPP_CONSTEXPR_SINCE_CXX17

         return 0;
 #if __has_feature(cxx_constexpr_string_builtins)
     return __builtin_wmemcmp(__s1, __s2, __n);
-#elif _LIBCPP_STD_VER <= 14
+#elif _LIBCPP_STD_VER <= 14 && !defined(_LIBCPP_FREESTANDING)
     return _VSTD::wmemcmp(__s1, __s2, __n);
 #else
     for (; __n; --__n, ++__s1, ++__s2)

         return nullptr;
 #if __has_feature(cxx_constexpr_string_builtins)
     return __builtin_wmemchr(__s, __a, __n);
-#elif _LIBCPP_STD_VER <= 14
+#elif _LIBCPP_STD_VER <= 14 && !defined(_LIBCPP_FREESTANDING)
     return _VSTD::wmemchr(__s, __a, __n);
 #else
     for (; __n; --__n)

 {
     using char_type           = char8_t;
     using int_type            = unsigned int;
+#ifndef _LIBCPP_FREESTANDING
     using off_type            = streamoff;
     using pos_type            = u8streampos;
     using state_type          = mbstate_t;
+#endif
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif

         std::fill_n(__s, __n, __a);
         return __s;
     }
-
+#if defined(EOF)
     static inline constexpr int_type  not_eof(int_type __c) noexcept
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+#endif
     static inline constexpr char_type to_char_type(int_type __c) noexcept
         {return char_type(__c);}
     static inline constexpr int_type to_int_type(char_type __c) noexcept
         {return int_type(__c);}
     static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
         {return __c1 == __c2;}
+#if defined(EOF)
     static inline constexpr int_type eof() noexcept
         {return int_type(EOF);}
+#endif
 };
 
 // TODO use '__builtin_strlen' if it ever supports char8_t ??

 {
     using char_type           = char16_t;
     using int_type            = uint_least16_t;
+#ifndef _LIBCPP_FREESTANDING
     using off_type            = streamoff;
     using pos_type            = u16streampos;
     using state_type          = mbstate_t;
+#endif
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif

 {
     using char_type           = char32_t;
     using int_type            = uint_least32_t;
+#ifndef _LIBCPP_FREESTANDING
     using off_type            = streamoff;
     using pos_type            = u32streampos;
     using state_type          = mbstate_t;
+#endif
 #if _LIBCPP_STD_VER > 17
     using comparison_category = strong_ordering;
 #endif

libcxx/include/__thread/poll_with_backoff.h

 #ifndef _LIBCPP___THREAD_POLL_WITH_BACKOFF_H
 #define _LIBCPP___THREAD_POLL_WITH_BACKOFF_H
 
+#include <__config>
+
+#ifndef _LIBCPP_FREESTANDING
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/high_resolution_clock.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/time_point.h>
-#include <__config>
 #include <__filesystem/file_time_type.h>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+
+template<class _Fn>
+_LIBCPP_INLINE_VISIBILITY
+bool __libcpp_thread_poll_with_backoff_freestanding(_Fn&& __f) {
+    for (;;) {
+      if (__f())
+        return true; // _Fn completion means success
+    }
+}
+
+#ifndef _LIBCPP_FREESTANDING
 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

     }
 }
 
+
 // A trivial backoff policy that always immediately returns the control to
 // the polling loop.
 //

       return false;
   }
 };
-
+#endif
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___THREAD_POLL_WITH_BACKOFF_H

libcxx/include/atomic

 #include <__chrono/duration.h>
 #include <__config>
 #include <__thread/poll_with_backoff.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <__thread/timed_backoff_policy.h>
+#endif
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_HAS_NO_THREADS
+#if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_FREESTANDING)
 # include <__threading_support>
 #endif
 

 
 using __cxx_atomic_contention_t = __cxx_atomic_impl<__cxx_contention_t>;
 
-#ifndef _LIBCPP_HAS_NO_THREADS
+#if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_FREESTANDING)
 
 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile*);
 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile*);

 template <class _Atp, class _Fn>
 _LIBCPP_INLINE_VISIBILITY bool __cxx_atomic_wait(_Atp*, _Fn && __test_fn)
 {
+#ifdef _LIBCPP_FREESTANDING
+    return __libcpp_thread_poll_with_backoff_freestanding(__test_fn);
+#else
     return __libcpp_thread_poll_with_backoff(__test_fn, __spinning_backoff_policy());
+#endif
 }
 
 #endif // _LIBCPP_HAS_NO_THREADS

libcxx/include/bitset

 // standard-mandated includes
 
 // [bitset.syn]
+#ifndef _LIBCPP_FREESTANDING
 #include <iosfwd>
 #include <string>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bitset() _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
         bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
+
     template<class _CharT, class = __enable_if_t<_IsCharLikeType<_CharT>::value> >
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
         explicit bitset(const _CharT* __str,
+#ifndef _LIBCPP_FREESTANDING
                         typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
+#else
+                        ::std::size_t __n = ::std::size_t(-1),
+#endif
                         _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
+#ifndef _LIBCPP_FREESTANDING
     template<class _CharT, class _Traits, class _Allocator>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
         explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,

                         typename basic_string<_CharT,_Traits,_Allocator>::size_type __n =
                                 (basic_string<_CharT,_Traits,_Allocator>::npos),
                         _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
-
+#endif
     // 23.3.5.2 bitset operations:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
     bitset& operator&=(const bitset& __rhs) _NOEXCEPT;

     unsigned long to_ulong() const;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
     unsigned long long to_ullong() const;
+#ifndef _LIBCPP_FREESTANDING
     template <class _CharT, class _Traits, class _Allocator>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
         basic_string<_CharT, _Traits, _Allocator> to_string(_CharT __zero = _CharT('0'),

     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
     basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
                                                                       char __one = '1') const;
+#endif
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
     size_t count() const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT {return _Size;}

 template<class _CharT, class>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
 bitset<_Size>::bitset(const _CharT* __str,
+#ifdef _LIBCPP_FREESTANDING
+                      _VSTD::size_t __n,
+#else
                       typename basic_string<_CharT>::size_type __n,
+#endif
                       _CharT __zero, _CharT __one)
 {
     size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));

     }
     _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
-
+#ifndef _LIBCPP_FREESTANDING
 template <size_t _Size>
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23

     }
     _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
+#endif
 
 template <size_t _Size>
 inline

     return base::to_ullong();
 }
 
+#ifndef _LIBCPP_FREESTANDING
 template <size_t _Size>
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23

 {
     return to_string<char, char_traits<char>, allocator<char> >(__zero, __one);
 }
+#endif
 
 template <size_t _Size>
 inline

         {return __bs.__hash_code();}
 };
 
+#ifndef _LIBCPP_FREESTANDING
 template <class _CharT, class _Traits, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x);

 template <class _CharT, class _Traits, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 

libcxx/include/compare

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__config>
 #include <__compare/common_comparison_category.h>
 #include <__compare/compare_partial_order_fallback.h>
 #include <__compare/compare_strong_order_fallback.h>

libcxx/include/cstdlib

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if defined(_LIBCPP_FREESTANDING)
+
+// Referenced from GNU libstdc++
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#endif
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 1
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+extern "C" _LIBCPP_NORETURN void abort(void) _NOEXCEPT;
+extern "C" int atexit(void (*)(void)) _NOEXCEPT;
+extern "C" _LIBCPP_NORETURN void exit(int) _NOEXCEPT;
+#if __cplusplus >= 201103L
+extern "C" int at_quick_exit(void (*)(void)) _NOEXCEPT;
+extern "C" _LIBCPP_NORETURN void quick_exit(int) _NOEXCEPT;
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#else
+
 #include <stdlib.h>
 
 #ifndef _LIBCPP_STDLIB_H

           not be the case.
 #endif
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::size_t _LIBCPP_USING_IF_EXISTS;

 #endif
 
 _LIBCPP_END_NAMESPACE_STD
+#endif
 
 #endif // _LIBCPP_CSTDLIB

libcxx/include/functional

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

libcxx/include/iosfwd

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#ifndef _LIBCPP_FREESTANDING
 #include <__mbstate_t.h>
+#endif
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_FREESTANDING
 class _LIBCPP_TYPE_VIS ios_base;
+#endif
 
 template<class _CharT>  struct _LIBCPP_TEMPLATE_VIS char_traits;
 template<> struct char_traits<char>;

 template<> struct char_traits<wchar_t>;
 #endif
 
+
+#ifndef _LIBCPP_FREESTANDING
 template<class _Tp>     class _LIBCPP_TEMPLATE_VIS allocator;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >

     }
 };
 
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_IOSFWD

libcxx/include/iterator

 #include <__iterator/incrementable_traits.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__iterator/insert_iterator.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <__iterator/istream_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
+#endif
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator.h>

 #include <__iterator/move_iterator.h>
 #include <__iterator/move_sentinel.h>
 #include <__iterator/next.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <__iterator/ostream_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
+#endif
 #include <__iterator/permutable.h>
 #include <__iterator/prev.h>
 #include <__iterator/projected.h>

libcxx/include/memory

 #include <__memory/align.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocation_guard.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <__memory/allocator.h>
+#endif
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/assume_aligned.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <__memory/auto_ptr.h>
+#endif
 #include <__memory/compressed_pair.h>
 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>

 #include <__memory/ranges_construct_at.h>
 #include <__memory/ranges_uninitialized_algorithms.h>
 #include <__memory/raw_storage_iterator.h>
+#ifndef _LIBCPP_FREESTANDING
 #include <__memory/shared_ptr.h>
+#endif
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.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/numeric

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#ifndef _LIBCPP_FREESTANDING
 #include <cmath> // for isnormal
+#endif
 #include <version>
 
 #include <__numeric/accumulate.h>

libcxx/include/ranges

 #include <type_traits>
 #include <version>
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_FREESTANDING)
 #include <__ranges/istream_view.h>
 #endif
 

libcxx/include/stdexcept

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <cstdlib>
-#include <exception>
-#include <iosfwd>  // for string forward decl
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+
+#if !defined(_LIBCPP_FREESTANDING)
+
+#include <cstdlib>
+#include <exception>
+#include <iosfwd>  // for string forward decl
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_ABI_VCRUNTIME

 };
 
 } // namespace std
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+
+#ifdef _LIBCPP_FREESTANDING
+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY void __throw_runtime_error(const char*){}
+#else
 // in the dylib
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
+#endif
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_logic_error(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw logic_error(__msg);
 #else
     ((void)__msg);

 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_domain_error(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw domain_error(__msg);
 #else
     ((void)__msg);

 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_invalid_argument(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw invalid_argument(__msg);
 #else
     ((void)__msg);

 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_length_error(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw length_error(__msg);
 #else
     ((void)__msg);

 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_out_of_range(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw out_of_range(__msg);
 #else
     ((void)__msg);

 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_range_error(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw range_error(__msg);
 #else
     ((void)__msg);

 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_overflow_error(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw overflow_error(__msg);
 #else
     ((void)__msg);

 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_underflow_error(const char*__msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
+#if !defined(_LIBCPP_NO_EXCEPTIONS) && !defined(_LIBCPP_FREESTANDING)
     throw underflow_error(__msg);
 #else
     ((void)__msg);

libcxx/include/stdlib.h

 #  pragma GCC system_header
 #endif
 
+#if defined(_LIBCPP_FREESTANDING)
+#include <cstdlib>
+
+using std::abort;
+using std::atexit;
+using std::exit;
+#if __cplusplus >= 201103L
+  using std::at_quick_exit;
+  using std::quick_exit;
+#endif
+
+#else
 #include_next <stdlib.h>
 
 #ifdef __cplusplus

 #endif // _LIBCPP_MSVCRT / __sun__
 } // extern "C++"
 #endif // __cplusplus
+#endif
 
 #endif // _LIBCPP_STDLIB_H

libcxx/include/string.h

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

       char* strstr(      char* __s1, const char* __s2) {return __libcpp_strstr(__s1, __s2);}
 }
 #endif
-
+#endif
 #endif // _LIBCPP_STRING_H

libcxx/include/string_view

 
 #endif //  _LIBCPP_STD_VER > 17
 
+#ifndef _LIBCPP_FREESTANDING
 template<class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            basic_string_view<_CharT, _Traits> __str);
+#endif
 
 // [string.view.hash]
 template<class _CharT>

libcxx/test/libcxx/libcpp_freestanding.sh.cpp

 #error _LIBCPP_FREESTANDING should be defined in freestanding mode and not \
        defined in non-freestanding mode
 #endif
+
+
+#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>
+
+
+/*
+ * libc++ Extensions
+ * We provide those headers as extensions
+ * just like libstdc++ do
+ */
+
+#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<charconv>