Re: Compile time executed functions

[Robert A Duff <bobduff@world.std.com>]

Ted Dennison<dennison@telepath.com> writes:

> In article <wcc1yrje0nr.fsf@world.std.com>, Robert A Duff says...
> >
> >Mats Karlssohn <mats@mida.se> writes:
> >
> >> Sometimes, especially when doing embedded programming, I feel a great
> >> need to execute a function to get literal initialization a constant.
> >> That is I'd like to have the compiler to execute a function for me (at
> >> compiletime!) and use the return of that function to initialize the
> >> constant.
> >
> >If you inline the function, you are likely to get what you want,
> >depending on how good the compiler's support for inlining is.
> 
> He also wanted the result of the function to be put into the ROM area when the
> executable is created by the compiler. Inlining wouldn't do that,
> would it?

Why not?  If the value of the constant is known to the compiler, then it
can go in ROM (presuming the compiler and linker and whatnot support ROM
at all).

>... It
> just prevents the little extra subprogram call overhead (saving and restoring
> the register context, etc) when the function is called at runtime.

Inlining does that, but it also allows the compiler to optimize through
the inlined code.  Eg:

    function Factorial(X: Natural) return Positive is
        pragma Inline(Factorial);
    begin
        if X = 0 then
            return 1;
        else
            return Factorial(X-1) * X;
        end if;
    end Factorial;

    Y: constant Integer := Factorial(7);

I have seen compilers that will generate the same code for the above
that is generated for:

    Y: constant Integer := 5040;

My point is that inlining is not just for removing the call overhead.
It is also for letting the compiler reason about the code as if it
were written in line at the call site.

- Bob