Runtime version statement

[Piotr Szturmaj]

The idea is to make versions of code that are environment dependent and 
never change during runtime, _without_ resorting to if statements. This 
statement would be valid only inside function bodies.

Examples of such versions may be:
* supported SIMD CPU extensions MMX, SSE, SSE2, etc.
* AMD vs Intel CPU, to use instructions that are not available on both
* different OS versions (XP/Vista/7, Linux kernel versions)

Why that instead of current if statement?
* some additional speed, avoids multiple checks in frequent operations
* making specific executables (f.i. SSE4 only) by limiting set of 
supported runtime options during compile time

Code example:

void main()
{
     version(rt_SSE4)
     {
         ...
     }
     else version(rt_SSE2)
     {
         ...
     }
     else
     {
         // portable code
     }
}

In this example program checks the supported extensions only once, 
before calling main(). Then it modifies the function code to make it 
execute only versions that match.

Runtime version identifiers may be set inside shared static constructors 
of modules (this implies that rt-version may not be used inside of 
them). SIMD extensions would preferably be set by druntime with help of 
core.cpuid.

Code modification mechanism is up to implementation. One that come to my 
mind is inserting unconditional jumps by the compiler then and fixing 
them up before calling main().

Additional advantage is possibility to generate executables for 
particular environments. This may help reduce execucutable size when 
targeting specific CPU, especially some constrained/embedded system. 
Also many cpuid checks inside druntime may be avoided.

Just thinking loud :)