[Bug tree-optimization/114966] New: fails to optimize avx2 in-register permute written with std::experimental::simd

["lee.imple at gmail dot com" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114966

            Bug ID: 114966
           Summary: fails to optimize avx2 in-register permute written
                    with std::experimental::simd
           Product: gcc
           Version: 14.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: tree-optimization
          Assignee: unassigned at gcc dot gnu.org
          Reporter: lee.imple at gmail dot com
  Target Milestone: ---

This is actually another attempt to permute a simd register with
std::experimental::simd, like PR114908, but written differently.

Following is the same function written in both std::experimental::simd and GNU
vector extension versions (available online at https://godbolt.org/z/n3WvqcePo
).
The purpose is to permute the register from [w, x, y, z] into [0, w, x, y].

```c++
#include <experimental/simd>
#include <cstdint>
namespace stdx = std::experimental;

using data_t = std::uint64_t;
constexpr std::size_t data_size = 4;

template <std::size_t N>
using simd_of = std::experimental::simd<data_t,
std::experimental::simd_abi::deduce_t<data_t, N>>;
using simd_t = simd_of<data_size>;

// stdx version
simd_t permute_simd(simd_t data) {
    return simd_t([=](auto i) -> data_t {
        constexpr size_t index = i - 1;
        if constexpr (index < data_size) {
            return data[index];
        } else {
            return 0;
        }
    });
}



typedef data_t vector_t [[gnu::vector_size(data_size * sizeof(data_t))]];

// gnu vector extension version
vector_t permute_vector(vector_t data) {
    return __builtin_shufflevector(data, vector_t{0}, 4, 0, 1, 2);
}
```

The code is compiled with the options `-O3 -march=x86-64-v3 -std=c++20`.
Although they should have the same functionality, generated assembly (by GCC)
is so different.

```asm
permute_simd(std::experimental::parallelism_v2::simd<unsigned long,
std::experimental::parallelism_v2::simd_abi::_VecBuiltin<32> >):
  vmovq %xmm0, %rax
  vpsrldq $8, %xmm0, %xmm1
  vextracti128 $0x1, %ymm0, %xmm0
  vpunpcklqdq %xmm0, %xmm1, %xmm1
  vpxor %xmm0, %xmm0, %xmm0
  vpinsrq $1, %rax, %xmm0, %xmm0
  vinserti128 $0x1, %xmm1, %ymm0, %ymm0
  ret
permute_vector(unsigned long __vector(4)):
  vpxor %xmm1, %xmm1, %xmm1
  vpermq $144, %ymm0, %ymm0
  vpblendd $3, %ymm1, %ymm0, %ymm0
  ret
```

However, Clang can optimize `permute_simd` into the same assembly as
`permute_vector`, so I think, instead of a bug in the std::experimental::simd,
it is a missed optimization in GCC.

```asm
permute_simd(std::experimental::parallelism_v2::simd<unsigned long,
std::experimental::parallelism_v2::simd_abi::_VecBuiltin<32> >): #
@permute_simd(std::experimental::parallelism_v2::simd<unsigned long,
std::experimental::parallelism_v2::simd_abi::_VecBuiltin<32> >)
        vpermpd $144, %ymm0, %ymm0              # ymm0 = ymm0[0,0,1,2]
        vxorps  %xmm1, %xmm1, %xmm1
        vblendps        $3, %ymm1, %ymm0, %ymm0         # ymm0 =
ymm1[0,1],ymm0[2,3,4,5,6,7]
        retq
permute_vector(unsigned long __vector(4)):                #
@permute_vector(unsigned long __vector(4))
        vpermpd $144, %ymm0, %ymm0              # ymm0 = ymm0[0,0,1,2]
        vxorps  %xmm1, %xmm1, %xmm1
        vblendps        $3, %ymm1, %ymm0, %ymm0         # ymm0 =
ymm1[0,1],ymm0[2,3,4,5,6,7]
        retq
```