Performance regression between v1.76.0 and v1.77.2 about rust HOT 10 OPEN

/*

```
[package]
name = "perf-regression-debug"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = { version = "0.8.5", features = ["alloc", "small_rng"] }

[[bin]]
name = "main"
path = "main.rs"
```

```
$ RUSTFLAGS="-Copt-level=3" cargo +1.76.0 build --release
$ time ./target/release/main
real    0m4.182s
user    0m4.181s
sys     0m0.000s
```

```
$ RUSTFLAGS="-Copt-level=3" cargo +1.77.2 build --release
$ time ./target/release/main
real    0m7.699s
user    0m7.694s
sys     0m0.004s
```

```
$ RUSTFLAGS="-Copt-level=3" cargo +1.78.0 build --release
$ time ./target/release/main
real    0m7.634s
user    0m7.628s
sys     0m0.005s
```

*/

use core::hint::black_box;
use core::ptr;

use rand::distributions::{Distribution, WeightedIndex};
use rand::{Rng, SeedableRng};

const RAND_VEC_LEN: usize = 10000;
const BENCHMARK_LOOP_ITERATIONS: usize = 250000;

#[inline]
#[no_mangle]
pub fn decode_u32(buf: &[u8; 5]) -> (u32, usize) {
	if buf[0] < 0x80 {
		return (buf[0] as u32, 1);
	}
	if buf[0] < 0xF0 {
		let x = u32::from_le(unsafe {
			ptr::from_ref(buf).cast::<u32>().read_unaligned()
		});
		if buf[0] < 0b11000000 {
			let decoded = (x & 0x3F) | ((x & 0xFF00) >> 2);
			return (decoded, 2);
		}
		if buf[0] < 0b11100000 {
			let decoded = (x & 0x1F) | ((x & 0xFFFF00) >> 3);
			return (decoded, 3);
		}
		let decoded = (x & 0x0F) | ((x & 0xFFFFFF00) >> 4);
		return (decoded, 4);
	}
	let decoded = u32::from_le(unsafe {
		ptr::from_ref(buf)
			.cast::<u8>()
			.add(1)
			.cast::<u32>()
			.read_unaligned()
	});
	(decoded, ((buf[0] & 0x0F) + 2) as usize)
}

#[inline(never)]
#[no_mangle]
pub fn benchmark_decode_u32(bufs: &[[u8; 5]]) {
	for buf in bufs {
		black_box(decode_u32(black_box(buf)));
	}
}

const U32_MASKS: [u32; 5] = [
	u32::MAX >> 25,
	u32::MAX >> 24,
	u32::MAX >> 16,
	u32::MAX >> 8,
	u32::MAX,
];

fn main() {
	let mixed_u32 = WeightedIndex::new(&[15, 60, 15, 5, 5])
		.unwrap()
		.map(|ii| U32_MASKS[ii]);

	let mut rng = rand::rngs::SmallRng::seed_from_u64(0);
	let encoded_values: Vec<[u8; 5]> =
		std::iter::from_fn(|| Some(rng.sample(&mixed_u32)))
			.map(|value| {
				let mut buf = [0u8; 5];
				encode_u32(&mut buf, value);
				buf
			})
			.take(RAND_VEC_LEN)
			.collect();

	for _ii in 0..BENCHMARK_LOOP_ITERATIONS {
		benchmark_decode_u32(&encoded_values);
	}
}

fn encode_u32(buf: &mut [u8; 5], mut x: u32) -> usize {
	if x & 0b01111111 == x {
		buf[0] = x as u8;
		return 1;
	}
	if x < 0x10000000 {
		if x < 0x00004000 {
			x <<= 2;
			buf[0] = 0b10000000 | ((x as u8) >> 2);
			buf[1] = (x >> 8) as u8;
			return 2;
		}
		if x < 0x00200000 {
			x <<= 3;
			buf[0] = 0b11000000 | ((x as u8) >> 3);
			buf[1] = (x >> 8) as u8;
			buf[2] = (x >> 16) as u8;
			return 3;
		}
		x <<= 4;
		buf[0] = 0b11100000 | ((x as u8) >> 4);
		buf[1] = (x >> 8) as u8;
		buf[2] = (x >> 16) as u8;
		buf[3] = (x >> 24) as u8;
		return 4;
	}
	let bytes = x.to_le_bytes();
	buf[0] = 0b11110011;
	buf[1] = bytes[0];
	buf[2] = bytes[1];
	buf[3] = bytes[2];
	buf[4] = bytes[3];
	5
}