/*
 * 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.
 */

// Kelvin ISA test common header

#ifndef TESTS_KELVIN_ISA_KELVIN_TEST_H_
#define TESTS_KELVIN_ISA_KELVIN_TEST_H_

#include <cstdio>

#include "crt/kelvin.h"

// Maximum storage required for parameterized machine load/store.
constexpr int VLEN = 256;  // simd register bits. Need to match the HW parameter
constexpr int VLENB = VLEN / 8;
constexpr int VLENH = VLEN / 16;
constexpr int VLENW = VLEN / 32;

uint32_t krand(void) {
  static uint32_t x = 123456789;
  static uint32_t y = 362436069;
  static uint32_t z = 521288629;
  static uint32_t w = 88675123;
  uint32_t t = x ^ (x << 11);
  x = y;
  y = z;
  z = w;
  return w = w ^ (w >> 19) ^ (t ^ (t >> 8));
}

#define getmaxvl(T, d)                 \
  {                                    \
    if (sizeof(T) == 1) getmaxvl_b(d); \
    if (sizeof(T) == 2) getmaxvl_h(d); \
    if (sizeof(T) == 4) getmaxvl_w(d); \
  }

#define getmaxvl_m(T, d)                 \
  {                                      \
    if (sizeof(T) == 1) getmaxvl_b_m(d); \
    if (sizeof(T) == 2) getmaxvl_h_m(d); \
    if (sizeof(T) == 4) getmaxvl_w_m(d); \
  }

#define vld_x(T, Vd, s)                 \
  {                                     \
    if (sizeof(T) == 1) vld_b_x(Vd, s); \
    if (sizeof(T) == 2) vld_h_x(Vd, s); \
    if (sizeof(T) == 4) vld_w_x(Vd, s); \
  }

#define vst_x(T, Vd, s)                 \
  {                                     \
    if (sizeof(T) == 1) vst_b_x(Vd, s); \
    if (sizeof(T) == 2) vst_h_x(Vd, s); \
    if (sizeof(T) == 4) vst_w_x(Vd, s); \
  }

#define vld_x_m(T, Vd, s)                 \
  {                                       \
    if (sizeof(T) == 1) vld_b_x_m(Vd, s); \
    if (sizeof(T) == 2) vld_h_x_m(Vd, s); \
    if (sizeof(T) == 4) vld_w_x_m(Vd, s); \
  }

#define vst_x_m(T, Vd, s)                 \
  {                                       \
    if (sizeof(T) == 1) vst_b_x_m(Vd, s); \
    if (sizeof(T) == 2) vst_h_x_m(Vd, s); \
    if (sizeof(T) == 4) vst_w_x_m(Vd, s); \
  }

#define vld_l_xx(T, Vd, s, t)                 \
  {                                           \
    if (sizeof(T) == 1) vld_b_l_xx(Vd, s, t); \
    if (sizeof(T) == 2) vld_h_l_xx(Vd, s, t); \
    if (sizeof(T) == 4) vld_w_l_xx(Vd, s, t); \
  }

#define vst_l_xx(T, Vd, s, t)                 \
  {                                           \
    if (sizeof(T) == 1) vst_b_l_xx(Vd, s, t); \
    if (sizeof(T) == 2) vst_h_l_xx(Vd, s, t); \
    if (sizeof(T) == 4) vst_w_l_xx(Vd, s, t); \
  }

#define vld_l_xx_m(T, Vd, s, t)                 \
  {                                             \
    if (sizeof(T) == 1) vld_b_l_xx_m(Vd, s, t); \
    if (sizeof(T) == 2) vld_h_l_xx_m(Vd, s, t); \
    if (sizeof(T) == 4) vld_w_l_xx_m(Vd, s, t); \
  }

#define vst_l_xx_m(T, Vd, s, t)                 \
  {                                             \
    if (sizeof(T) == 1) vst_b_l_xx_m(Vd, s, t); \
    if (sizeof(T) == 2) vst_h_l_xx_m(Vd, s, t); \
    if (sizeof(T) == 4) vst_w_l_xx_m(Vd, s, t); \
  }

#define vld_s_xx(T, Vd, s, t)                 \
  {                                           \
    if (sizeof(T) == 1) vld_b_s_xx(Vd, s, t); \
    if (sizeof(T) == 2) vld_h_s_xx(Vd, s, t); \
    if (sizeof(T) == 4) vld_w_s_xx(Vd, s, t); \
  }

#define vst_s_xx(T, Vd, s, t)                 \
  {                                           \
    if (sizeof(T) == 1) vst_b_s_xx(Vd, s, t); \
    if (sizeof(T) == 2) vst_h_s_xx(Vd, s, t); \
    if (sizeof(T) == 4) vst_w_s_xx(Vd, s, t); \
  }

