C++0x standalone standard library implementation requirements?

[User Name:]

I vaguely remember that there is a special spec in the C standard for standalone(no OS intervention) implementations of libc. I have two questions, 1) What chapter/section is this in? 2) Is there a C++/STL equivalent?

I'm considering doing a rewrite of my, so far, insignificant kernel in C++, if most of the relevant part of the STL is required for standalone implementations.

EDIT: I just remembered, it's called "freestanding," and it's covered in 5.1.2.1. Now that I know the official name I can do some research in the C++ standards.

[grumpy]

Both the C and C++ standards specify a "hosted" and a "freestanding" implementation. "Hosted" essentially means "supports everything in the standard". "Freestanding" means "at least a specified subset of the library". Program startup and termination (i.e. what happens before and after main(), if supported) are implementation defined for a freestanding environment.

In the 1999 C standard, a conforming freestanding implementation is limited to not using complex types (as in complex numbers), and is required to support (as a minimum) standard headers <float.h>, <iso646.h>, <limits.h>, <stdarg.h>, <stdbool.h>, <stddef.h>, and <stdint.h>. The relevant clauses are in Section 4 "Conformance", para 6 and there is more said in Section 5.1.2.1 "Freestanding environment".

In the 1998 C++ standard, the minimum subset of the library that a freestanding is in the headers <cstddef>, <limits>, <cstdlib>, <new>, <typeinfo>, <exception>, and <cstdarg>. <cstddef> must declare, at minimum, abort(), atexit(), and exit(). The relevant section in the C++ standard is 17.4.1.3 "Freestanding implementations".

In both standards, it is implementation defined whether or not other standard headers are supported in a freestanding implementation. In other words, freestanding implementations are not limited to just the minimum.

I'm not sure offhand if the proposed C++0x changes the definition of a freestanding implementation, or if the sections are named or numbered differently.

[rt454]

My version of the C++0x draft says the freestanding subset(17.6.1.3) must consist of:

• <cstddef>
• <limits>
• <cstdlib>
• <new>
• <typeinfo>
• <exception>
• <initializer_list>
• <cstdarg>
• <type_traits>
• <thread>

The supplied version of the header <cstdlib> shall declare at least the functions abort, atexit, at_ quick_exit, exit, and quick_exit (18.5).

The supplied version of the header <thread> shall meet the same requirements as for a hosted implementation or including it shall have no effect. The other headers listed in this table shall meet the same requirements as for a hosted implementation.

[User Name:]

Thanks. That's disappointing. I was hoping they would require the parts of the STL that don't need dynamic allocation.

[grumpy]

There is nothing preventing a freestanding implementation from implementing more than the minimum.

Simply document the requirements of your "kernel" to be a minimal freestanding implementation plus whatever other headers you need.

If your "kernel" is "insignificant", it is quite possible the amount of the STL needed would be quite small (eg a subset of the algorithms). A lot of the STL is actually quite simple, so you might be able to implement a usable equivalent for your kernel. That would require some more work, but would allow you to target a minimal freestanding implementation.

Incidentally, the logic of these things normally goes the other way. Someone implementing a compiler for a computing platform decides whether to make it hosted or freestanding. Then you, as an end-user developing your "kernel", decide which computing platforms to target.

[User Name:]

I know what you mean. All I really need, for now, is bitset for my heap allocator. I like to keep things really neat, and well designed. I'd like to avoid the work necessary to implement a well designed subset of libc++. That's basically my only reason for not just making a simple bitset for myself. I guess I'll just go ahead and do it anyway.

Thanks.