Certain simd math operations imply `fast-math`, but operation naming does not make it apparent

[calebzulawski]

In the following, is_infinite is optimized to always return zero, but it should instead perform fabs and cmp:

#![feature(platform_intrinsics, repr_simd)]

extern "platform-intrinsic" {
    fn simd_fabs<T>(x: T) -> T;
    fn simd_eq<T, U>(x: T, y: T) -> U;
}

#[repr(simd)]
pub struct V([f32; 4]);

#[repr(simd)]
pub struct M([i32; 4]);

pub fn is_infinite(v: V) -> M {
    unsafe {
        simd_eq(simd_fabs(v), V([f32::INFINITY; 4]))
    }
}

It works correctly in debug, and fails in release.

Playground link: https://play.rust-lang.org/?version=nightly&mode=release&edition=2018&gist=49b790d5e14139e6bea9e57b0ae381d5

The problem is related to simd_fabs, because in stdsimd we are currently using simd_xor instead of simd_fabs and that optimizes correctly.

Meta

rustc --version --verbose:

rustc 1.53.0-nightly (b0c818c5e 2021-04-16)
binary: rustc
commit-hash: b0c818c5e0fa37251d9fda2f656bf1041a2e1e1d
commit-date: 2021-04-16
host: x86_64-unknown-linux-gnu
release: 1.53.0-nightly
LLVM version: 12.0.0

[calebzulawski]

I just tried this with nightly-2021-02-11 and it optimizes correctly, so I think this is an LLVM 12 regression.

[nikic]

The optimization is correct from LLVM's perspective, because rustc is emitting fast flags on the fabs: https://rust.godbolt.org/z/17h48dWha

This is done here:

rust/compiler/rustc_codegen_llvm/src/intrinsic.rs

Line 1078 in 7af1f55

unsafe { llvm::LLVMRustSetHasUnsafeAlgebra(c) };

The change was made in #50521. This is almost certainly wrong under rust semantics. Based on the comments there, possibly the intention was to set just afn and not the full set of fast flags.

[calebzulawski]

Hmm, the LLVM docs don't seem to indicate fast (or ninf in this case) does anything for fabs--this probably changed in LLVM 12, but I agree that it's correct.

[nagisa]

The documentation for fast-math says:

fast: This flag implies all of the others.

And amongst the implied ones:

ninf: No Infs - Allow optimizations to assume the arguments and result are not +/-Inf. If an argument is +/-Inf, or the result would be +/-Inf, it produces a poison value instead.

In this particular case the property that's exploited is that the result is assumed to not be +inf and the comparison is optimized out. Once that's done the fabs is also just dead code and is removed.