Mark by-value parameters that are passed on the stack as nocapture

[dotdash]

The by-value argument is a copy that is only valid for the duration of
the function call, therefore keeping any pointer to it that outlives the
call is illegal.

[brson]

@dotdash thanks for the explanation. do you have an example where this leads to TCO?

[dotdash]

Generic example:

#[inline(never)]fnhuge_fn(x:&str,d:int){println!("{}: {}", x, d);}fnrec(d:int){huge_fn("Test", d);rec(d+1);}pubfnmain(){rec(0);}

Since &str is not an actual pointer but a struct and doesn't fit into a single register, it is passed as a by-value argument on the stack. Without the nocapture attribute, TCO can't happen.

In libstd, TCO is made possible for char::decompose_canonical and char::decompose_compatible (but nothing else).

In can check larger libs like libsyntax and librustc later today.

[dotdash]

Further checking tells that there may be more TCO changes in libstd than just those two. I had looked for TAILCALL in the assembly diff, but that's only for recursive tail calls I think.

A different example that doesn't involve recursion is this:

#[crate_type="lib"];#[inline(never)]pubfnfunc(foo:Option<int>){println!("{:?}", foo);}#[inline(never)]pubfnfunc2(foo:int){println!("{:?}", foo);}pubfnbar(foo_opt:Option<int>){func(foo_opt);match foo_opt {Some(foo) => func2(foo),
_ => {}}}

With the change, the call to func2 gets lowered to a jmp.

I also found this change in the IR for librustc:

Old:

%283 = bitcast [4 x i64]* %282toi8*%284 = loadi8*%283, align8, !range!1switchi8%284, label%match_else42 [
;...%285 = bitcast [4 x i64]* %282to { i8, %"struct.syntax::ast::DefId[#9]", i8, { i64, void (i8*)*, i8*, i8*, %"struct.syntax::ast::Method[#9]" }* }*
;...%impl_did.sroa.0.0.idx = getelementptrinbounds { i8, %"struct.syntax::ast::DefId[#9]", i8, { i64, void (i8*)*, i8*, i8*, %"struct.syntax::ast::Method[#9]" }* }* %285, i640, i321, i320%impl_did.sroa.0.0.copyload = loadi32*%impl_did.sroa.0.0.idx, align4

New:

%283 = getelementptrinbounds [4 x i64]* %282, i640, i640%284 = loadi64*%283, align8%285 = trunci64%284toi8%286 = lshri64%284, 32%287 = trunci64%286toi32switchi8%285, label%match_else42 [

LLVM could deduce that the value doesn't change between the two loads and combine them to a single load instead (+ shifting). Unfortunately, I don't have a simple rust example that exposes this.

[brson]

@dotdash Thanks for the details.

@nikomatsakis Can you review?