Range of index variables forgotten in an `else if`

[kornelski]

LLVM issue: llvm/llvm-project#151078

pub fn choose(v: &[i32], a: usize, b: usize, c: usize, cond1: i32, cond2: i32) -> usize {
    if a >= v.len() || b >= v.len() || c >= v.len() {
        return 0;
    }

    let va = v[a];
    let vb = v[b]; // v[a]

    let res = if va < cond1 {
        a
    } else if vb < cond2 {
        b
    } else {
        c
    };
    assert!(res < v.len());
    res
}

Godbolt link

I expected the assert to be optimized out, because the only possible values are a/b/c which have been checked at the start of the function. However, in this case the bounds check seems to be lost, and the assert stays.

The optimization failure happens when both conditions are met:

• two different slice indices must be used (e.g. v[a] and v[b]). There's no problem when both conditions use the same v[a].
• there must be an else if. There's no problem if there's only if/else even if the conditions uses two different values if va < cond1 || vb < cond2

Does not optimize:

    let res = if va < cond1 {
        a
    } else if vb < cond2 {
        a
    } else {
        b
    };

Does optimize:

    let res = if va < cond1 ||  vb < cond2 {
        a
    } else {
        b
    };

In C va < cond1 || vb < cond2 doens't optimize, but va < cond1 | vb < cond2 does, so it may be related to extra branches.

[scottmcm]

There's so little going on in the rust there that this sounds to me like something that just needs to be reported to LLVM upstream if you want anything to happen. There's not even any library code running for the indexing because that's the built-in slice indexing (https://rust.godbolt.org/z/8jqsProxf), not one of the Index impls. Even before LLVM's optimizer does anything (https://rust.godbolt.org/z/7PvsYsTbG) it's really quite simple -- could probably make an identical example in C++ (using throw instead of panic).