Suboptimal code generation in 8byte copy loop

[PSeitz]

In this loop the 8 byte copy seems to get converted into a more complicated assembly than necessary, which is quite slow compared to the 16byte version, which is a much simpler version.

https://play.rust-lang.org/?version=nightly&mode=release&edition=2018&gist=21b5eb51917947a25123dfafc9ed7959

pub fn wild_copy_from_src_8(mut source: *const u8, mut dst_ptr: *mut u8, num_items: usize) {
    // Note: if the compiler transforms this into a call to memcpy it'll hurt performance!
    unsafe {
        let dst_ptr_end = dst_ptr.add(num_items);
        while (dst_ptr as usize) < dst_ptr_end as usize {
            core::ptr::copy_nonoverlapping(source, dst_ptr, 8);
            source = source.add(8);
            dst_ptr = dst_ptr.add(8);
        }
    }
}

When the step size is 16bytes, the assembly looks fine

https://play.rust-lang.org/?version=nightly&mode=release&edition=2018&gist=9bb775fedfb94aec47252b943c28a6d6

[leonardo-m]

Could you move the pointer management upstream and let this function take two &[u8; 8]/&mut [u8; 8] as arguments?

[nikic]

I don't see a call to memcpy in your first example?

[PSeitz]

I don't see a call to memcpy in your first example?

true this was a wrong assumption that these instructions are the memcpy inlined, I'll update the message

[PSeitz]

Could you move the pointer management upstream and let this function take two &[u8; 8]/&mut [u8; 8] as arguments?

The generated code looks fine here. (they are not 100% equal though)

With bounds checks
https://play.rust-lang.org/?version=nightly&mode=release&edition=2018&gist=f850dc3f2318071bf36b693b662bbab3

Without bounds checks
https://play.rust-lang.org/?version=nightly&mode=release&edition=2018&gist=571d2d0e87d432bed25973cb10e88e68

[fmease]

Triage: Still reproducible.