Re: Compile time executed functions

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

Mats Karlssohn <mats@mida.se> writes:

> I agree on the location issue (RAM vs. ROM), but the control over how
> and when the code is executed is already a language issue I think.
> We already have generics in the language wich controls how code should
> be generated. 

I don't think so.  Some compilers generate a separate piece of code for
each instance, some compilers generate a single shared piece of code for
all instances (which requires passing in all kinds of stuff at run time,
which in the first technique would be compile-time known), and some
compilers do some combination of the two.  In any case, the RM has
nothing to say about it.

>...We also have pragma Inline and representation pragmas
> that controls the layout of code and data.

Pragma Inline doesn't *require* anything (it's just a hint).
Representation pragmas and clauses specify data layout, but not code
layout.

>... So why couldn't we also
> have pragma(s) to _hint_ to the compiler that this piece of code is
> only used for initializing constants and is therefore NOT needed in
> the runtime image if the compiler executes it.

Oh, hint?  Like pragma Inline?  Well, maybe.  But why shouldn't the
compiler just do the optimization?  I mean, if I write "2 + 2", I want
the compiler to generate "4" in the machine code.  Likewise, if I have a
function call, and the function returns "2 + 2", and the function is
inlined, I want the compiler to do the same.  I don't think any hint is
needed here.  And anyway, the compiler can always ignore hints.

A hint pragma like pragma Inline makes sense, because inlining is not
always a good idea, so the programmer can tell the compiler when
inlining is worthwhile.  But pragma Inline doesn't make inlining any
easier for the compiler to do, and most compilers have various
restrictions on which pragmas Inline they actually obey.

Some compilers are capable of guessing when inlining is a good idea,
even *without* pragma Inline.  If the guesses are good, then that's
better than using the pragma.

>... And, yes, I realize
> that the analysis of the code may be to expensive and/or the
> tradeoffs that have to be made may cause all this to be unusable.

Compilers already do some of what you want (if you inline).  And adding
hint pragmas won't make them do better.  An open checkbook, on the other
hand, might cause a compiler writer to do certain table lookups (or
whatever it is you wanted) at compile time.  ;-)

So I still say it's an implementation issue, not a language issue.
On the other hand, I suppose it's a language issue in the sense that
some languages make this sort of optimization easier.  But no language
definition can *require* these kinds of optimizations in its Reference
Manual.

- Bob