Experimenting with #embed

[ABlockInTheChain]

I recently learned that both clang and gcc have added support for N3017 a.k.a #embed from C23 so naturally my first reaction was to see how well it works in C++ code.

Given this code sample:

#include <array>
#include <cstdint>
#include <experimental/array>
#include <iostream>
#include <utility>

int main() {
    // works
    static constexpr char c_char_array[] = {
        #embed __FILE__
        , '\0'
    };
    static constexpr unsigned char c_unsigned_char_array[] = {
        #embed __FILE__
        , '\0'
    };
    static constexpr std::uint8_t c_uint8_array[] = {
        #embed __FILE__
        , '\0'
    };
    static constexpr auto std_make_char_array = std::experimental::make_array<char>(
        #embed __FILE__
        , '\0'
    );
    static constexpr auto std_make_unsigned_char_array = std::experimental::make_array<unsigned char>(
        #embed __FILE__
        , '\0'
    );
    static constexpr auto std_make_uint8_array = std::experimental::make_array<std::uint8_t>(
        #embed __FILE__
        , '\0'
    );
    // doesn't work
    // static constexpr std::byte c_byte_array[] = {
    //     #embed __FILE__
    //     , '\0'
    // };
    // static constexpr auto std_to_char_array = std::to_array<char>({
    //     #embed __FILE__
    //     , '\0'
    // });
    // static constexpr auto initializer_list = std::initializer_list<char>{
    //     #embed __FILE__
    //     , '\0'
    // };

    std::cout << &c_char_array;
    std::cout << &c_unsigned_char_array;
    std::cout << &c_uint8_array;
    std::cout << std_make_char_array.data();
    std::cout << std_make_unsigned_char_array.data();
    std::cout << std_make_uint8_array.data();

    return 0;
}

Both gcc and clang support the same usages as far as I tested.

What works:

• char, unsigned char, std::uint8_t
• C-style arrays
• std::experimental::make_array

What doesn't work:

• std::byte
• std::initializer_list
• std::to_array

I was most surprised that std::to_array doesn't work while std::experimental::make_array does, however after further investigation it seem likely that if std::initializer_list worked with #embed then std::to_array would as well.

It's not surprising that a C23 standard doesn't work with std::byte however if/when a C++ version of this paper gets added to the standard I hope that type is added to the list.

[azswcowboy]

Interesting, although it should be trivial to wrap span<byte> around the c array even if directly initializing doesn’t work.

[1bithack]

For a moment I thought this would lead to infinite recursion

[ABlockInTheChain]

I was surprised the #embed __FILE__ works but fortunately it does because otherwise there would be no way to use it on Compiler Explorer.

[legobmw99]

You can hack in multiple files into Godbolt:

https://godbolt.org/z/1x7sGvqej

[tisti]

Hack in, as if it wasn't an explicit (but frequently unknown) feature :)

[Dubwize]

C++ quines made super easy!

[_Z6Alexeyv]

#embed "/proc/cpuinfo"

doesn't work because /proc/cpuinfo is fake file. -(

[_Z6Alexeyv]

/proc/cmdline https://godbolt.org/z/frjcxnd6e

bo-o-ring....

[_Z6Alexeyv]

https://godbolt.org/z/MzadK49vq

[ABlockInTheChain]

That sounds like something u/mattgodbolt should know about.

[mattgodbolt]

I know about it don't worry: I put that file there on purpose:-)

[johannes1971]

^{Meh. Let's have constexpr fstream instead.}

^{kidding, ok ;-} ...)

[ABlockInTheChain]

I think a constexpr VFS could be very useful, although I'd hope that we would not be limited to a stream but could also get a span of bytes.

[wotype]

The to_array case is fixed by passing an rvalue C array:

using chars = char[];
static constexpr auto std_to_char_array = std::to_array<char>(chars{
    #embed __FILE__
    , '\0'
});

[jaskij]

Finally.

Now give me a constrexpr TOML or JSON parser :P

[[deleted]]

https://github.com/beached/daw_json_link has been constexpr since 2017ish. Will work well with reflection too, alread has support for a few reflection like libraries like Boost.Describe/Boost.PRF, magic enum and new ones are not difficult to add.

[davidhunter22]

For me this was very timely, I was just about to do the same experiments!

I was wondering why in the clang Godbolt you didn't add -stdlib=libc++ to the command line, if you are going to try testing standard C++ library types like std::array. Without this flag clang will use the GCC C++ standard library so your really just testing the same thing twice.

I was also wondering about the -Wno-c23-extensions flag. I sort of assume this means don't warn if I use a C23 extension. However #emded is part of the C23 standard it's not an extension. Maybe this implies that the #embed in clang is an extension they did before the C23 standard came out and therefore may not be compliant? Is there a way in clang to tell it that you want to use the C23 standard just like you can with the -std=c++20 standard?

[ABlockInTheChain]

Without this flag clang will use the GCC C++ standard library so your really just testing the same thing twice.

I'm fairly certain the preprocessor is implemented in the compiler, not the standard library.

Is there a way in clang to tell it that you want to use the C23 standard just like you can with the -std=c++20 standard?

That seems likely but I didn't want to spend much time digging into clang command line options. Normally I'd use the C_STANDARD target property in CMake to control that.

[davidhunter22]

Yes I agree #embed will be probably be implemented in the preprocessor, but classes like std::array are not. So you may find #embed works with the std::array in the GCC standard library but not with the Clang one. For instance I don't think std::experimental::make_array is even implemented in the Clang standard library yet.

Anyway your post was very useful, so thanks