Teach LLVM about data ownership

[Aatch]

Functions that take a non-immediate argument by-value are passed that value by-reference. If the argument needs to live in the current function's frame, we copy it to a local stack slot, but otherwise we'll just re-use the storage that is already there.

Unfortunately, LLVM does not understand that the caller cannot see any of the changes that we might make to the value, behind the passed reference. Since passing an argument by-value either a) copies, meaning that the caller already created a temporary slot, or b) moves, meaning that the slot from the caller is dead once the call returns, LLVM could optimise based on this information, we just need to inform it of that fact.

[dotdash]

We emit lifetime end intrinsics in the callee for by-value arguments, so LLVM should actually know that the value is dead. Do you have anything else in mind that we should do?

[Aatch]

@dotdash not that I can think of. If LLVM is still missing some optimisations there, that's a separate issue.

I'll investigate some basic cases, but I can't see what else we could do here.

[DemiMarie]

Maybe implement some optimizations in rustc itself?

Since no other widely-used language has Rust's ownership model, optimizations based on it may be in the purview of rustc, rather than llvm (which must serve multiple frontends).

[cyplo]

Hi ! Is this still an issue ?

[Mark-Simulacrum]

I believe this is no longer an issue on the LLVM side, and while we can certainly do more optimizations in rustc, there is nothing concrete that could be done to fix this, so I'm going to close this.