Concatenating arrays

help
12

After checking the compiler output (Godbolt) with --edition=2021 -C opt-level=3, I don't like the iterator based approach anymore:

.LCPI3_0:
        .quad   1
        .quad   0
example::concat_iter:
        push    r14
        push    rbx
        sub     rsp, 104
        lea     r9, [rsp + 88]
        movzx   eax, word ptr [rdx + 8]
        mov     word ptr [rsp + 96], ax
        mov     rax, qword ptr [rdx]
        mov     qword ptr [rsp + 88], rax
        lea     r10, [rsp + 40]
        mov     qword ptr [rsp + 48], 8
        lea     r8, [rsp + 56]
        mov     qword ptr [rsp + 56], rsi
        mov     qword ptr [rsp + 80], 10
        movaps  xmm0, xmmword ptr [rip + .LCPI3_0]
        movaps  xmmword ptr [rsp + 32], xmm0
        movaps  xmmword ptr [rsp + 64], xmm0
        mov     edx, 1
        xor     r11d, r11d
        xor     ebx, ebx
        jmp     .LBB3_1
.LBB3_8:
        lea     rax, [rsi + 1]
        mov     qword ptr [rcx], rax
        add     rsi, r8
.LBB3_9:
        movzx   eax, byte ptr [rsi]
        mov     byte ptr [rsp + rbx + 14], al
        inc     rbx
        cmp     rbx, 18
        je      .LBB3_10
.LBB3_1:
        mov     rcx, r10
        test    rdx, rdx
        cmove   rcx, rdx
        je      .LBB3_4
        mov     rsi, qword ptr [rcx]
        cmp     rsi, 8
        jne     .LBB3_8
        mov     qword ptr [rsp + 32], 0
.LBB3_4:
        cmp     r11, 10
        je      .LBB3_6
        mov     rsi, r11
        inc     r11
        mov     qword ptr [rsp + 72], r11
        add     rsi, r9
        xor     edx, edx
        jmp     .LBB3_9
.LBB3_10:
        mov     eax, dword ptr [rsp + 14]
        mov     ecx, dword ptr [rsp + 17]
        mov     dword ptr [rdi + 3], ecx
        mov     dword ptr [rdi], eax
        mov     rax, qword ptr [rsp + 21]
        movzx   ecx, word ptr [rsp + 29]
        movzx   edx, byte ptr [rsp + 31]
        mov     qword ptr [rdi + 7], rax
        mov     byte ptr [rdi + 17], dl
        mov     word ptr [rdi + 15], cx
        mov     rax, rdi
        add     rsp, 104
        pop     rbx
        pop     r14
        ret
.LBB3_6:
        lea     rdi, [rip + .L__unnamed_1]
        lea     rdx, [rip + .L__unnamed_2]
        mov     esi, 43
        call    qword ptr [rip + core::panicking::panic@GOTPCREL]
        ud2
        mov     r14, rax
        lea     rsi, [rsp + 14]
        mov     rdi, rbx
        call    core::ptr::drop_in_place<core::array::Guard<u8,18_usize>>
        lea     rdi, [rsp + 32]
        call    core::ptr::drop_in_place<core::iter::adapters::chain::Chain<core::array::iter::IntoIter<u8,8_usize>,core::array::iter::IntoIter<u8,10_usize>>>
        mov     rdi, r14
        call    _Unwind_Resume@PLT
        ud2
        call    qword ptr [rip + core::panicking::panic_no_unwind@GOTPCREL]
        ud2

Compare with the short output of the variant using copy_from_slice:

example::concat_copy:
        mov     rax, rdi
        mov     qword ptr [rdi], rsi
        mov     rcx, qword ptr [rdx]
        mov     qword ptr [rdi + 8], rcx
        movzx   ecx, word ptr [rdx + 8]
        mov     word ptr [rdi + 16], cx
        ret

As I don't need to be generic in my case, I think I'll just stick to copy_from_slice and write a helper function for my particular use case.