Add vst unit test

Change-Id: Ic01f1748bb2a7656d807a2c510c688d36ec2b013

tests/kelvin_isa/BUILD

diff --git a/tests/kelvin_isa/BUILD b/tests/kelvin_isa/BUILD
index 9986566..52865ac 100644
--- a/tests/kelvin_isa/BUILD
+++ b/tests/kelvin_isa/BUILD
@@ -221,6 +221,16 @@
 )
 
 kelvin_test(
+    name = "vst",
+    srcs = [
+        "vst.cc",
+    ],
+    deps = [
+        ":kelvin_test",
+    ],
+)
+
+kelvin_test(
     name = "vstq",
     srcs = [
         "vstq.cc",

tests/kelvin_isa/vst.cc

diff --git a/tests/kelvin_isa/vst.cc b/tests/kelvin_isa/vst.cc
new file mode 100644
index 0000000..11a5792
--- /dev/null
+++ b/tests/kelvin_isa/vst.cc
@@ -0,0 +1,729 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "crt/printf_traits.h"
+#include "tests/kelvin_isa/kelvin_test.h"
+
+inline uint8_t* vstp_data(uint8_t* data) {
+  vst_b_p_x(v0, data);
+  return data;
+}
+
+inline uint16_t* vstp_data(uint16_t* data) {
+  vst_h_p_x(v0, data);
+  return data;
+}
+
+inline uint32_t* vstp_data(uint32_t* data) {
+  vst_w_p_x(v0, data);
+  return data;
+}
+
+inline uint8_t* vstpm_data(uint8_t* data) {
+  vst_b_p_x_m(v0, data);
+  return data;
+}
+
+inline uint16_t* vstpm_data(uint16_t* data) {
+  vst_h_p_x_m(v0, data);
+  return data;
+}
+
+inline uint32_t* vstpm_data(uint32_t* data) {
+  vst_w_p_x_m(v0, data);
+  return data;
+}
+
+inline uint8_t* vstlp_xx(uint8_t* data, int length) {
+  vst_b_lp_xx(v0, data, length);
+  return data;
+}
+
+inline uint16_t* vstlp_xx(uint16_t* data, int length) {
+  vst_h_lp_xx(v0, data, length);
+  return data;
+}
+
+inline uint32_t* vstlp_xx(uint32_t* data, int length) {
+  vst_w_lp_xx(v0, data, length);
+  return data;
+}
+
+inline uint8_t* vstlpm_xx(uint8_t* data, int length) {
+  vst_b_lp_xx_m(v0, data, length);
+  return data;
+}
+
+inline uint16_t* vstlpm_xx(uint16_t* data, int length) {
+  vst_h_lp_xx_m(v0, data, length);
+  return data;
+}
+
+inline uint32_t* vstlpm_xx(uint32_t* data, int length) {
+  vst_w_lp_xx_m(v0, data, length);
+  return data;
+}
+
+uint8_t* vstp_xx(uint8_t* data, int length) {
+  vst_b_p_xx(v0, data, length);
+  return data;
+}
+
+uint16_t* vstp_xx(uint16_t* data, int length) {
+  vst_h_p_xx(v0, data, length);
+  return data;
+}
+
+uint32_t* vstp_xx(uint32_t* data, int length) {
+  vst_w_p_xx(v0, data, length);
+  return data;
+}
+
+uint8_t* vstpm_xx(uint8_t* data, int length) {
+  vst_b_p_xx_m(v0, data, length);
+  return data;
+}
+
+uint16_t* vstpm_xx(uint16_t* data, int length) {
+  vst_h_p_xx_m(v0, data, length);
+  return data;
+}
+
+uint32_t* vstpm_xx(uint32_t* data, int length) {
+  vst_w_p_xx_m(v0, data, length);
+  return data;
+}
+
+uint8_t* vstsp_xx(uint8_t* data, int stride) {
+  vst_b_sp_xx(v0, data, stride);
+  return data;
+}
+
+uint16_t* vstsp_xx(uint16_t* data, int stride) {
+  vst_h_sp_xx(v0, data, stride);
+  return data;
+}
+
+uint32_t* vstsp_xx(uint32_t* data, int stride) {
+  vst_w_sp_xx(v0, data, stride);
+  return data;
+}
+
+uint8_t* vstspm_xx(uint8_t* data, int stride) {
+  vst_b_sp_xx_m(v0, data, stride);
+  return data;
+}
+
+uint16_t* vstspm_xx(uint16_t* data, int stride) {
+  vst_h_sp_xx_m(v0, data, stride);
+  return data;
+}
+
+uint32_t* vstspm_xx(uint32_t* data, int stride) {
+  vst_w_sp_xx_m(v0, data, stride);
+  return data;
+}
+
+uint8_t* vsttp_xx(uint8_t* data, int stride) {
+  vst_b_tp_xx(v0, data, stride);
+  return data;
+}
+
+uint16_t* vsttp_xx(uint16_t* data, int stride) {
+  vst_h_tp_xx(v0, data, stride);
+  return data;
+}
+
+uint32_t* vsttp_xx(uint32_t* data, int stride) {
+  vst_w_tp_xx(v0, data, stride);
+  return data;
+}
+
+uint8_t* vsttpm_xx(uint8_t* data, int stride) {
+  vst_b_tp_xx_m(v0, data, stride);
+  return data;
+}
+
+uint16_t* vsttpm_xx(uint16_t* data, int stride) {
+  vst_h_tp_xx_m(v0, data, stride);
+  return data;
+}
+
+uint32_t* vsttpm_xx(uint32_t* data, int stride) {
+  vst_w_tp_xx_m(v0, data, stride);
+  return data;
+}
+
+template <typename T>
+struct TypeString {
+  static const char* type_str() { return "<unknown>"; }
+};
+
+template <>
+struct TypeString<uint8_t> {
+  static const char* type_str() { return "<uint8_t>"; }
+};
+
+template <>
+struct TypeString<uint16_t> {
+  static const char* type_str() { return "<uint16_t>"; }
+};
+
+template <>
+struct TypeString<uint32_t> {
+  static const char* type_str() { return "<uint32_t>"; }
+};
+
+// Test vst[_m] instructions for correct pointer update and store result.
+template <typename T, bool post_increment, bool stripmine>
+void test_ldst_x() {
+  uint8_t read_data[4 * VLENB] __attribute__((aligned(64)));
+  T* input = reinterpret_cast<T*>(read_data);
+  constexpr int size = (stripmine ? 4 : 1) * VLENB / sizeof(T);
+  for (int i = 0; i < size; i++) {
+    input[i] = static_cast<T>(i);
+  }
+
+  if (stripmine) {
+    vld_x_m(T, v0, input);
+  } else {
+    vld_x(T, v0, input);
+  }
+
+  uint8_t write_data[4 * VLENB] __attribute__((aligned(64)));
+  memset(write_data, 0, sizeof(write_data));
+  T* dut = reinterpret_cast<T*>(write_data);
+  if (post_increment) {
+    if (stripmine) {
+      dut = vstpm_data(dut);
+    } else {
+      dut = vstp_data(dut);
+    }
+  } else {
+    vst_x(T, v0, dut);
+  }
+
+  // Test post increment
+  int offset = 0;
+  if (post_increment) {
+    offset = (stripmine ? 4 : 1) * VLENB;
+  }
+  void* target = reinterpret_cast<void*>(write_data + offset);
+  if (reinterpret_cast<void*>(dut) != target) {
+    printf("Failed test_ldst_x for type %s:\n", TypeString<T>::type_str());
+    printf("  expected dut=%p to be %p\n", reinterpret_cast<void*>(dut),
+           target);
+    exit(1);
+  }
+
+  dut = reinterpret_cast<T*>(write_data);
+  for (int i = 0; i < size; i++) {
+    if (dut[i] != static_cast<T>(i)) {
+      printf("Failed test_ldst_x for type %s:\n", TypeString<T>::type_str());
+      printf("  expected %d at position %d/%d got ", i, i, size);
+      printf(PrintfTraits<T>::kFmt, dut[i]);
+      printf("\n");
+      exit(1);
+    }
+  }
+}
+
+// Test vst_p[_m] instructions for correct pointer update and store result.
+template <typename T, bool stripmine>
+void test_ldst_p_xx(int length) {
+  uint8_t read_data[4 * VLENB] __attribute__((aligned(64)));
+  T* input = reinterpret_cast<T*>(read_data);
+  constexpr int size = (stripmine ? 4 : 1) * VLENB / sizeof(T);
+  for (int i = 0; i < size; i++) {
+    input[i] = static_cast<T>(i);
+  }
+
+  if (stripmine) {
+    vld_x_m(T, v0, input);
+  } else {
+    vld_x(T, v0, input);
+  }
+
+  uint8_t write_data[4 * VLENB] __attribute__((aligned(64)));
+  memset(write_data, 0, sizeof(write_data));
+  T* dut = reinterpret_cast<T*>(write_data);
+  if (stripmine) {
+    dut = vstpm_xx(dut, length);
+  } else {
+    dut = vstp_xx(dut, length);
+  }
+
+  // Test post increment
+  void* target = reinterpret_cast<void*>(write_data + length * sizeof(T));
+  if (reinterpret_cast<void*>(dut) != target) {
+    printf("Failed test_ldst_p_xx for type %s:\n", TypeString<T>::type_str());
+    printf("  expected dut=%p to be %p\n", reinterpret_cast<void*>(dut),
+           target);
+    exit(1);
+  }
+
+  dut = reinterpret_cast<T*>(write_data);
+  for (int i = 0; i < size; i++) {
+    if (dut[i] != static_cast<T>(i)) {
+      printf("Failed test_ldst_p_xx for type %s:\n", TypeString<T>::type_str());
+      printf("  expected %d at position %d/%d got ", i, i, size);
+      printf(PrintfTraits<T>::kFmt, dut[i]);
+      printf("\n");
+      exit(1);
+    }
+  }
+}
+
+// Test vst_s[p][_m] instructions for correct pointer update and store result.
+template <typename T, bool post_increment, bool stripmine>
+void test_ldst_s_xx(int stride) {
+  uint8_t read_data[4 * VLENB] __attribute__((aligned(64)));
+  T* input = reinterpret_cast<T*>(read_data);
+  constexpr int size = (stripmine ? 4 : 1) * VLENB / sizeof(T);
+  for (int i = 0; i < size; i++) {
+    input[i] = static_cast<T>(i);
+  }
+
+  if (stripmine) {
+    vld_x_m(T, v0, input);
+  } else {
+    vld_x(T, v0, input);
+  }
+
+  uint8_t write_data[9 * VLENB] __attribute__((aligned(64)));
+  memset(write_data, 0, sizeof(write_data));
+  T* dut = reinterpret_cast<T*>(write_data);
+  if (post_increment) {
+    if (stripmine) {
+      dut = vstspm_xx(dut, stride);
+    } else {
+      dut = vstsp_xx(dut, stride);
+    }
+  } else {
+    if (stripmine) {
+      vst_s_xx_m(T, v0, dut, stride);
+    } else {
+      vst_s_xx(T, v0, dut, stride);
+    }
+  }
+
+  // Test post increment
+  int offset = 0;
+  if (post_increment) {
+    offset = (stripmine ? 4 * stride : stride) * sizeof(T);
+  }
+  void* target = reinterpret_cast<void*>(write_data + offset);
+  if (reinterpret_cast<void*>(dut) != target) {
+    printf("Failed test_ldst_s_xx for type %s:\n", TypeString<T>::type_str());
+    printf("  expected dut=%p to be %p\n", reinterpret_cast<void*>(dut),
+           target);
+    exit(1);
+  }
+
+  dut = reinterpret_cast<T*>(write_data);
+  constexpr int num_vectors = stripmine ? 4 : 1;
+  int val = 0;
+  for (int v = 0; v < num_vectors; ++v) {
+    for (size_t i = 0; i < VLENB / sizeof(T); i++) {
+      if (dut[i] != static_cast<T>(val)) {
+        printf("Failed test_ldst_s_xx for type %s:\n",
+               TypeString<T>::type_str());
+        printf("  expected %d at position %d/%d got ", val,
+               v * VLENB / sizeof(T) + i, size);
+        printf(PrintfTraits<T>::kFmt, dut[i]);
+        printf("\n");
+        exit(1);
+      }
+      val++;
+    }
+    dut += stride;
+  }
+}
+
+// Test vst_l[p][_m] instructions for correct pointer update and store result.
+template <typename T, bool post_increment, bool stripmine>
+void test_ldst_l_xx(int length) {
+  uint8_t read_data[4 * VLENB] __attribute__((aligned(64)));
+  T* input = reinterpret_cast<T*>(read_data);
+  constexpr int size = (stripmine ? 4 : 1) * VLENB / sizeof(T);
+  for (int i = 0; i < size; i++) {
+    input[i] = static_cast<T>(i);
+  }
+
+  // Saturate length
+  length = std::min(size, length);
+
+  if (stripmine) {
+    vld_x_m(T, v0, input);
+  } else {
+    vld_x(T, v0, input);
+  }
+
+  uint8_t write_data[4 * VLENB] __attribute__((aligned(64)));
+  memset(write_data, 0, sizeof(write_data));
+  T* dut = reinterpret_cast<T*>(write_data);
+  if (post_increment) {
+    if (stripmine) {
+      dut = vstlpm_xx(dut, length);
+    } else {
+      dut = vstlp_xx(dut, length);
+    }
+  } else {
+    if (stripmine) {
+      vst_l_xx_m(T, v0, dut, length);
+    } else {
+      vst_l_xx(T, v0, dut, length);
+    }
+  }
+
+  // Test post increment
+  void* target = reinterpret_cast<void*>(
+      write_data + (post_increment ? length * sizeof(T) : 0));
+  if (reinterpret_cast<void*>(dut) != target) {
+    printf("Failed test_ldst_l_xx for type %s:\n", TypeString<T>::type_str());
+    printf("  expected dut=%p to be %p\n", reinterpret_cast<void*>(dut),
+           target);
+    exit(1);
+  }
+
+  dut = reinterpret_cast<T*>(write_data);
+  for (int i = 0; i < length; i++) {
+    if (dut[i] != static_cast<T>(i)) {
+      printf("Failed test_ldst_l_xx for type %s:\n", TypeString<T>::type_str());
+      printf("  expected %d at position %d/%d got ", i, i, size);
+      printf(PrintfTraits<T>::kFmt, dut[i]);
+      printf("\n");
+      exit(1);
+    }
+  }
+}
+
+// Test vst_tp[_m] instructions for correct pointer update and store result.
+template <typename T, bool stripmine>
+void test_ldst_tp_xx(int stride) {
+  uint8_t read_data[4 * VLENB] __attribute__((aligned(64)));
+  T* input = reinterpret_cast<T*>(read_data);
+  constexpr int size = (stripmine ? 4 : 1) * VLENB / sizeof(T);
+  for (int i = 0; i < size; i++) {
+    input[i] = static_cast<T>(i);
+  }
+
+  if (stripmine) {
+    vld_x_m(T, v0, input);
+  } else {
+    vld_x(T, v0, input);
+  }
+
+  uint8_t write_data[9 * VLENB] __attribute__((aligned(64)));
+  memset(write_data, 0, sizeof(write_data));
+  T* dut = reinterpret_cast<T*>(write_data);
+
+  if (stripmine) {
+    dut = vsttpm_xx(dut, stride);
+  } else {
+    dut = vsttp_xx(dut, stride);
+  }
+
+  // Test post increment
+  void* target = reinterpret_cast<void*>(write_data + VLENB);
+  if (reinterpret_cast<void*>(dut) != target) {
+    printf("Failed test_ldst_tp_xx for type %s:\n", TypeString<T>::type_str());
+    printf("  expected dut=%p to be %p\n", reinterpret_cast<void*>(dut),
+           target);
+    exit(1);
+  }
+
+  dut = reinterpret_cast<T*>(write_data);
+  constexpr int num_vectors = stripmine ? 4 : 1;
+  int val = 0;
+  for (int v = 0; v < num_vectors; ++v) {
+    for (size_t i = 0; i < VLENB / sizeof(T); i++) {
+      if (dut[i] != static_cast<T>(val)) {
+        printf("Failed test_ldst_tp_xx for type %s:\n",
+               TypeString<T>::type_str());
+        printf("  expected %d at position %d/%d got ", val,
+               v * VLENB / sizeof(T) + i, size);
+        printf(PrintfTraits<T>::kFmt, dut[i]);
+        printf("\n");
+        exit(1);
+      }
+      val++;
+    }
+    dut += stride;
+  }
+}
+
+template <typename T, bool sm>
+void test_vst_l() {
+  constexpr int n = sizeof(T) * 8;
+  constexpr int s = sm ? 4 : 1;
+  constexpr int size = s * VLEN / n + 1;
+  T in[size] __attribute__((aligned(64)));
+  T dut[size] __attribute__((aligned(64)));
+  int vlen;
+  if (sm) {
+    getmaxvl_m(T, vlen);
+  } else {
+    getmaxvl(T, vlen);
+  }
+
+  for (int j = 0; j <= vlen + 1; ++j) {
+    in[j] = j + 1;
+  }
+
+  if (sm) {
+    vdup_x_m(T, v4, 0xcc);
+    vld_x_m(T, v0, in);
+    vst_x_m(T, v4, dut);
+    vst_x_m(T, v4, dut + vlen);
+  } else {
+    vdup_x(T, v1, 0xcc);
+    vld_x(T, v0, in);
+    vst_x(T, v1, dut);
+    vst_x(T, v1, dut + vlen);
+  }
+
+  for (int i = 0; i <= vlen; ++i) {
+    if (sm) {
+      vst_x_m(T, v4, dut);
+      vst_l_xx_m(T, v0, dut, i);
+    } else {
+      vst_x(T, v1, dut);
+      vst_l_xx(T, v0, dut, i);
+    }
+    for (int j = 0; j <= vlen; ++j) {
+      T ref = j < i ? j + 1 : 0xcc;
+      if (ref != dut[j]) {
+        printf("**error vst_l[%d,%d] ", i, j);
+        printf(PrintfTraits<T>::kFmtHex, ref);
+        printf(" ");
+        printf(PrintfTraits<T>::kFmtHex, dut[j]);
+        printf("\n");
+        exit(-1);
+      }
+    }
+  }
+}
+
+template <typename T>
+void test_vst_s() {
+  constexpr int n = sizeof(T) * 8;
+  constexpr int size = 4 * VLEN / n;
+  T in[size] __attribute__((aligned(64)));
+  T dut[2 * size] __attribute__((aligned(64)));
+  int vlen;
+  getmaxvl(T, vlen);
+
+  for (int i = 0; i < 2 * size; ++i) {
+    dut[i] = T(0xcccccccc);
+  }
+
+  for (int i = 0; i < 4 * vlen; ++i) {
+    in[i] = i + 1;
+  }
+
+  vld_x_m(T, v0, in);
+  vst_s_xx_m(T, v0, dut, vlen + 2);
+
+  for (int s = 0; s < 4; ++s) {
+    T* d = dut + s * (vlen + 2);
+    for (int i = 0; i < vlen + 2; ++i) {
+      T ref = i < vlen ? i + 1 + s * vlen : T(0xcccccccc);
+      if (ref != d[i]) {
+        printf("**error vst_s[%d] ", i);
+        printf(PrintfTraits<T>::kFmtHex, ref);
+        printf(" ");
+        printf(PrintfTraits<T>::kFmtHex, d[i]);
+        printf("\n");
+        exit(-1);
+      }
+    }
+  }
+}
+
+int main() {
+  int vlenb, vlenh, vlenw;
+
+  getmaxvl_b(vlenb);
+  getmaxvl_h(vlenh);
+  getmaxvl_w(vlenw);
+
+  // vst.*.x
+  test_ldst_x<uint8_t, false, false>();
+  test_ldst_x<uint16_t, false, false>();
+  test_ldst_x<uint32_t, false, false>();
+
+  // vst.*.p.x
+  test_ldst_x<uint8_t, true, false>();
+  test_ldst_x<uint16_t, true, false>();
+  test_ldst_x<uint32_t, true, false>();
+
+  // vst.*.p.x.m
+  test_ldst_x<uint8_t, true, true>();
+  test_ldst_x<uint16_t, true, true>();
+  test_ldst_x<uint32_t, true, true>();
+
+  // vst.*.l.xx
+  test_ldst_l_xx<uint8_t, false, false>(1);
+  test_ldst_l_xx<uint16_t, false, false>(1);
+  test_ldst_l_xx<uint32_t, false, false>(1);
+  test_ldst_l_xx<uint8_t, false, false>(vlenb / 2);
+  test_ldst_l_xx<uint16_t, false, false>(vlenh / 2);
+  test_ldst_l_xx<uint32_t, false, false>(vlenw / 2);
+  test_ldst_l_xx<uint8_t, false, false>(vlenb - 1);
+  test_ldst_l_xx<uint16_t, false, false>(vlenh - 1);
+  test_ldst_l_xx<uint32_t, false, false>(vlenw - 1);
+  test_ldst_l_xx<uint8_t, false, false>(vlenb);
+  test_ldst_l_xx<uint16_t, false, false>(vlenh);
+  test_ldst_l_xx<uint32_t, false, false>(vlenw);
+  test_ldst_l_xx<uint8_t, false, false>(vlenb + 1);
+  test_ldst_l_xx<uint16_t, false, false>(vlenh + 1);
+  test_ldst_l_xx<uint32_t, false, false>(vlenw + 1);
+
+  // vst.*.lp.xx
+  test_ldst_l_xx<uint8_t, true, false>(1);
+  test_ldst_l_xx<uint16_t, true, false>(1);
+  test_ldst_l_xx<uint32_t, true, false>(1);
+  test_ldst_l_xx<uint8_t, true, false>(vlenb / 2);
+  test_ldst_l_xx<uint16_t, true, false>(vlenh / 2);
+  test_ldst_l_xx<uint32_t, true, false>(vlenw / 2);
+  test_ldst_l_xx<uint8_t, true, false>(vlenb - 1);
+  test_ldst_l_xx<uint16_t, true, false>(vlenh - 1);
+  test_ldst_l_xx<uint32_t, true, false>(vlenw - 1);
+  test_ldst_l_xx<uint8_t, true, false>(vlenb);
+  test_ldst_l_xx<uint16_t, true, false>(vlenh);
+  test_ldst_l_xx<uint32_t, true, false>(vlenw);
+  test_ldst_l_xx<uint8_t, true, false>(vlenb + 1);
+  test_ldst_l_xx<uint16_t, true, false>(vlenh + 1);
+  test_ldst_l_xx<uint32_t, true, false>(vlenw + 1);
+
+  // vst.*.p.xx
+  test_ldst_p_xx<uint8_t, false>(1);
+  test_ldst_p_xx<uint16_t, false>(1);
+  test_ldst_p_xx<uint32_t, false>(1);
+  test_ldst_p_xx<uint8_t, false>(vlenb / 2);
+  test_ldst_p_xx<uint16_t, false>(vlenh / 2);
+  test_ldst_p_xx<uint32_t, false>(vlenw / 2);
+  test_ldst_p_xx<uint8_t, false>(vlenb - 1);
+  test_ldst_p_xx<uint16_t, false>(vlenh - 1);
+  test_ldst_p_xx<uint32_t, false>(vlenw - 1);
+  test_ldst_p_xx<uint8_t, false>(vlenb);
+  test_ldst_p_xx<uint16_t, false>(vlenh);
+  test_ldst_p_xx<uint32_t, false>(vlenw);
+  test_ldst_p_xx<uint8_t, false>(vlenb + 1);
+  test_ldst_p_xx<uint16_t, false>(vlenh + 1);
+  test_ldst_p_xx<uint32_t, false>(vlenw + 1);
+
+  // vst.*.sp.xx. Stride should be >= vector size.
+  test_ldst_s_xx<uint8_t, true, false>(vlenb);
+  test_ldst_s_xx<uint16_t, true, false>(vlenh);
+  test_ldst_s_xx<uint32_t, true, false>(vlenw);
+  test_ldst_s_xx<uint8_t, true, false>(vlenb + 1);
+  test_ldst_s_xx<uint16_t, true, false>(vlenh + 1);
+  test_ldst_s_xx<uint32_t, true, false>(vlenw + 1);
+
+  // vst.*.tp.xx. Stride should be >= vector size.
+  test_ldst_tp_xx<uint8_t, false>(vlenb);
+  test_ldst_tp_xx<uint16_t, false>(vlenh);
+  test_ldst_tp_xx<uint32_t, false>(vlenw);
+  test_ldst_tp_xx<uint8_t, false>(vlenb + 1);
+  test_ldst_tp_xx<uint16_t, false>(vlenh + 1);
+  test_ldst_tp_xx<uint32_t, false>(vlenw + 1);
+
+  getmaxvl_b_m(vlenb);
+  getmaxvl_h_m(vlenh);
+  getmaxvl_w_m(vlenw);
+
+  // vst.*.l.xx.m
+  test_ldst_l_xx<uint8_t, false, true>(1);
+  test_ldst_l_xx<uint16_t, false, true>(1);
+  test_ldst_l_xx<uint32_t, false, true>(1);
+  test_ldst_l_xx<uint8_t, false, true>(vlenb / 2);
+  test_ldst_l_xx<uint16_t, false, true>(vlenh / 2);
+  test_ldst_l_xx<uint32_t, false, true>(vlenw / 2);
+  test_ldst_l_xx<uint8_t, false, true>(vlenb - 1);
+  test_ldst_l_xx<uint16_t, false, true>(vlenh - 1);
+  test_ldst_l_xx<uint32_t, false, true>(vlenw - 1);
+  test_ldst_l_xx<uint8_t, false, true>(vlenb);
+  test_ldst_l_xx<uint16_t, false, true>(vlenh);
+  test_ldst_l_xx<uint32_t, false, true>(vlenw);
+  test_ldst_l_xx<uint8_t, false, true>(vlenb + 1);
+  test_ldst_l_xx<uint16_t, false, true>(vlenh + 1);
+  test_ldst_l_xx<uint32_t, false, true>(vlenw + 1);
+
+  // vst.*.lp.xx.m
+  test_ldst_l_xx<uint8_t, true, true>(1);
+  test_ldst_l_xx<uint16_t, true, true>(1);
+  test_ldst_l_xx<uint32_t, true, true>(1);
+  test_ldst_l_xx<uint8_t, true, true>(vlenb / 2);
+  test_ldst_l_xx<uint16_t, true, true>(vlenh / 2);
+  test_ldst_l_xx<uint32_t, true, true>(vlenw / 2);
+  test_ldst_l_xx<uint8_t, true, true>(vlenb - 1);
+  test_ldst_l_xx<uint16_t, true, true>(vlenh - 1);
+  test_ldst_l_xx<uint32_t, true, true>(vlenw - 1);
+  test_ldst_l_xx<uint8_t, true, true>(vlenb);
+  test_ldst_l_xx<uint16_t, true, true>(vlenh);
+  test_ldst_l_xx<uint32_t, true, true>(vlenw);
+  test_ldst_l_xx<uint8_t, true, true>(vlenb + 1);
+  test_ldst_l_xx<uint16_t, true, true>(vlenh + 1);
+  test_ldst_l_xx<uint32_t, true, true>(vlenw + 1);
+
+  // vst.*.p.xx.m
+  test_ldst_p_xx<uint8_t, true>(vlenb);
+  test_ldst_p_xx<uint16_t, true>(vlenh);
+  test_ldst_p_xx<uint32_t, true>(vlenw);
+  test_ldst_p_xx<uint8_t, true>(vlenb + 1);
+  test_ldst_p_xx<uint16_t, true>(vlenh + 1);
+  test_ldst_p_xx<uint32_t, true>(vlenw + 1);
+
+  // vst.*.s.xx.m. Stride should be >= vector size.
+  test_ldst_s_xx<uint8_t, false, true>(vlenb);
+  test_ldst_s_xx<uint16_t, false, true>(vlenh);
+  test_ldst_s_xx<uint32_t, false, true>(vlenw);
+  test_ldst_s_xx<uint8_t, false, true>(vlenb + 1);
+  test_ldst_s_xx<uint16_t, false, true>(vlenh + 1);
+  test_ldst_s_xx<uint32_t, false, true>(vlenw + 1);
+
+  // vst.*.sp.xx.m. Stride should be >= vector size.
+  test_ldst_s_xx<uint8_t, true, true>(vlenb);
+  test_ldst_s_xx<uint16_t, true, true>(vlenh);
+  test_ldst_s_xx<uint32_t, true, true>(vlenw);
+  test_ldst_s_xx<uint8_t, true, true>(vlenb + 1);
+  test_ldst_s_xx<uint16_t, true, true>(vlenh + 1);
+  test_ldst_s_xx<uint32_t, true, true>(vlenw + 1);
+
+  // vst.*.tp.xx.m. Stride should be >= vector size.
+  test_ldst_tp_xx<uint8_t, true>(vlenb);
+  test_ldst_tp_xx<uint16_t, true>(vlenh);
+  test_ldst_tp_xx<uint32_t, true>(vlenw);
+  test_ldst_tp_xx<uint8_t, true>(vlenb + 1);
+  test_ldst_tp_xx<uint16_t, true>(vlenh + 1);
+  test_ldst_tp_xx<uint32_t, true>(vlenw + 1);
+
+  test_vst_l<uint8_t, 0>();
+  test_vst_l<uint16_t, 0>();
+  test_vst_l<uint32_t, 0>();
+
+  test_vst_l<uint8_t, 1>();
+  test_vst_l<uint16_t, 1>();
+  test_vst_l<uint32_t, 1>();
+
+  test_vst_s<uint8_t>();
+  test_vst_s<uint16_t>();
+  test_vst_s<uint32_t>();
+
+  return 0;
+}