Bad codegen with multiple paths for small struct return

[aengelke]

Clang generates a single return, SROA inserts code to merge struct fields there, but the tail is never duplicated causing suboptimal codegen. (For a slightly simpler case without the ternary at the return, InstCombine will optimize to "good" code on x86-64, but not on AArch64.)

struct X2 { char a, b; };
X2 s(unsigned num) {
    if (num < 3) [[likely]] {
        static constexpr X2 data[] = {{1, 1}, {2, 2}, {3, 3}};
        return data[num];
    }
    return num == 12 ? X2{8, 7} : X2{0, 0};
}

Clang:

s(unsigned int):
        cmp     edi, 2
        ja      .LBB0_2
        mov     ecx, edi
        lea     rdx, [rip + s(unsigned int)::data]
        movzx   eax, byte ptr [rdx + 2*rcx]
        movzx   ecx, byte ptr [rdx + 2*rcx + 1]
        shl     ecx, 8
        movzx   eax, ax
        or      eax, ecx
        ret
.LBB0_2:
        xor     edx, edx
        xor     eax, eax
        cmp     edi, 12
        sete    al
        mov     ecx, 1792
        cmovne  ecx, edx
        shl     eax, 3
        movzx   eax, ax
        or      eax, ecx
        ret

GCC:

s(unsigned int):
        cmp     edi, 2
        ja      .L2
        mov     edi, edi
        movzx   eax, WORD PTR s(unsigned int)::data[rdi+rdi]
        ret
.L2:
        xor     eax, eax
        mov     edx, 1800
        cmp     edi, 12
        cmove   eax, edx
        ret

https://godbolt.org/z/a3Wb38Taf

[aengelke]

On AArch64, this can lead to completely useless code that does nothing:

  46f368: 12103d28      and     w8, w9, #0xffff0000
  46f36c: 2a0903ea      mov     w10, w9
  46f370: 12181d29      and     w9, w9, #0xff00
  46f374: 2a080128      orr     w8, w9, w8
  46f378: 12001d49      and     w9, w10, #0xff
  46f37c: 2a090100      orr     w0, w8, w9
  46f380: d65f03c0      ret

[antoniofrighetto]

It indeed looks like we miss duplicating the exit here: https://alive2.llvm.org/ce/z/ycR6W9. @nikic Should we try handling duplicateRet in SimplifyCFG (if we are somehow not doing this already)?

[nikic]

@antoniofrighetto I don't think we want to do this in SimplifyCFG. This goes against the direction middle-end transforms usually go. The expectation is that tail duplication i the backend handles it.

What is relevant in this case, is that folding the or into the phis results in significant simplification -- in a fairly trivial way over the selects, and in a fairly non-trivial way (via AggressiveInstCombine) for the other branch.

Annoyingly, even the select simplification requires InstCombine and not InstSimplify, so straightforward attempts to push up the operation will fail. I guess we could further extend the special case list in

llvm-project/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

Line 1883 in b581f9d

auto WillFold = [&]() {

to cover this...