[Clang][XTHeadVector] Define vector unit-stride load/store intrinsics for clang

[imkiva]

The goal of this PR is to make the following function work:

#include <riscv_vector.h>
#include <stdint.h>
#include <stdio.h>

void memcpy_v(uint8_t *dst, const uint8_t *src, size_t n) {
  for (size_t vl; n > 0; n -= vl, src += vl, dst += vl) {
    vl = __riscv_vsetvl_e8m4(n);
    vuint8m4_t vec_src = __riscv_th_vle8_v_u8m4(src, vl);
    __riscv_th_vse8_v_u8m4(dst, vec_src, vl);
  }
}

[imkiva]

Full working example:

#include <riscv_vector.h>
#include <stdint.h>
#include <stdio.h>

void memcpy_v(uint8_t *dst, const uint8_t *src, size_t n) {
  for (size_t vl; n > 0; n -= vl, src += vl, dst += vl) {
    vl = __riscv_vsetvl_e8m4(n);
    vuint8m4_t vec_src = __riscv_th_vle8_v_u8m4(src, vl);
    __riscv_th_vse8_v_u8m4(dst, vec_src, vl);
  }
}

void show(const char *prompt, const uint8_t *chunk, size_t n) {
  printf("%s: ", prompt);
  for (int i = 0; i < n; i++) {
    printf("%d, ", chunk[i]);
  }
  printf("\n");
}

#define N 8

int main() {
  uint8_t src[N] = {1, 2, 3, 4, 5, 6, 7, 8};
  uint8_t dst[N] = {};
  show("Before memcpy_v", dst, N);
  memcpy_v(dst, src, N);
  show("After  memcpy_v", dst, N);
}

[imkiva]

C++ version for testing unit-stride load/store with all VL:

#define __riscv_v_elen 64

#include <riscv_vector.h>
#include <stdint.h>
#include <stdio.h>
#include <assert.h>

template <size_t N> struct UnderlyingType {};
template <>         struct UnderlyingType<1> { using type = uint8_t;  using vtype = vuint8m4_t;  };
template <>         struct UnderlyingType<2> { using type = uint16_t; using vtype = vuint16m4_t; };
template <>         struct UnderlyingType<4> { using type = uint32_t; using vtype = vuint32m4_t; };
#if __riscv_v_elen >= 64
template <>         struct UnderlyingType<8> { using type = uint64_t; using vtype = vuint64m4_t; };
#endif

template <size_t N> struct RVV {};
template <>         struct RVV<1> {
  using UT = typename UnderlyingType<1>::type;
  using VT = typename UnderlyingType<1>::vtype;
  static inline size_t vsetvl(size_t N)                 { return __riscv_vsetvl_e8m4(N); }
  static inline auto   vle(const UT *src, size_t vl)    { return __riscv_th_vle8_v_u8m4(src, vl); }
  static inline auto   vse(UT *dst, VT vsrc, size_t vl) { __riscv_th_vse8_v_u8m4(dst, vsrc, vl); }
};
template <>         struct RVV<2> {
  using UT = typename UnderlyingType<2>::type;
  using VT = typename UnderlyingType<2>::vtype;
  static inline size_t vsetvl(size_t N)                 { return __riscv_vsetvl_e16m4(N); }
  static inline auto   vle(const UT *src, size_t vl)    { return __riscv_th_vle16_v_u16m4(src, vl); }
  static inline auto   vse(UT *dst, VT vsrc, size_t vl) { __riscv_th_vse16_v_u16m4(dst, vsrc, vl); }
};
template <>         struct RVV<4> {
  using UT = typename UnderlyingType<4>::type;
  using VT = typename UnderlyingType<4>::vtype;
  static inline size_t vsetvl(size_t N)                 { return __riscv_vsetvl_e32m4(N); }
  static inline auto   vle(const UT *src, size_t vl)    { return __riscv_th_vle32_v_u32m4(src, vl); }
  static inline auto   vse(UT *dst, VT vsrc, size_t vl) { __riscv_th_vse32_v_u32m4(dst, vsrc, vl); }
};
#if __riscv_v_elen >= 64
template <>         struct RVV<8> {
  using UT = typename UnderlyingType<8>::type;
  using VT = typename UnderlyingType<8>::vtype;
  static inline size_t vsetvl(size_t N)                 { return __riscv_vsetvl_e64m4(N); }
  static inline auto   vle(const UT *src, size_t vl)    { return __riscv_th_vle64_v_u64m4(src, vl); }
  static inline auto   vse(UT *dst, VT vsrc, size_t vl) { __riscv_th_vse64_v_u64m4(dst, vsrc, vl); }
};
#endif

template <typename T, size_t N>
void memcpy_v(T (&dst)[N], const T (&src)[N]) {
  using UT = typename UnderlyingType<sizeof(T)>::type;
  using V = RVV<sizeof(T)>;

  auto psrc = reinterpret_cast<const UT *>(src);
  auto pdst = reinterpret_cast<UT *>(dst);
  
  for (size_t vl, n = N; n > 0; n -= vl, psrc += vl, pdst += vl) {
    vl = V::vsetvl(n);
    auto vec_src = V::vle(src, vl);
    V::vse(dst, vec_src, vl);
  }
}

template <typename T, size_t N>
void show(const char *prompt, const T (&chunk)[N]) {
  printf("%s: ", prompt);
  for (int i = 0; i < N; i++)
    printf("%u, ", chunk[i]);
  printf("\n");
}

template <typename T>
void test() {
  T src[8] = {1, 2, 3, 4, 5, 6, 7, 8};
  T dst[8] = {};
  memcpy_v(dst, src);
  show("After  memcpy_v", dst);
  for (int i = 0; i < 8; i++)
    assert(src[i] == dst[i]);
}

int main() {
  test<uint8_t>();
  test<uint16_t>();
  test<uint32_t>();
#if __riscv_v_elen >= 64
  test<uint64_t>();
#endif
}