compiler misses obvious optimization

[timotheecour]

Should I report such optimization issues ?

Im using flags:
ldmd2 -release -inline -O -noboundscheck -L-no_pie
I'm not sure why ldc gives such different results in this benchmark:
writeln(b.point); // prints 1.91474
meaning that 'x+=x.to!double_((1.2).to!int);' is 2X slower than 'x+=x.to!double_(cast(int)1);'
Basically, the compiler should recognize that ((1.2).to!int) is constant and equal to cast(int)1, so there should be no difference.

This is repeatable.

import std.conv;
import std.datetime;
import std.stdio;

static int counter=0;
void main(){
    enum n=100_000_000;
    static int x=0;
    assert((1.2).to!int==cast(int)1);
    ref int funb(ref int x){//TEMP
        x+=x.to!double*((1.2).to!int);
        return x;
    }
    ref int fun(ref int x){
        x+=x.to!double*(cast(int)1);
        return x;
    }
    void fun1(){
        x+=fun(x);
    }
    void fun2(){
        x+=funb(x);
    }
    auto b = comparingBenchmark!(fun2, fun1,n);
    writeln(b.point); // prints 1.91474
    writeln("counter=",counter);
}

[dnadlinger]

The problem seems to be that due to the amount of overflow checking in toImpl!(int, double) (including allocating the exceptions, …) LLVM doesn't inline the function into main, and thus can't optimize away the bounds checks.

Not sure what we can do about this.

[dnadlinger]

Git master now generates the same code for funb and fun.