Inefficient compilation of ? operator

[stepancheg]

Consider these two functions:

pub fn bar(x: Result<String, String>) -> Result<String, String> {
    Ok(x?)
}

pub fn baz(x: Result<String, String>) -> Result<String, String> {
    x
}

Ideally the compiler should generate identical machine code. But it does not.

Compiler explorer

Because of this issue, ? operator is not as convenient to use in high performance parts of code. E. g.

fn f() -> Result<(), MyError> {
  f1()?;
  f2()?;
  Ok(())
}

has to be written for performance as

fn f() -> Result<(), MyError> {
  f1()?;
  f2()
}

[PatchMixolydic]

Manually desugaring the ? operator seems to produce the same assembly (Compiler Explorer):

use std::ops::{ControlFlow, FromResidual, Try};

pub unsafe fn qux(x: Result<String, String>) -> Result<String, String> {
    match x.branch() {
        ControlFlow::Continue(res) => Result::from_output(res),
        ControlFlow::Break(err) => return Result::from_residual(err),
    }
}

example::qux:
        mov     rax, rdi
        xor     ecx, ecx
        cmp     qword ptr [rsi], 1
        sete    cl
        mov     rdx, qword ptr [rsi + 24]
        mov     qword ptr [rdi + 24], rdx
        movups  xmm0, xmmword ptr [rsi + 8]
        movups  xmmword ptr [rdi + 8], xmm0
        mov     qword ptr [rdi], rcx
        ret

; Provided for comparison; note that defining `qux` and `bar` at the
; same time will cause `qux` to be optimized out with `-C opt-level=3`
example::bar:
        mov     rax, rdi
        xor     ecx, ecx
        cmp     qword ptr [rsi], 1
        sete    cl
        mov     rdx, qword ptr [rsi + 24]
        mov     qword ptr [rdi + 24], rdx
        movups  xmm0, xmmword ptr [rsi + 8]
        movups  xmmword ptr [rdi + 8], xmm0
        mov     qword ptr [rdi], rcx
        ret

Replacing Result::from_output(res) with Ok(res) and Result::from_residual(err) with Err(unsafe { err.unwrap_err_unchecked() }) doesn't seem to have any effect on the generated code, so this might be caused by the call to x.branch() or by the match expression.

[SkiFire13]

match seems to have an negative effect, but is still better than the ? version

pub unsafe fn qux(x: Result<String, String>) -> Result<String, String> {
    match x {
        Ok(s) => Ok(s),
        Err(s) => Err(s),
    }
}

example::qux:
        mov     rax, rdi
        mov     rcx, qword ptr [rsi]
        mov     rdx, qword ptr [rsi + 24]
        mov     qword ptr [rdi + 24], rdx
        movups  xmm0, xmmword ptr [rsi + 8]
        movups  xmmword ptr [rdi + 8], xmm0
        mov     qword ptr [rdi], rcx
        ret

However the difference is only on how the bytes are copied: in baz there are two copies of length 16 bytes while in qux there's a copy of 8 bytes, then 16 bytes and then 8 bytes. Maybe this is due to the discriminant being considered separated from the String? At least in this case the conditional is optimized away.

[stepancheg]

Another much simpler example, and I guess the reason is the same:

pub fn baz(o: Option<u32>) -> Option<u32> {
    o.map(|f| f)
}

example::bar:
        mov     edx, esi
        xor     eax, eax
        test    edi, edi
        setne   al
        ret

Here is does avoidable test/setne.

Compiler explorer

[Amanieu]

This seems to be fixed on the latest nightly.