//
// Testcases for
//   128/256/512 bit vdbpsadbw
// intrinsics with no mask/blend mask/zero mask forms.
//
// Here we check for _mm*_dbsad_epu8 intrinsics.
//

#include "m512_test_util.h"
#include <stdio.h>

#if DEBUG
#define dprintf(...) printf(__VA_ARGS__)
#define ddisplay_w(...) display_pw(__VA_ARGS__)
#define ddisplay_b(...) display_pb(__VA_ARGS__)
#else
#define dprintf(...)
#define ddisplay_w(...)
#define ddisplay_b(...)
#endif // DEBUG

typedef int bool;
#define true 1
#define false 0

#define CHECK_DBPSADBW(opcode, res_bit_size, is_masked, mask, is_zero_mask,    \
                       imm)                                                    \
  {                                                                            \
    int fail = 0;                                                              \
    /* Compute the expected result. */                                         \
    expVal.zmmi =                                                              \
        compute_vdbpsadbw(&expVal, is_masked, mask, is_zero_mask, imm,         \
                          &bop1.zmmi, &bop2.zmmi, res_bit_size);               \
                                                                               \
    /* Compare the obtained and expected results. */                           \
    fail = check_equal_nw(&res, &expVal, (res_bit_size / 16),                  \
                          is_masked ? (is_zero_mask ? opcode " zero mask"      \
                                                    : opcode " blend mask")    \
                                    : opcode " no mask",                       \
                          __LINE__);                                           \
    if (fail) {                                                                \
      dprintf("\n");                                                           \
      ddisplay_w(&wres_orig, "old:", res_bit_size / 16);                       \
      dprintf("\n");                                                           \
      ddisplay_b(&bop2, "bop2:", res_bit_size / 8);                            \
      dprintf("\n");                                                           \
      ddisplay_b(&bop1, "bop1:", res_bit_size / 8);                            \
      dprintf("\n===========================================\n");              \
    }                                                                          \
  }

#define XYDBPSADBW(opcode, res_bit_size, mmsuffix, is_masked, mask,            \
                   is_zero_mask, imm, xy)                                      \
  {                                                                            \
    if (is_masked) {                                                           \
      if (is_zero_mask) {                                                      \
        /* Zero masking */                                                     \
        memset(&res, 0xFF, sizeof(res));                                       \
        res.xy##mmi[0] = mmsuffix##maskz_##dbsad_epu8(mask, bop1.xy##mmi[0],   \
                                                      bop2.xy##mmi[0], imm);   \
      } else {                                                                 \
        /* Blend masking */                                                    \
        memcpy(&res, &wres_orig, sizeof(res));                                 \
        res.xy##mmi[0] = mmsuffix##mask_##dbsad_epu8(                          \
            res.xy##mmi[0], mask, bop1.xy##mmi[0], bop2.xy##mmi[0], imm);      \
      }                                                                        \
    } else {                                                                   \
      /* No masking */                                                         \
      memset(&res, 0x0, sizeof(res));                                          \
      res.xy##mmi[0] =                                                         \
          mmsuffix##dbsad_epu8(bop1.xy##mmi[0], bop2.xy##mmi[0], imm);         \
    }                                                                          \
    CHECK_DBPSADBW(opcode, res_bit_size, is_masked, mask, is_zero_mask, imm)   \
  }

#define ZDBPSADBW(opcode, is_masked, mask, is_zero_mask, imm)                  \
  {                                                                            \
    if (is_masked) {                                                           \
      if (is_zero_mask) { /* Zero masking */                                   \
        memset(&res, 0xFF, sizeof(res));                                       \
        res.zmmi = _mm512_maskz_##dbsad_epu8(mask, bop1.zmmi, bop2.zmmi, imm); \
      } else { /* Blend masking */                                             \
        memcpy(&res, &wres_orig, sizeof(res));                                 \
        res.zmmi = _mm512_mask_##dbsad_epu8(res.zmmi, mask, bop1.zmmi,         \
                                            bop2.zmmi, imm);                   \
      }                                                                        \
    } else { /* No masking */                                                  \
      memset(&res, 0x0, sizeof(res));                                          \
      res.zmmi = _mm512_##dbsad_epu8(bop1.zmmi, bop2.zmmi, imm);               \
    }                                                                          \
    CHECK_DBPSADBW(opcode, 512, is_masked, mask, is_zero_mask, imm)            \
  }

//
// Data
//

volatile unsigned short u16_orig_arr[32] = {
    0x1000, 0x1100, 0x2200, 0x3300, 0x4400, 0x5500, 0x6600, 0x7700,
    0x8800, 0x9900, 0xaa00, 0xbb00, 0xcc00, 0xdd00, 0xee00, 0xff00,
    0x1234, 0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777,
    0x8888, 0x9999, 0xaaaa, 0xbbbb, 0xcccc, 0xdddd, 0xeeee, 0xffff};

V512 bop1, bop2;
V512 res, expVal;
V512 wres_orig;

static void NOINLINE init() {
  int i;

  // i8 operand vectors
  //
  for (i = 0; i < 64; i++) {
    bop1.s8[i] = i;
  }
  for (i = 63; i >= 0; i--) {
    bop2.s8[63 - i] = i;
  }

  // Destructed operand vectors
  memcpy((void *)&wres_orig, (void *)u16_orig_arr, 64);
}

//
// Emulate the vdbpsadbw operation.
//

