On Tuesday, 27 March 2018 at 23:35:44 UTC, kinke wrote:
On Tuesday, 27 March 2018 at 21:52:25 UTC, Rubn wrote:
It happens with LDC too, not sure how it would be able to know
to do any kind of optimization like that unless it was able to
inline every single function called into one function and be
able to do optimize it from there. I don't imagine that'll be
likely though.
It does it in your code sample with `-O`, there's no call to
bar and the foo() by-value arg is memcpy'd to the global.
If you compile everything with LTO, your code and all 3rd-party
libs as well as druntime/Phobos, LLVM is able to optimize the
whole program as if it were inside a single gigantic 'object'
file in LLVM bitcode IR, and is thus indeed theoretically able
to inline *all* functions.
A bit off topic now but anyways:
Well that example I posted didn't do anything, so it would
optimize it out quite easily. The entire function was excluded
essentially. Just adding a few writeln it isn't able to remove
the function entirely anymore and can't optimize it out. Idk if
you want to try some different options but flto didn't do
anything for it.
https://godbolt.org/g/bLdpnm
import std.stdio : writeln;
struct Foo {
ubyte[1024] data;
this(int a)
{
data[0] = cast(ubyte)a;
}
}
void foo(T)(auto ref T t) {
import std.functional: forward;
writeln(gfoo.data[0]);
bar(forward!t);
writeln(gfoo.data[0]);
}
__gshared Foo gfoo;
void bar(T)(auto ref T t) {
import std.algorithm.mutation : move;
writeln(gfoo.data[0]);
move(t, gfoo);
}
void main() {
foo(Foo(10));
}
