Optimize char_try_from_u32

[digama0]

The optimization was proposed by @falk-hueffner in https://rust-lang.zulipchat.com/#narrow/stream/219381-t-libs/topic/Micro-optimizing.20char.3A.3Afrom_u32/near/272146171, and I simplified it a bit and added an explanation of why the optimization is correct. The generated code is 2 instructions shorter and uses 2 registers instead of 4 on x86.

[rust-highfive]

r? @scottmcm

(rust-highfive has picked a reviewer for you, use r? to override)

[scottmcm]

Hmm, looks like we have all the edges tested in

rust/library/core/tests/char.rs

Lines 13 to 21 in f838a42

	assert_eq!(char::try_from(0_u32), Ok('\0'));
	assert_eq!(char::try_from(0x61_u32), Ok('a'));
	assert_eq!(char::try_from(0xD7FF_u32), Ok('\u{D7FF}'));
	assert!(char::try_from(0xD800_u32).is_err());
	assert!(char::try_from(0xDFFF_u32).is_err());
	assert_eq!(char::try_from(0xE000_u32), Ok('\u{E000}'));
	assert_eq!(char::try_from(0x10FFFF_u32), Ok('\u{10FFFF}'));
	assert!(char::try_from(0x110000_u32).is_err());
	assert!(char::try_from(0xFFFF_FFFF_u32).is_err());

, so this seems good. (I know it's right, from the zulip thread, but since this didn't add any tests I wanted to check.)

@bors r+

(Though I still think it'd be good to teach LLVM about this pattern, so we never need to do it again by hand.)

[bors]

📌 Commit 7c3ebec has been approved by scottmcm

[hkratz]

Testing all possible input values (just for fun):

use std::intrinsics::transmute;

#[inline]
pub const fn char_try_from_u32_old(i: u32) -> Result<char, ()> {
    if (i > char::MAX as u32) || (i >= 0xD800 && i <= 0xDFFF) {
        Err(())
    } else {
        // SAFETY: checked that it's a legal unicode value
        Ok(unsafe { transmute(i) })
    }
}

#[inline]
pub const fn char_try_from_u32_new(i: u32) -> Result<char, ()> {
    if (i ^ 0xD800).wrapping_sub(0x800) >= 0x110000 - 0x800 {
        Err(())
    } else {
        // SAFETY: checked that it's a legal unicode value
        Ok(unsafe { transmute(i) })
    }
}

#[cfg(test)]
mod tests {
    use crate::*;

    #[test]
    fn test_char_try_from_u32() {
        for i in 0..=u32::MAX {
            assert_eq!(char_try_from_u32_new(i), char_try_from_u32_old(i));
        }
    }
}

$ cargo test --release
Compiling chartest v0.1.0 (/Users/hans/dev/spikes/chartest)
Finished release [optimized] target(s) in 0.31s
Running unittests (target/release/deps/chartest-d411d651ea1d838e)

running 1 test
test tests::test_char_try_from_u32 ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 6.37s

[lqd]

Alive2 also approves of the transformation. There was little chance that a superoptimizer would yield an incorrect simplified expression in the first place, but it's still a nice confirmation.