#define vld_s_xx_m(T, Vd, s, t)                 \
  {                                             \
    if (sizeof(T) == 1) vld_b_s_xx_m(Vd, s, t); \
    if (sizeof(T) == 2) vld_h_s_xx_m(Vd, s, t); \
    if (sizeof(T) == 4) vld_w_s_xx_m(Vd, s, t); \
  }

#define vst_s_xx_m(T, Vd, s, t)                 \
  {                                             \
    if (sizeof(T) == 1) vst_b_s_xx_m(Vd, s, t); \
    if (sizeof(T) == 2) vst_h_s_xx_m(Vd, s, t); \
    if (sizeof(T) == 4) vst_w_s_xx_m(Vd, s, t); \
  }

#define vdup_x(T, Vd, s)                 \
  {                                      \
    if (sizeof(T) == 1) vdup_b_x(Vd, s); \
    if (sizeof(T) == 2) vdup_h_x(Vd, s); \
    if (sizeof(T) == 4) vdup_w_x(Vd, s); \
  }

#define vdup_x_m(T, Vd, s)                 \
  {                                        \
    if (sizeof(T) == 1) vdup_b_x_m(Vd, s); \
    if (sizeof(T) == 2) vdup_h_x_m(Vd, s); \
    if (sizeof(T) == 4) vdup_w_x_m(Vd, s); \
  }

#define test_alu_b_v(op, in0, ref)                                         \
  {                                                                        \
    uint8_t dut[VLENB] __attribute__((aligned(64))) = {0xcc};              \
    vdup_b_x(v0, in0);                                                     \
    __asm__ __volatile_always__(ARGS_F_A_A(op, v2, v0));                   \
    vst_b_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %02x : %02x %02x\n", __LINE__, op, in0, ref, \
             dut[0]);                                                      \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_h_v(op, in0, ref)                                         \
  {                                                                        \
    uint16_t dut[VLENH] __attribute__((aligned(64))) = {0xcccc};           \
    vdup_h_x(v0, in0);                                                     \
    __asm__ __volatile_always__(ARGS_F_A_A(op, v2, v0));                   \
    vst_h_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %04x : %04x %04x\n", __LINE__, op, in0, ref, \
             dut[0]);                                                      \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_w_v(op, in0, ref)                                          \
  {                                                                         \
    uint32_t dut[VLENW] __attribute__((aligned(64))) = {0xcccccccc};        \
    vdup_w_x(v0, in0);                                                      \
    __asm__ __volatile_always__(ARGS_F_A_A(op, v2, v0));                    \
    vst_w_x(v2, dut);                                                       \
    if (ref != dut[0]) {                                                    \
      printf("**error(%d)[%s] %08x : %08x %08lx\n", __LINE__, op, in0, ref, \
             dut[0]);                                                       \
      exit(-1);                                                             \
    }                                                                       \
  }

#define test_alu_b_vv(op, in0, in1, ref)                                   \
  {                                                                        \
    uint8_t dut[VLENB] __attribute__((aligned(64))) = {0xcc};              \
    vdup_b_x(v0, in0);                                                     \
    vdup_b_x(v1, in1);                                                     \
    __asm__ __volatile_always__(ARGS_F_A_A_A(op, v2, v0, v1));             \
    vst_b_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %02x %02x : %02x %02x\n", __LINE__, op, in0, \
             in1, ref, dut[0]);                                            \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_h_vv(op, in0, in1, ref)                                   \
  {                                                                        \
    uint16_t dut[VLENH] __attribute__((aligned(64))) = {0xcccc};           \
    vdup_h_x(v0, in0);                                                     \
    vdup_h_x(v1, in1);                                                     \
    __asm__ __volatile_always__(ARGS_F_A_A_A(op, v2, v0, v1));             \
    vst_h_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %04x %04x : %04x %04x\n", __LINE__, op, in0, \
             in1, ref, dut[0]);                                            \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_w_vv(op, in0, in1, ref)                                  \
  {                                                                       \
    uint32_t dut[VLENW] __attribute__((aligned(64))) = {0xcccccccc};      \
    vdup_w_x(v0, in0);                                                    \
    vdup_w_x(v1, in1);                                                    \
    __asm__ __volatile_always__(ARGS_F_A_A_A(op, v2, v0, v1));            \
    vst_w_x(v2, dut);                                                     \
    if (ref != dut[0]) {                                                  \
      printf("**error(%d)[%s] %08lx %08lx : %08lx %08lx\n", __LINE__, op, \
             static_cast<uint32_t>(in0), static_cast<uint32_t>(in1),      \
             static_cast<uint32_t>(ref), dut[0]);                         \
      exit(-1);                                                           \
    }                                                                     \
  }