__m512i NOINLINE compute_vdbpsadbw(void *res, bool is_masked, unsigned int mask,
                                   bool zero_mask, int imm, const void *op1,
                                   const void *op2, int res_bit_size) {
  V512 *vres = (V512 *)res;
  V512 *vop1 = (V512 *)op1;
  V512 *vop2 = (V512 *)op2;
  V512 vtmp;

  int lanes = res_bit_size / 128;
  int lane, res_i;
  int elems, elem;

  dprintf("\n\n");

  // Do unmasked vdbpsadbw to get temp result.
  //
  for (lane = 0; lane < lanes; lane++) {

    dprintf("\n");
    for (elem = 0; elem < 4; elem++) {
      int op_i;

      res_i = lane * 4 + elem;
      op_i = lane * 4 + ((imm >> (2 * elem)) & 0x3);
      vtmp.u32[res_i] = vop2->u32[op_i];

      dprintf("l,e %d:%d,   tmp[%d] = op2[%d]\n", lane, elem, res_i, op_i);
    }
  }

  elems = res_bit_size / 64;

  for (elem = 0; elem < elems; elem++) {
    unsigned short *res_wp = (unsigned short *)&vres->u64[elem];
    unsigned char *op1_bp = (unsigned char *)&vop1->u64[elem];
    unsigned char *tmp_bp = (unsigned char *)&vtmp.u64[elem];

    res_wp[0] = abs(op1_bp[0] - tmp_bp[0]) + abs(op1_bp[1] - tmp_bp[1]) +
                abs(op1_bp[2] - tmp_bp[2]) + abs(op1_bp[3] - tmp_bp[3]);

    res_wp[1] = abs(op1_bp[0] - tmp_bp[1]) + abs(op1_bp[1] - tmp_bp[2]) +
                abs(op1_bp[2] - tmp_bp[3]) + abs(op1_bp[3] - tmp_bp[4]);

    res_wp[2] = abs(op1_bp[4] - tmp_bp[2]) + abs(op1_bp[5] - tmp_bp[3]) +
                abs(op1_bp[6] - tmp_bp[4]) + abs(op1_bp[7] - tmp_bp[5]);

    res_wp[3] = abs(op1_bp[4] - tmp_bp[3]) + abs(op1_bp[5] - tmp_bp[4]) +
                abs(op1_bp[6] - tmp_bp[5]) + abs(op1_bp[7] - tmp_bp[6]);
  }

  // Apply masking to get final result.
  //
  elems = res_bit_size / 16;

  for (res_i = 0; res_i < elems; res_i++) {
    int elem_mask;

    elem_mask = mask & (1 << res_i);

    // The unmasked computation above has taken care of
    // the elem_mask == 1 case.
    if (elem_mask == 0) {
      if (zero_mask) {
        // Zeroing behavior.
        vres->u16[res_i] = 0;
      } else {
        // Blending behavior
        vres->u16[res_i] = wres_orig.u16[res_i];
      }
    }
  }

  return vres->zmmi;
}

//
// Mask values.
//

#define KMASK8_NONE 0xff
#define KMASK16_NONE 0xffff
#define KMASK32_NONE 0xffffffff

#define KMASK8_ONES 0xff
#define KMASK16_ONES 0xffff
#define KMASK32_ONES 0xffffffff

#define KMASK8_ALT 0xaa
#define KMASK16_ALT 0xaaaa
#define KMASK32_ALT 0xaaaaaaaa

//
// Immediate value.
//
#define IMM_3210 0xe4

//
// Tests for vdbpsadbw
//
void do_xdbpsadbw() {
  XYDBPSADBW("EDBPSADBW", 128, _mm_, false, KMASK8_NONE, false, IMM_3210, x);

  XYDBPSADBW("EDBPSADBW", 128, _mm_, true, KMASK8_ONES, false, IMM_3210, x);

  XYDBPSADBW("EDBPSADBW", 128, _mm_, true, KMASK8_ALT, false, IMM_3210, x);

  XYDBPSADBW("EDBPSADBW", 128, _mm_, true, KMASK8_ALT, true, IMM_3210, x);
}

void do_ydbpsadbw() {
  XYDBPSADBW("YDBPSADBW", 256, _mm256_, false, KMASK16_NONE, false, IMM_3210,
             y);

  XYDBPSADBW("YDBPSADBW", 256, _mm256_, true, KMASK16_ONES, false, IMM_3210, y);

  XYDBPSADBW("YDBPSADBW", 256, _mm256_, true, KMASK16_ALT, false, IMM_3210, y);

  XYDBPSADBW("YDBPSADBW", 256, _mm256_, true, KMASK16_ALT, true, IMM_3210, y);
}

void do_zdbpsadbw() {
  ZDBPSADBW("ZDBPSADBW", false, KMASK32_NONE, false, IMM_3210);

  ZDBPSADBW("ZDBPSADBW", true, KMASK32_ONES, false, IMM_3210);

  ZDBPSADBW("ZDBPSADBW", true, KMASK32_ALT, false, IMM_3210);

  ZDBPSADBW("ZDBPSADBW", true, KMASK32_ALT, true, IMM_3210);
}

int main() {
  init();

  do_xdbpsadbw();
  do_ydbpsadbw();
  do_zdbpsadbw();

  if (n_errs != 0) {
    printf("FAILED\n");
    return 1;
  }

  printf("PASSED\n");
  return 0;
}