ABI: Ownership transfer through pointer involves unnecessary copies

[CryZe]

Let's say we have a reasonably large struct that doesn't get passed through registers:

pub struct Color {
    red: f64,
    green: f64,
    blue: f64,
    alpha: f64,
}

Then we have some method on it that requires ownership transfer:

impl Color {
    #[inline(never)]
    fn to_rgba8(self) -> [u8; 4] {
        [
            (255.0 * self.red) as u8,
            (255.0 * self.green) as u8,
            (255.0 * self.blue) as u8,
            (255.0 * self.alpha) as u8,
        ]
    }
}

And then we have some sort of function that just passes ownership through to that method:

pub fn convert(color: Color) -> [u8; 4] {
    color.to_rgba8()
}

In C you would expect a "copy" of the struct to get passed into the function, as we pass the struct by value. And that's exactly what Rust does here as well. It copies the entire struct onto the stack and then passes a pointer to the copy into the function:

example::convert:
        sub     rsp, 40
        movups  xmm0, xmmword ptr [rdi]
        movups  xmm1, xmmword ptr [rdi + 16]
        movaps  xmmword ptr [rsp + 16], xmm1
        movaps  xmmword ptr [rsp], xmm0
        mov     rdi, rsp
        call    example::Color::to_rgba8
        add     rsp, 40
        ret

However Rust has a unique notion of ownership, where we know that color can't be used anymore after calling the method. So no actual copy should ever be necessary for a non-Copy type. Though technically even on a Copy type no such additional copy should be necessary if it's the last use.

https://rust.godbolt.org/z/135z7aK3K

[jonas-schievink]

MIR generated for convert:

fn convert(_1: Color) -> [u8; 4] {
    debug color => _1;                   // in scope 0 at /app/example.rs:20:16: 20:21
    let mut _0: [u8; 4];                 // return place in scope 0 at /app/example.rs:20:33: 20:40
    let mut _2: Color;                   // in scope 0 at /app/example.rs:21:5: 21:10

    bb0: {
        StorageLive(_2);                 // scope 0 at /app/example.rs:21:5: 21:10
        _2 = move _1;                    // scope 0 at /app/example.rs:21:5: 21:10
        _0 = Color::to_rgba8(move _2) -> bb1; // scope 0 at /app/example.rs:21:5: 21:21
    }

    bb1: {
        StorageDead(_2);                 // scope 0 at /app/example.rs:21:20: 21:21
        return;                          // scope 0 at /app/example.rs:22:2: 22:2
    }
}

Seems like this would be easy to handle with intra-block copy propagation, or the existing dest_prop pass (though it doesn't seem to handle this case just yet).