#define test_aluw_h_vv(op, in0, in1, ref)                                  \
  {                                                                        \
    uint16_t dut[VLENH] __attribute__((aligned(64))) = {0xcccc};           \
    vdup_b_x(v0, in0);                                                     \
    vdup_b_x(v1, in1);                                                     \
    __asm__ __volatile__(ARGS_F_A_A_A(op, v2, v0, v1));                    \
    vst_h_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %02x %02x : %04x %04x\n", __LINE__, op, in0, \
             in1, ref, dut[0]);                                            \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_aluw_w_vv(op, in0, in1, ref)                                   \
  {                                                                         \
    uint32_t dut[VLENW] __attribute__((aligned(64))) = {0xcccccccc};        \
    vdup_h_x(v0, in0);                                                      \
    vdup_h_x(v1, in1);                                                      \
    __asm__ __volatile__(ARGS_F_A_A_A(op, v2, v0, v1));                     \
    vst_w_x(v2, dut);                                                       \
    if (ref != dut[0]) {                                                    \
      printf("**error(%d)[%s] %04x %04x : %08x %08lx\n", __LINE__, op, in0, \
             in1, ref, dut[0]);                                             \
      exit(-1);                                                             \
    }                                                                       \
  }

#define test_alu_b_vv3(op, in0, in1, in2, ref)                             \
  {                                                                        \
    uint8_t dut[VLENW] __attribute__((aligned(64))) = {0xcc};              \
    vdup_b_x(v0, in0);                                                     \
    vdup_b_x(v1, in1);                                                     \
    vdup_b_x(v2, in2);                                                     \
    __asm__ __volatile__(ARGS_F_A_A_A(op, v2, v0, v1));                    \
    vst_b_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %02x %02x %02x : %02x %02x\n", __LINE__, op, \
             in0, in1, in2, ref, dut[0]);                                  \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_h_vv3(op, in0, in1, in2, ref)                             \
  {                                                                        \
    uint16_t dut[VLENW] __attribute__((aligned(64))) = {0xcccc};           \
    vdup_h_x(v0, in0);                                                     \
    vdup_h_x(v1, in1);                                                     \
    vdup_h_x(v2, in2);                                                     \
    __asm__ __volatile__(ARGS_F_A_A_A(op, v2, v0, v1));                    \
    vst_h_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %04x %04x %04x : %04x %04x\n", __LINE__, op, \
             in0, in1, in2, ref, dut[0]);                                  \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_w_vv3(op, in0, in1, in2, ref)                              \
  {                                                                         \
    uint32_t dut[VLENW] __attribute__((aligned(64))) = {0xcccccccc};        \
    vdup_w_x(v0, in0);                                                      \
    vdup_w_x(v1, in1);                                                      \
    vdup_w_x(v2, in2);                                                      \
    __asm__ __volatile__(ARGS_F_A_A_A(op, v2, v0, v1));                     \
    vst_w_x(v2, dut);                                                       \
    if (ref != dut[0]) {                                                    \
      printf("**error(%d)[%s] %08x %08x %08x : %08x %08lx\n", __LINE__, op, \
             in0, in1, in2, ref, dut[0]);                                   \
      exit(-1);                                                             \
    }                                                                       \
  }

// clang-format off
#define test_alu_b_vx(op, in0, in1, ref)                                   \
  {                                                                        \
    uint8_t dut[VLENB] __attribute__((aligned(64))) = {0xcc};              \
    vdup_b_x(v0, in0);                                                     \
    __asm__ __volatile__(ARGS_F_A_A_A(op, v2, v0, %0) : : "r"(in1));       \
    vst_b_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %02x %02x : %02x %02x\n", __LINE__, op, in0, \
             in1, ref, dut[0]);                                            \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_h_vx(op, in0, in1, ref)                                   \
  {                                                                        \
    uint16_t dut[VLENH] __attribute__((aligned(64))) = {0xcccc};           \
    vdup_h_x(v0, in0);                                                     \
    __asm__ __volatile__(ARGS_F_A_A_A(op, v2, v0, %0) : : "r"(in1));       \
    vst_h_x(v2, dut);                                                      \
    if (ref != dut[0]) {                                                   \
      printf("**error(%d)[%s] %04x %04x : %04x %04x\n", __LINE__, op, in0, \
             in1, ref, dut[0]);                                            \
      exit(-1);                                                            \
    }                                                                      \
  }

#define test_alu_w_vx(op, in0, in1, ref)                                     \
  {                                                                          \
    uint32_t dut[VLENW] __attribute__((aligned(64))) = {0xcccccccc};         \
    vdup_w_x(v0, in0);                                                       \
    __asm__ __volatile_always__(ARGS_F_A_A_A(op, v2, v0, %0) : : "r"(in1));  \
    vst_w_x(v2, dut);                                                        \
    if (ref != dut[0]) {                                                     \
      printf("**error(%d)[%s] %08x %08x : %08x %08lx\n", __LINE__, op, in0,  \
             in1, ref, dut[0]);                                              \
      exit(-1);                                                              \
    }                                                                        \
  }
// clang-format on

#endif  // TESTS_KELVIN_ISA_KELVIN_TEST_H_