data copied needlessly

[tspiteri]

For this code, foo() and bar() are functionally the same.

use std::mem;

#[repr(C)]
struct Inner {
    data: [i64; 4],
}

extern "C" {
    fn init(ptr: *mut Inner);
}

pub struct Outer {
    inner: Inner,
}

pub unsafe fn foo() -> Outer {
    let mut outer = mem::uninitialized::<Outer>();
    init(&mut outer.inner);
    outer
}

pub unsafe fn bar() -> Outer {
    let mut inner = mem::uninitialized::<Inner>();
    init(&mut inner);
    Outer { inner }
}

However, the output from cargo rustc --release -- --emit asm shows needless copying for bar().

;snip...
;function foo:
    .cfi_startproc
    pushq   %rbx
.Ltmp0:
    .cfi_def_cfa_offset 16
.Ltmp1:
    .cfi_offset %rbx, -16
    movq    %rdi, %rbx
    callq   init@PLT
    movq    %rbx, %rax
    popq    %rbx
    retq
;snip...
;function bar:
    .cfi_startproc
    pushq   %rbx
.Ltmp2:
    .cfi_def_cfa_offset 16
    subq    $32, %rsp
.Ltmp3:
    .cfi_def_cfa_offset 48
.Ltmp4:
    .cfi_offset %rbx, -16
    movq    %rdi, %rbx
    leaq    (%rsp), %rdi
    callq   init@PLT
    movups  (%rsp), %xmm0
    movups  16(%rsp), %xmm1
    movups  %xmm1, 16(%rbx)
    movups  %xmm0, (%rbx)
    movq    %rbx, %rax
    addq    $32, %rsp
    popq    %rbx
    retq
;snip...

[michaelwoerister]

I think @brson did quite a bit of experimentation with merging functions at the LLVM level, but it turned out to be more complicated than expected.

[tspiteri]

@michaelwoerister: The bug is not that foo and bar are not merged, it is that the code for bar is not as good as the code for foo: foo just calls init with an unchanged %rdi, but bar grows the stack, makes %rdi point to the new stack space, calls init, and then copies the bytes from the stack to the address in the original %rdi. And bar could have just done the exact same thing as foo.

[steveklabnik]

Today, this produces:

playground::foo:
	pushq	%rbx
	movq	%rdi, %rbx
	callq	*init@GOTPCREL(%rip)
	movq	%rbx, %rax
	popq	%rbx
	retq

playground::bar:
	pushq	%rbx
	subq	$32, %rsp
	movq	%rdi, %rbx
	movq	%rsp, %rdi
	callq	*init@GOTPCREL(%rip)
	movups	(%rsp), %xmm0
	movups	16(%rsp), %xmm1
	movups	%xmm1, 16(%rbx)
	movups	%xmm0, (%rbx)
	movq	%rbx, %rax
	addq	$32, %rsp
	popq	%rbx
	retq

However, mem::uninitialized isn't to be used these days. With MaybeUninit, you'd write

pub unsafe fn bar() -> Outer {
    let mut inner = MaybeUninit::uninit();
    
    init(inner.as_mut_ptr());

    Outer { inner: inner.assume_init() }
}

which gives

playground::bar:
	pushq	%rbx
	movq	%rdi, %rbx
	callq	*init@GOTPCREL(%rip)
	movq	%rbx, %rax
	popq	%rbx
	retq

But I dont think you can write foo this way. I am not a MaybeUninit expert though.

[tspiteri]

Making Outer have repr(transparent), I think you can then cast the pointer, so foo would become

#[repr(transparent)]
pub struct Outer {
    inner: Inner,
}

pub unsafe fn foo() -> Outer {
    let mut outer = MaybeUninit::<Outer>::uninit();
    init(outer.as_mut_ptr().cast());
    outer.assume_init()
}

That is the current way to do it as far as I know, at least until &raw mut or something of the sort is stable, maybe making it possible to write init(&raw mut (*outer.as_mut_ptr()).inner).

This makes foo and the updated bar create the same optimal code, which I think fixes this issue.

[tspiteri]

And, in relation to a previous comment in the thread, with the current compiler foo and bar would also actually be merged as they have equivalent LLVM IR.