Compile-time computations

[Marc Glisse <marc dot glisse+gcc at normalesup dot org>]

Hello,

for builtin types, the compiler can optimize some functions when it 
detects that an argument is a compile-time constant. For instance it can 
turn a multiplication (or division) of an unsigned int by a power of 2 
into a shift.

If I create my own type (I am doing C++, but it would be similar in C), I 
lose all these optimizations.

Gcc provides __builtin_constant_p which in many cases (assuming at least 
-O1) can detect compile-time constants. Knowing it, I would like to 
perform some computation at compile-time that will make the evaluation 
fast. For instance, if I detect a multiplication by a power of 2, I need 
to compute the log2 of this number to pass it as an argument to shift. And 
I really want the computation of the log2 to happen at compile-time, 
otherwise this branch becomes slower than the regular multiplication. I 
can compute the log2 and ask gcc whether the result is a compile-time 
constant, so I am safe.

But in practice, the operations that carry constants are fairly limited. 
In order to compile the log2, I have to use a switch statement with a list 
of all possible powers of 2, because a for/while loop gives a result that 
is not considered a constant (for log2 in particular, probably as a result 
of the gmp-mpfr integration, (int)(log2(5)) is considered a constant by 
the latest gcc version, but that is really a very special case). If I do 
modular arithmetic and want to compute the inverse of a number to replace 
a division by a multiplication, it essentially means computing a gcd and I 
can't do it without a loop or recursion (or do I really have to unroll it 
by hand to a large depth?).

Is there a way to tell gcc that it would be _really_ nice if it could 
evaluate some function at compile-time, even if that means, as in the case 
of a log2 computation, going through a loop up to 64 times?

Note that I could have a type static_int<n> and use C++ template 
meta-programming to perform all the compile-time computations I want (log2 
and gcd are trivial, sqrt is already a bit more fun), but it means I have 
to write n/static_int<2>() instead of n/2 to halve a number, and I want to 
avoid that. Besides, there are other overloading issues with this 
technique.

Thank you for any hint,

--
Marc Glisse