Inconsistent optimization

[npmccallum]

use std::ops::*;

pub struct Number([u64; 4]);

impl Add for Number {
    type Output = Self;

    #[inline]
    fn add(self, other: Self) -> Self::Output {
        let mut accum: Self::Output = unsafe { core::mem::uninitialized() };
        let mut carry = false;

        for i in 0..self.0.len() {
            let x = self.0[i] as u128 + other.0[i] as u128 + carry as u128;
            carry = x > core::u64::MAX as u128;
            accum.0[i] = x as u64;
        }

        accum
    }
}

pub fn add_a(l: Number, r: Number) -> Number {
    l + r
}


pub fn add_b(l: [u64; 4], r: [u64; 4]) -> [u64; 4] {
    let mut accum: [u64; 4] = unsafe { core::mem::uninitialized() };
    let mut carry = false;

    for i in 0..4 {
        let x = l[i] as u128 + r[i] as u128 + carry as u128;
        carry = x > core::u64::MAX as u128;
        accum[i] = x as u64;
    }

    accum
}

impl Sub for Number {
    type Output = Self;

    #[inline]
    fn sub(self, other: Self) -> Self::Output {
        let mut accum: Self::Output = unsafe { core::mem::uninitialized() };
        let mut carry = false;

        for i in 0..self.0.len() {
            let x = self.0[i] as u128 - other.0[i] as u128 - carry as u128;
            carry = x > core::u64::MAX as u128;
            accum.0[i] = x as u64;
        }

        accum
    }
}

pub fn sub_a(l: Number, r: Number) -> Number {
    l - r
}


pub fn sub_b(l: [u64; 4], r: [u64; 4]) -> [u64; 4] {
    let mut accum: [u64; 4] = unsafe { core::mem::uninitialized() };
    let mut carry = false;

    for i in 0..4 {
        let x = l[i] as u128 - r[i] as u128 - carry as u128;
        carry = x > core::u64::MAX as u128;
        accum[i] = x as u64;
    }

    accum
}

https://godbolt.org/z/aqhD1B

The above link demonstrates four functions of the same algorithm. The generated assembly is widely divergent based on context. It would be great if rust could output the same code for all of them. Alternatively, someone could recommend an algorithm that produces consistent output.

[shepmaster]

As a curious passer-by, it would probably be useful for you to describe in prose what the differences are between the variants.

[npmccallum]

add_a() and add_b() both add together two four-word integers and return the result. add_a() inlines an internal function and is highly optimized by the compiler. add_b() implements exactly the same algorithm, but instead of inlining the code is manually copied into the function. This function is not very optimized, even though it is the same algorithm.

sub_a() and sub_b() are similar to the above. sub_b() is less optimized than sub_a() even though they are the same algorithm and only differ by copying the algorithm by hand.

However, another interesting thing is that add_a() and sub_a() both implement the same algorithm, but with subtraction rather than addition. But sub_a() is nowhere near as optimized as add_a(). It isn't obvious why.

I'm also open to other algorithms that consistently produce highly optimized assembly.