wasm: `i8x16.swizzle` with a constant value should be optimized to `i8x16.shuffle`

[valadaptive]

A SIMD variable permute (like i8x16.swizzle) should be optimizable to a constant permute (like i8x16.shuffle) if the input is constant. This type of optimization is already performed for x86 vector operations, but not for WebAssembly vector operations.

This optimization is particularly useful for architecture-generic SIMD, where exposing constant permutes might not be possible depending on the type system.

Take a look at this example code (also on https://godbolt.org/z/6esax48Kr):

#include <wasm_simd128.h>

v128_t reverse(v128_t n) {
    v128_t indices = wasm_i8x16_make(
        15,
        14,
        13,
        12,
        11,
        10,
        9,
        8,
        7,
        6,
        5,
        4,
        3,
        2,
        1,
        0
    );
    return wasm_i8x16_swizzle(n, indices);
}

I would expect this code to be optimized to:

reverse:
        local.get       0
        local.get       0
        i8x16.shuffle   15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
        end_function

But instead, we get:

reverse:
        local.get       0
        v128.const      15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
        i8x16.swizzle
        end_function

[llvmbot]

@llvm/issue-subscribers-backend-webassembly

Author: None (valadaptive)

A SIMD variable permute (like `i8x16.swizzle`) should be optimizable to a constant permute (like `i8x16.shuffle`) if the input is constant. This type of optimization is already performed for x86 vector operations, but not for WebAssembly vector operations.

This optimization is particularly useful for architecture-generic SIMD, where exposing constant permutes might not be possible depending on the type system.

Take a look at this example code (also on https://godbolt.org/z/6esax48Kr):

#include <wasm_simd128.h>

v128_t reverse(v128_t n) {
    v128_t indices = wasm_i8x16_make(
        15,
        14,
        13,
        12,
        11,
        10,
        9,
        8,
        7,
        6,
        5,
        4,
        3,
        2,
        1,
        0
    );
    return wasm_i8x16_swizzle(n, indices);
}

I would expect this code to be optimized to:

reverse:
        local.get       0
        local.get       0
        i8x16.shuffle   15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
        end_function

But instead, we get:

reverse:
        local.get       0
        v128.const      15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
        i8x16.swizzle
        end_function

[badumbatish]

i'll take a look at implementing this

[valadaptive]

@badumbatish I've implemented this in #169110 if you'd like to take a look.

[ppenzin]

At least V8 optimizes swizzles with constant mask to shuffles. On the other hand this would save an extra operation, which is not a bad thing. @yurydelendik do you know if SM also does that?

[valadaptive]

At least V8 optimizes swizzles with constant mask to shuffles. On the other hand this would save an extra operation, which is not a bad thing.

Wasmtime does not perform this optimization. It compiles an i8x16.swizzle to a vpshufb on Intel.

The issue title is also not completely accurate. As I implemented it in my PR, i8x16.swizzle is optimized not to the i8x16.shuffle intrinsic directly, but to shufflevector, which LLVM knows how to optimize further.