Debug info after MIR inlining losses track which variables represent arguments

[tmiasko]

For example:

fn main() {
    println!("{}", f(std::env::args().count(), 1));
}

#[inline]
pub fn f(x: usize, y: usize) -> usize {
    x + y
}

Running rustc -Zinline-mir a.rs -g && gdb ./a currently results in:

(gdb) break a::f
(gdb) run
Breakpoint 1, a::f () at a.rs:7
7	    x + y
(gdb) info args
No arguments.
(gdb) info locals
x = 1
y = 1

It should be more or less as follows:

(gdb) break a::f
(gdb) run
Breakpoint 1, a::f (x=1, y=1) at a.rs:7
7	    x + y
(gdb) info args
x = 1
y = 1
(gdb) info locals
No locals.

@rustbot label +A-mir-opt-inlining +A-debuginfo

[khuey]

I took a look at this and it's non-trivial to fix. The good news is that the LLVM IR looks almost entirely correct to me. The line/scope/etc information looks good. The bad news is that the DILocalVariables that are emitted for the arguments of the inlined function are missing argument indexes, which causes LLVM to emit DW_TAG_variable instead of DW_TAG_formal_parameter, and for these to be interpreted by debuggers as local variables instead of arguments.

Whether a variable has an argument index or not is entirely inferred by the LLVM IR generation step. Only LocalKind::Arg locals are converted to VariableKind::ArgumentVariable, and the argument index is inferred from the Local::index (as index - 1, since index == 0 is reserved for the return value). When a function is inlined its arguments are converted to LocalKind::Temps in the caller. In order to fix this the compiler would need to track which LocalKind::Temps originated in which inline function, at least for the arguments of inline functions. This information doesn't currently survive the MIR inlining pass and there isn't an obvious (to me) place to store it for later use.