CODEWITHSUNDEEP
cgcccompilationcompiler-optimizationcompile-time
VannTen
VannTen

Reputation: 461

Can gcc/clang optimize initialization computing?

I recently wrote a parser generator tool that takes a BNF grammar (as a string) and a set of actions (as a function pointer array) and output a parser (= a state automaton, allocated on the heap). I then use another function to use that parser on my input data and generates a abstract syntax tree.

In the initial parser generation, there is quite a lot of steps, and i was wondering if gcc or clang are able to optimize this, given constant inputs to the parser generation function (and never using the pointers values, only dereferencing them) ? Is is possible to run the function at compile time, and embed the result (aka, the allocated memory) in the executable ?

(obviously, that would be using link time optimization, since the compiler would need to be able to check that the whole function does indeed have the same result with the same parameters)

Upvotes: 1

Views: 94

Answers (1)

dbush
dbush

Reputation: 225437

What you could do in this case is have code that generates code.

Have your initial parser generator as a separate piece of code that runs independently. The output of this code would be a header file containing a set of variable definitions initialized to the proper values. You then use this file in your main code.

As an example, suppose you have a program that needs to know the number of bits that are set in a given byte. You could do this manually whenever you need:

int count_bits(uint8_t b)
{
    int count = 0;
    while (b) {
        count += b & 1;
        b >>= 1;
    }
    return count;
}

Or you can generate the table in a separate program:

int main()
{
    FILE *header = fopen("bitcount.h", "w");
    if (!header) {
        perror("fopen failed");
        exit(1);
    }

    fprintf(header, "int bit_counts[256] = {\n");

    int count;
    unsigned v;

    for (v=0,count=0; v<256; v++) {
        uint8_t b = v;
        while (b) {
            count += b & 1;
            b >>= 1;
        }
        fprintf(header, "    %d,\n" count);
    }

    fprintf(header, "};\n");
    fclose(header);
    return 0;
}

This create a file called bitcount.h that looks like this:

int bit_counts[256] = {
    0,
    1,
    1,
    2,
    ...
    7,
};

That you can include in your "real" code.

Upvotes: 1

Related Questions