Field ordering causes extra memcpy

[jrmuizel]

In the following test case reduced from SmallVec:

use std::mem;

struct SV {
    capacity: usize,
    disc: usize,
    data: [usize; 40],
}

impl SV {
    fn new() -> SV {
        SV { data: unsafe { mem::uninitialized() },
            disc: 0,
            capacity: 0 }
    }
}

pub struct L {
    a: SV,
}

pub struct Allocation<T> {
    f: *mut T,
}

impl<T> Allocation<T> {
    pub fn init(self, value: T) {
        use std::ptr;
        unsafe {
        ptr::write(self.f, value);
        }
    }
}

#[inline(never)]
pub fn foo(a: Allocation<L>) {
    a.init(L {
        a: SV::new(),
    });
}

produces

example::foo:
  sub rsp, 344
  xorps xmm0, xmm0
  movaps xmmword ptr [rsp], xmm0
  mov rsi, rsp
  mov edx, 336
  call memcpy@PLT
  add rsp, 344
  ret

moving capacity to the end of the struct gives:

example::foo:
  mov qword ptr [rdi], 0
  mov qword ptr [rdi + 328], 0
  ret

This is surprising to me.

[jrmuizel]

It looks like I can reproduce the same problem with:

struct SV {
        size_t capacity;
        size_t disc;
        size_t data[40];

        static SV make() {
                SV ret;
                ret.capacity = 0;
                ret.disc = 0;
                return ret;
        }
};

struct L {
        SV a;
};

template<class T>
struct Allocation {
    T *vec;
    void init(T s) {
        *vec = s;
    }
};

void bar(Allocation<L> a, double g) {
        L s = { SV::make() };
        a.init(s);
}

I'll file an llvm bug.

[jrmuizel]

Filed as https://bugs.llvm.org/show_bug.cgi?id=39844

[nikic]

This is the same issue as #56191. I just checked that the patch attached there would also fix this case.

[jrmuizel]

@nikic do you plan on submitting that patch upstream?

[jrmuizel]

This was fixed by #57675