CTFE and BetterC compatibility

Apr 27, 2022

Claude

Apr 27, 2022

Apr 27, 2022

Apr 27, 2022

Apr 27, 2022

Apr 27, 2022

Apr 27, 2022

Apr 28, 2022

Apr 28, 2022

Apr 28, 2022

Apr 28, 2022

April 27, 2022

CTFE and BetterC compatibility

Posted by Claude

Permalink

Claude

Permalink

Hello,

I want to make a SAX XML parser in D that I could both use at run-time or compile-time.

Also when I use it at compile-time, I would like to use BetterC so I don't have to link D-runtime.

But I have some compilation problems. I use GDC (GCC 9.4.0).

Here's a reduced sample code:

struct Data
{
    int[] digits;
}

int parseDigit(char c) pure
{
    return c - '0';
}

Data parse(string str) pure
{
    Data data;

    while (str.length != 0)
    {
        // Skip spaces
        while (str[0] == ' ')
            str = str[1 .. $];

        // Parse single digit integer
        data.digits ~= parseDigit(str[0]);

        // Consume digit
        str = str[1 .. $];
    }

    return data;
}

enum Data parsedData = parse("5 4 2 6 9");

extern(C) int main()
{
    pragma(msg, "First digit=", parsedData.digits[0]);
    return 0;
}

If I compile and link against D-runtime, it works:

$ gcc test.d -lgdruntime -o test
First digit=5

If I compile with BetterC (no D-runtime for GDC), I get a compilation error about RTTI:

$ gcc test.d -fno-druntime -o test
test.d: In function ‘parse’:
test.d:25:21: error: ‘object.TypeInfo’ cannot be used with -fno-rtti
   25 |         data.digits ~= parseDigit(str[0]);
      |                     ^

If I compile without the BetterC switch, compilation actually works but I'll have some linker issues:

$ gcc test.d -o test
First digit=5
/tmp/ccuPwjdv.o : In function « _D5test5parseFNaAyaZS5test4Data » :
test.d:(.text+0x137) : undefined reference to « _d_arraybounds »
test.d:(.text+0x183) : undefined reference to « _d_arraybounds »

etc...

The operation requiring the D-runtime is appending the array, but it should only be done at compile-time.

I don't understand why it requires to link against the D-runtime whereas it only needs it at compilation-time (and the compilation and CTFE interpretation works, as we can see in the last example).

Is there a way to force the compiler to not emit any object ode for those functions?

Or am I missing something?

Regards,

Claude

$ gcc test.d -o test First digit=5 /tmp/ccuPwjdv.o : In function « _D5test5parseFNaAyaZS5test4Data » : test.d:(.text+0x137) : undefined reference to « _d_arraybounds » test.d:(.text+0x183) : undefined reference to « _d_arraybounds » etc...

This works: ```d struct Data { int[] digits; } int parseDigit(char c) pure { return c - '0'; } Data parse(string str) pure { Data data; if (__ctfe) { size_t used; data.digits.length = str.length; while (str.length != 0) { // Skip spaces while (str[0] == ' ') str = str[1 .. $]; // Parse single digit integer data.digits[used++] = parseDigit(str[0]); // Consume digit str = str[1 .. $]; } data.digits = data.digits[0 .. used]; } return data; } enum Data parsedData = parse("5 4 2 6 9"); extern(C) int main() { pragma(msg, "First digit=", parsedData.digits[0]); return 0; } ```

On Wednesday, 27 April 2022 at 14:27:43 UTC, Stanislav Blinov wrote:

This is a long-standing pain point with BetterC (see https://issues.dlang.org/show_bug.cgi?id=19268).

That's what I was afraid of... Thanks for the link to the bug-report.

On Wednesday, 27 April 2022 at 14:27:43 UTC, Stanislav Blinov wrote:

When not using BetterC, but not linking against druntime either, you have to provide your own implementation for those functions. This is e.g. so you can replace druntime with your own version.

Yeah... The problem is that there will a lot of those functions to define (for a whole XML parser). I suppose I can use cork functions with empty bodies??

I will check if the linker optimize them out...

On Wednesday, 27 April 2022 at 14:34:27 UTC, rikki cattermole wrote: > This works: Cool, thanks. Unfortunately, with that implementation, I need to know the maximum size for the array. It works for that particular example, but in the context of an XML file analysis, it's a bit awkward. Regarding my comment above, I tried using cork functions for missing symbols: it also works! However the linker does not optimize those functions out (I see the symbols in the executable binary)...

On Wednesday, 27 April 2022 at 14:21:15 UTC, Claude wrote: > The operation requiring the D-runtime is appending the array, but it should **only** be done at compile-time. In that case, you want to prove to the compiler it is only called at compile time by encapsulating the function inside a template or defining it immediately where it is called. Delete the stand-alone function `parse` and instead call it like this: ``` // define it.... enum Data parsedData = function Data (string str) pure { Data data; while (str.length != 0) { // Skip spaces while (str[0] == ' ') str = str[1 .. $]; // Parse single digit integer data.digits ~= parseDigit(str[0]); // Consume digit str = str[1 .. $]; } return data; } ("5 4 2 6 9"); // and call it in the same place ``` Or if you want it to be independently defined still, you can define it inside a helper template but you'd have to return a basic type instead of Data, so I think calling it immediately is what you want to do here. There was going to be a ctfe-only thing you could put in the function so the compiler doesn't try to generate the runtime version, but this got killed due to internal D politics. A pity.

On Thursday, 28 April 2022 at 12:36:56 UTC, Dennis wrote: > In this case, it was actually a trailing whitespace in the changelog entry making the test suite fail, but the PR author Stefan's own `assert(__ctfe);` approach was better anyway...

Forums