Compiler Explorer

Source code

// SPDX-License-Identifier: MIT

#[unsafe(no_mangle)]
pub fn get_range_reference(v: u128, len: i32, start: i32) -> u64 {
    return ((v >> start) as u64) & if len == 64 { u64::MAX } else { (((1u64).wrapping_shl(len as u32).wrapping_sub(1)) as u64) };
}

#[unsafe(naked)]
#[unsafe(no_mangle)]
extern "sysv64" fn get_range_opt(v: u128, len: i32, start: i32) -> u64 {
    core::arch::naked_asm!( 
        "test cl, 64",
        "cmovnz rdi, rsi",
        "shrd rdi, rsi, cl",
        "bzhi rax, rdi, rdx",
        "ret"
    )
}

/// NB: Everything past here is vibe coded

/// A simple pseudo-random number generator using the xoroshiro128+ algorithm.
struct SimplePrng {
    s0: u64,
    s1: u64,
}

impl SimplePrng {
    /// Creates a new PRNG with a given 128-bit seed.
    fn new(seed: u128) -> Self {
        // A non-zero seed is required.
        let seed = if seed == 0 { u128::MAX } else { seed };
        Self {
            s0: (seed >> 64) as u64,
            s1: seed as u64,
        }
    }

/// Generates the next 128-bit pseudo-random number.
    fn next_u128(&mut self) -> u128 {
        // Call the 64-bit generator twice to produce a 128-bit number.
        let hi = self.next_u64();
        let lo = self.next_u64();
        ((hi as u128) << 64) | (lo as u128)
    }
    
    /// Generates a pseudo-random i32 within a specified range (inclusive).
    /// Note: This uses the modulo operator, which introduces a slight bias,
    /// but is simple and sufficient for testing purposes.
    fn gen_range(&mut self, start_inclusive: i32, end_inclusive: i32) -> i32 {
        let range = (end_inclusive as u64) - (start_inclusive as u64) + 1;
        if range == 0 {
            return start_inclusive;
        }
        // Use the lower 64 bits of a random u128 for simplicity.
        let random_u64 = self.next_u128() as u64;
        start_inclusive + (random_u64 % range) as i32
    }
    
    // Private helper for the 64-bit state transition (xoroshiro128+).
    fn next_u64(&mut self) -> u64 {
        let s0 = self.s0;
        let mut s1 = self.s1;
        let result = s0.wrapping_add(s1);

s1 ^= s0;
        self.s0 = s0.rotate_left(24) ^ s1 ^ (s1 << 16);
        self.s1 = s1.rotate_left(37);

result
    }
}

fn main() {
    // Initialize the PRNG with a fixed seed for reproducible test runs.
    let mut prng = SimplePrng::new(0x853409618721e25501827a73819301ab);
    const ITERATIONS: u32 = 5_000_000;

println!("Running {ITERATIONS} pseudo-random tests...");

for i in 0..ITERATIONS {
        // 1. Generate a valid length: 0 <= len <= 64
        let len: i32 = prng.gen_range(0, 64);

// 2. Generate a valid start position: 0 <= start <= 128 - len
        let start: i32 = prng.gen_range(0, 127 - len);

// 3. Generate a random value
        let v: u128 = prng.next_u128();

// 4. Get results from both functions
        let reference_result = get_range_reference(v, len, start);
        let opt_result = get_range_opt(v, len, start);

// 5. Check that they are the same
        assert_eq!(
            reference_result,
            opt_result,
            "\n\nMismatch on iteration {i}!\n\
             Inputs: v=0x{v:032x}, len={len}, start={start}\n\
             Reference output: 0x{reference_result:016x}\n\
             Optimized output: 0x{opt_result:016x}\n"
        );
    }

println!("✅ Success! All {ITERATIONS} tests passed.");
}