Clang trunk does not optimize trivial case

[socketpair]

https://godbolt.org/z/65Tza7cdf

#include <stdint.h>

extern uint16_t qwe, asd, zxc, zzz;

int firewall(const uint8_t *restrict data) {
    const uint8_t ip_proto = *data;
    const uint16_t dst_port = *((const uint16_t *)data + 32);

    if (ip_proto == 17 && dst_port == qwe) return 1;

    if (ip_proto == 17 && dst_port == asd) return 1;

    if (ip_proto == 17 && dst_port == zxc) return 1;

    if (ip_proto == 17 && dst_port == zzz) return 1;

    return 0;
}

firewall:                               # @firewall
        mov     dl, byte ptr [rdi]
        movzx   ecx, word ptr [rdi + 64]
        mov     eax, 1
        cmp     dl, 17
        jne     .LBB0_2
        cmp     cx, word ptr [rip + qwe]
        jne     .LBB0_2
.LBB0_7:
        ret
.LBB0_2:
        cmp     dl, 17
        jne     .LBB0_4
        cmp     cx, word ptr [rip + asd]
        je      .LBB0_7
.LBB0_4:
        cmp     dl, 17
        jne     .LBB0_6
        cmp     cx, word ptr [rip + zxc]
        je      .LBB0_7
.LBB0_6:
        cmp     dl, 17
        sete    al
        cmp     cx, word ptr [rip + zzz]
        sete    cl
        and     cl, al
        movzx   eax, cl
        ret

Compiled with -O3 to x86_64.
cmp dl, 17 is repeated for some reason. This is a bug as I think.

[socketpair]

Interesting, extern volatile uint16_t qwe, asd, zxc, zzz; fixes the problem. Or changing uint16_t to uint32_t. What's happening ?

[socketpair]

@EugeneZelenko who should I trigger regarding this task ?

[socketpair]

CLang 12 does not have this problem:
On the same (with 1,2,3,4 instead of external variables) C source Clang 13 gives ASM output like in the first message.

#include <stdint.h>

int firewall(uint8_t *data) {
    uint8_t ip_proto = *data;
    uint16_t dst_port = *(uint16_t *)data;
    if (ip_proto == 17 && dst_port == 1) return 1;
    if (ip_proto == 17 && dst_port == 2) return 1;
    if (ip_proto == 17 && dst_port == 3) return 1;
    if (ip_proto == 17 && dst_port == 4) return 1;
    return 0;
}

firewall:                               # @firewall
        movzx   eax, word ptr [rdi]
        cmp     byte ptr [rdi], 17
        sete    cl
        dec     eax
        cmp     ax, 4
        setb    al
        and     al, cl
        movzx   eax, al
        ret

[socketpair]

Another thing. Even for Clang12 (-O4):

for code

#include <stdint.h>

int firewall(uint8_t *data) {
    uint8_t ip_proto = *data;
    uint16_t dst_port = *(uint16_t *)data;
    if (ip_proto == 17 && dst_port == 11) return 1;
    if (ip_proto == 17 && dst_port == 22) return 1;
    if (ip_proto == 17 && dst_port == 33) return 1;
    if (ip_proto == 17 && dst_port == 44) return 1;
    return 0;
}

It gives:

.LCPI0_0:
        .short  44                              # 0x2c
        .short  33                              # 0x21
        .short  11                              # 0xb
        .short  22                              # 0x16
        .zero   2
        .zero   2
        .zero   2
        .zero   2
firewall:                               # @firewall
        cmp     byte ptr [rdi], 17
        sete    al
        vpbroadcastw    xmm0, word ptr [rdi]
        vpcmpeqw        xmm0, xmm0, xmmword ptr [rip + .LCPI0_0]
        vpmovsxwd       xmm0, xmm0
        vmovmskps       ecx, xmm0
        test    cl, cl
        setne   cl
        and     cl, al
        movzx   eax, cl
        ret

But if I remove comparison with 17:

#include <stdint.h>

int firewall(uint8_t *data) {
    uint8_t ip_proto = *data;
    uint16_t dst_port = *(uint16_t *)data;
    if (dst_port == 11) return 1;
    if (dst_port == 22) return 1;
    if (dst_port == 33) return 1;
    if (dst_port == 44) return 1;
    return 0;
}

it gives beautiful ASM code:

firewall:                               # @firewall
        movzx   ecx, word ptr [rdi]
        cmp     rcx, 44
        ja      .LBB0_2
        mov     eax, 1
        movabs  rdx, 17600780175360
        bt      rdx, rcx
        jae     .LBB0_2
        ret
.LBB0_2:
        xor     eax, eax
        ret

So, WHAT'S happening ? gcc even ancient versions does not have such problems and generate good code.

[nickdesaulniers]

CLang 12 does not have this problem:

There's a bunch of conflicting test cases here, but the original reported issue doesn't look like a regression to me.
https://godbolt.org/z/f6K78Ex8h
Test other versions of clang, too.

cc @zmodem

[socketpair]

@nickdesaulniers What about this: https://godbolt.org/z/h6zbWvr6n ?

[nickdesaulniers]

Yeah, that's a more demonstrative-of-regression test case. Seeing the repeated comparisons of an unchanged register against a constant is disappointing. Looks like a critical edge we could have split perhaps; the IR looks nice, so it's probably isel.

Bisecting LLVM converged on:
5c2e50b
cc @aqjune
Reported here, too. Tentatively marking as a regression.

[LebedevRI]

Hm, let me take a look.