Repository: rust
Issue: Improve `core::intrinsics::black_box` output.
Labels: C-enhancement,A-codegen,T-compiler,A-intrinsics

On discord, the user kangalioo (unsure of github name) shared a custom version of the `black_box` (https://github.com/rust-lang/rust/issues/64102) function they're using to improve the asm output of black_box, and reduce the overhead of its use. It does this by passing small things in registers instead of by pointers.

```rs
// Warning, not sound. Do not use.
pub fn black_box<T>(x: T) -> T {
    use std::mem::{transmute_copy as t, forget as f};
    use std::arch::asm;
    unsafe { match std::mem::size_of::<T>() {
        1 => { let mut y: u8 = t(&x); f(x); asm!("/*{y}*/", y = inout(reg_byte) y, options(nostack)); t(&y) }
        2 => { let mut y: u16 = t(&x); f(x); asm!("/*{y}*/", y = inout(reg) y, options(nostack)); t(&y) }
        4 => { let mut y: u32 = t(&x); f(x); asm!("/*{y}*/", y = inout(reg) y, options(nostack)); t(&y) }
        8 => { let mut y: u64 = t(&x); f(x); asm!("/*{y}*/", y = inout(reg) y, options(nostack)); t(&y) }
        16 => { let [mut y, mut z]: [u64; 2] = t(&x); f(x); asm!("/*{y}{z}*/", y = inout(reg) y, z = inout(reg) z, options(nostack)); t(&[y, z]) }
        _ => { x },
    } }
}
pub fn example() {
    black_box(black_box(2) + black_box(3));
    extern "C" { fn print(_: &str); }
    unsafe { print(black_box("hello world :)")); }
}
```

Which produces the following output:

```nasm
example::example:
    mov     eax, 2
    mov     ecx, 3
    add     ecx, eax
    lea     rdi, [rip + .L__unnamed_1]
    mov     esi, 14
    jmp     qword ptr [rip + print@GOTPCREL]
.L__unnamed_1:
    .ascii  "hello world :)"
```

In comparison, the current black box `black_box` spills the output in basically all cases. The equivalent output with the current `black_box` is as follows (Godbolt for all this is available here https://godbolt.org/z/a7evcEP6x):

```nasm
example::example:
    sub     rsp, 24
    mov     dword ptr [rsp + 8], 2
    lea     rax, [rsp + 8]
    mov     ecx, dword ptr [rsp + 8]
    mov     dword ptr [rsp + 8], 3
    add     ecx, dword ptr [rsp + 8]
    mov     dword ptr [rsp + 8], ecx
    lea     rcx, [rip + .L__unnamed_1]
    mov     qword ptr [rsp + 8], rcx
    mov     qword ptr [rsp + 16], 14
    mov     rdi, qword ptr [rsp + 8]
    mov     rsi, qword ptr [rsp + 16]
    call    qword ptr [rip + print@GOTPCREL]
    add     rsp, 24
    ret

.L__unnamed_1:
    .ascii  "hello world :)"
```

I believe this is basically because we just lower the intrinsic as passing a pointer to the value into an inline asm block, which forces the spilling.

I don't believe this can be fixed by libs changes, as we are just calling into an intrinsic and need to remain that way to support all targets (and cases like miri). Additionally, the version posted in discord has a soundness hole, and is considered UB if `T` contains padding bytes (and can't be fixed at the moment as passing `MaybeUninit` via registers isn't currently possible).

However, because we just pass the argument to an intrinsic, it seems likely that the compiler can lower it in a more optimal way, which seems to be a less error-prone way of handling this anyway.

Improving this output seems beneficial, since the whole point of this intrinsic is to have as close to 0 cost as possible while still providing an optimization barrier. I think the basic idea behind the `black_box` provided above is a reasonable starting point of what would be good, but it's obviously not a requirement that it's lowered in that manner.