Infinite recursion optimized away with `opt-level=z`

[ldm0]

I tried this code:

#[derive(Default)]
pub struct Run {
    pub a: bool,
    pub b: bool,
    pub c: Option<String>,
}

impl Run {
    pub fn run(&mut self) {
        if !self.a && !self.b {
            self.run();
        }
    }
}

pub fn foo() -> Run {
    let mut run = Run::default();
    run.a = false;
    run.b = false;
    run.run();
    run
}

I expected to see this happen: foo runs infinitely

Instead, this happened: foo return directly

The opt-level is set to z: https://rust.godbolt.org/z/n1v471j6E

[ldm0]

According to #28728 (comment) and https://www.llvm.org/docs/LangRef.html#llvm-loop-mustprogress-metadata, rustc doesn't emit mustprogress, which means the loop generated by the tail call shouldn't be removed(I guess).

[hkratz]

This was apparently working in 1.58 and regressed in 1.59.

@rustbot label regression-from-stable-to-stable

[ldm0]

Small reproducer: https://github.com/ldm0/rust_test1

$ cargo run --release 
    Finished release [optimized] target(s) in 0.04s
     Running `target/release/rust_test1`
start
done: Run { a: false, b: false, c: None }

[nikic]

From a cursory look, probably due to: https://github.com/llvm/llvm-project/blob/cc871cf6b50f6a76f2083d192e2254a16832224b/llvm/lib/Transforms/Utils/Local.cpp#L2369

[ldm0]

From cargo bisect:

Regression in nightly-2021-09-25

Probably related to #88243

[inquisitivecrystal]

I'm tagging this as P-critical, as discussed in the prioritization working group.

The following reproduction is concerning:

#[derive(Default)]
pub struct Run {
    pub a: Option<String>,
}

impl Run {
    #[inline(never)]
    pub fn run(&mut self) -> ! {
        self.run()
    }
}

pub fn foo() -> Run {
    let mut run = Run::default();
    run.run();
    run
}

fn main() {
    foo();
}

This exits with an illegal hardware instruction, which is not good. Presumably, run() is returning even though it returns !. One of many ways in which this can likely be unsound.