[x86-64 BMI2] Missed canonicalization on ~blsmsk

[Validark]

This code:

export fn foo(a: u64) u64 {
    return ~blsmsk(a);
}

fn blsmsk(a: u64) u64 {
    return (a ^ (a - 1));
}

Gives this emit:

foo:
        mov     rax, rdi
        neg     rax
        xor     rax, rdi
        ret

With inline assembly, we can force the compiler to do the thing we want:

export fn bar(a: u64) u64 {
    return ~blsmsk_asm(a);
}

inline fn blsmsk_asm(src: u64) u64 {
    return asm ("blsmsk %[src], %[ret]"
        : [ret] "=r" (-> u64),
        : [src] "r" (src),
    );
}

bar:
        blsmsk  rax, rdi
        not     rax
        ret

In my real code, I was doing a bitwise AND on ~blsmsk(a). Meaning the not can be folded into an ANDN instruction.

export fn foo(a: u64, b: u64) u64 {
    return ~blsmsk(a) & b;
}

foo:
        mov     rax, rdi
        neg     rax
        xor     rax, rdi
        and     rax, rsi
        ret

Again, with inline assembly, we can get:

bar:
        blsmsk  rax, rdi
        andn    rax, rax, rsi
        ret

Godbolt link

[llvmbot]

@llvm/issue-subscribers-backend-x86

Author: Niles Salter (Validark)

This code:

export fn foo(a: u64) u64 {
    return ~blsmsk(a);
}

fn blsmsk(a: u64) u64 {
    return (a ^ (a - 1));
}

Gives this emit:

foo:
        mov     rax, rdi
        neg     rax
        xor     rax, rdi
        ret

With inline assembly, we can force the compiler to do the thing we want:

export fn bar(a: u64) u64 {
    return ~blsmsk_asm(a);
}

inline fn blsmsk_asm(src: u64) u64 {
    return asm ("blsmsk %[src], %[ret]"
        : [ret] "=r" (-> u64),
        : [src] "r" (src),
    );
}

bar:
        blsmsk  rax, rdi
        not     rax
        ret

In my real code, I was doing a bitwise AND on ~blsmsk(a). Meaning the not can be folded into an ANDN instruction.

export fn foo(a: u64, b: u64) u64 {
    return ~blsmsk(a) & b;
}

foo:
        mov     rax, rdi
        neg     rax
        xor     rax, rdi
        and     rax, rsi
        ret

Again, with inline assembly, we can get:

bar:
        blsmsk  rax, rdi
        andn    rax, rax, rsi
        ret

Godbolt link

[RKSimon]

uint64_t blsmsk(uint64_t a) {
    return (a ^ (a - 1));
}
uint64_t foo(uint64_t a)  {
    return ~blsmsk(a);
}
uint64_t bar(uint64_t a, uint64_t b)  {
    return b & ~blsmsk(a);
}

emits:

define i64 @blsmsk(i64 noundef %a) {
entry:
  %sub = add i64 %a, -1
  %xor = xor i64 %sub, %a
  ret i64 %xor
}

define i64 @foo(i64 noundef %a) {
entry:
  %0 = sub i64 0, %a
  %not = xor i64 %a, %0
  ret i64 %not
}

define i64 @bar(i64 noundef %a, i64 noundef %b) {
entry:
  %0 = sub i64 0, %a
  %not = xor i64 %a, %0
  %and = and i64 %b, %not
  ret i64 %and
}

Fixing the foo codegen might not be worth it (although blsmsk is more likely to load-fold than neg) - but bar is definitely a missed opportunity.