/* Capstone Disassembly Engine */

/* By Yoshinori Sato, 2022 */

#include <string.h>

#include "../../Mapping.h"

#include "SHInstPrinter.h"

#ifndef CAPSTONE_DIET

static const char *const s_reg_names[] = {

  "invalid", "r0",      "r1",  "r2",      "r3",      "r4",

  "r5",    "r6",      "r7",  "r8",      "r9",      "r10",

  "r11",     "r12",     "r13",   "r14",     "r15",     "r0_bank",

  "r1_bank", "r2_bank", "r3_bank", "r4_bank", "r5_bank", "r6_bank",

  "r7_bank", "fr0",     "fr1",   "fr2",     "fr3",     "fr4",

  "fr5",     "fr6",     "fr7",   "fr8",     "fr9",     "fr10",

  "fr11",    "fr12",    "fr13",  "fr14",    "fr15",    "dr0",

  "dr2",     "dr4",     "dr6",   "dr8",     "dr10",    "dr12",

  "dr14",    "xd0",     "xd2",   "xd4",     "xd6",     "xd8",

  "xd10",    "xd12",    "xd14",  "xf0",     "xf1",     "xf2",

  "xf3",     "xf4",     "xf5",   "xf6",     "xf7",     "xf8",

  "xf9",     "xf10",    "xf11",  "xf12",    "xf13",    "xf14",

  "xf15",    "fv0",     "fv4",   "fv8",     "fv12",    "xmtrx",

  "pc",    "pr",      "mach",  "macl",    "sr",      "gbr",

  "ssr",     "spc",     "sgr",   "dbr",     "vbr",     "tbr",

  "rs",    "re",      "mod",   "fpul",    "fpscr",   "x0",

  "x1",    "y0",      "y1",  "a0",      "a1",      "a0g",

  "a1g",     "m0",      "m1",  "dsr",     "0x0",     "0x1",

  "0x2",     "0x3",     "0x4",   "0x5",     "0x6",     "0x7",

  "0x8",     "0x9",     "0xa",   "0xb",     "0xc",     "0xd",

  "0xe",     "0xf",

};

#endif

const char *SH_reg_name(csh handle, unsigned int reg)

{

#ifdef CAPSTONE_DIET

  return NULL;

#else

  if (reg >= ARR_SIZE(s_reg_names)) {

    return NULL;

  }

  return s_reg_names[(int)reg];

#endif

}

void SH_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)

{

  insn->id = id; // These id's matches for sh

}

#ifndef CAPSTONE_DIET

static const char *const s_insn_names[] = {

  "unknown", "add",     "add",   "addc",    "addv",    "and",

  "band",    "bandnot", "bclr",  "bf",      "bf/s",    "bld",

  "bldnot",  "bor",     "bornot",  "bra",     "braf",    "bset",

  "bsr",     "bsrf",    "bst",   "bt",      "bt/s",    "bxor",

  "clips",   "clipu",   "clrdmxy", "clrmac",  "clrs",    "clrt",

  "cmp/eq",  "cmp/ge",  "cmp/gt",  "cmp/hi",  "cmp/hs",  "cmp/pl",

  "cmp/pz",  "cmp/str", "div0s",   "div0u",   "div1",    "divs",

  "divu",    "dmuls.l", "dmulu.l", "dt",      "exts",    "exts",

  "extu",    "extu",    "fabs",  "fadd",    "fcmp/eq", "fcmp/gt",

  "fcnvds",  "fcnvsd",  "fdiv",  "fipr",    "fldi0",   "fldi1",

  "flds",    "float",   "fmac",  "fmov",    "fmul",    "fneg",

  "fpchg",   "frchg",   "fsca",  "fschg",   "fsqrt",   "fsrra",

  "fsts",    "fsub",    "ftrc",  "ftrv",    "icbi",    "jmp",

  "jsr",     "jsr/n",   "ldbank",  "ldc",     "ldrc",    "ldre",

  "ldrs",    "lds",     "ldtlb",   "mac.l",   "mac.w",   "mov",

  "mova",    "movca",   "movco",   "movi20",  "movi20s", "movli",

  "movml",   "movmu",   "movrt",   "movt",    "movu",    "movua",

  "mul.l",   "mulr",    "muls",  "mulu",    "neg",     "negc",

  "nop",     "not",     "nott",  "ocbi",    "ocbp",    "ocbwb",

  "or",    "pref",    "prefi",   "resbank", "rotcl",   "rotcr",

  "rotl",    "rotr",    "rte",   "rts",     "rts/n",   "rtv/n",

  "setdmx",  "setdmy",  "setrc",   "sets",    "sett",    "shad",

  "shal",    "shar",    "shld",  "shll",    "shll16",  "shll2",

  "shll8",   "shlr",    "shlr16",  "shlr2",   "shlr8",   "sleep",

  "stbank",  "stc",     "sts",   "sub",     "subc",    "subv",

  "swap",    "swap",    "synco",   "tas",     "trapa",   "tst",

  "xor",     "xtrct",

};

#endif

const char *SH_insn_name(csh handle, unsigned int id)

{

#ifdef CAPSTONE_DIET

  return NULL;

#else

  if (id >= ARR_SIZE(s_insn_names)) {

    return NULL;

  }

  return s_insn_names[id];

#endif

}

#ifndef CAPSTONE_DIET

#endif

#ifndef CAPSTONE_DIET

static void print_dsp_double(SStream *O, sh_info *info, int xy)

{

  char suffix_xy = 'x' + xy;

  int i;

  if (info->op.operands[xy].dsp.insn == SH_INS_DSP_NOP) {

    if ((info->op.operands[0].dsp.insn == SH_INS_DSP_NOP) &&

        (info->op.operands[1].dsp.insn == SH_INS_DSP_NOP)) {

      SStream_concat(O, "nop%c", suffix_xy);

    }

  } else {

    SStream_concat(O, "mov%c", suffix_xy);

    switch (info->op.operands[xy].dsp.size) {

    case 16:

      SStream_concat0(O, ".w ");

      break;

    case 32:

      SStream_concat0(O, ".l ");

      break;

    }

    for (i = 0; i < 2; i++) {

      switch (info->op.operands[xy].dsp.operand[i]) {

      default:

        break;

      case SH_OP_DSP_REG_IND:

        SStream_concat(O, "@%s",

                 s_reg_names[info->op.operands[xy]

                   .dsp.r[i]]);

        break;

      case SH_OP_DSP_REG_POST:

        SStream_concat(O, "@%s+",

                 s_reg_names[info->op.operands[xy]

                   .dsp.r[i]]);

        break;

      case SH_OP_DSP_REG_INDEX:

        SStream_concat(O, "@%s+%s",

                 s_reg_names[info->op.operands[xy]

                   .dsp.r[i]],

                 s_reg_names[SH_REG_R8 + xy]);

        break;

      case SH_OP_DSP_REG:

        SStream_concat(O, "%s",

                 s_reg_names[info->op.operands[xy]

                   .dsp.r[i]]);

        break;

      }

      if (i == 0)

        SStream_concat0(O, ",");

    }

  }

  if (xy == 0)

    SStream_concat0(O, " ");

}

static const char *s_dsp_insns[] = {

  "invalid",    "nop",      "mov",    "pshl",  "psha",  "pmuls",

  "pclr_pmuls", "psub_pmuls", "padd_pmuls", "psubc", "paddc", "pcmp",

  "pabs",       "prnd",     "psub",   "psub",  "padd",  "pand",

  "pxor",       "por",      "pdec",   "pinc",  "pclr",  "pdmsb",

  "pneg",       "pcopy",      "psts",   "plds",  "pswap", "pwad",

  "pwsb",

};

static void print_dsp(SStream *O, sh_info *info)

{

  int i;

  switch (info->op.op_count) {

  case 1:

    // single transfer

    SStream_concat0(O, "movs");

    switch (info->op.operands[0].dsp.size) {

    case 16:

      SStream_concat0(O, ".w ");

      break;

    case 32:

      SStream_concat0(O, ".l ");

      break;

    }

    for (i = 0; i < 2; i++) {

      switch (info->op.operands[0].dsp.operand[i]) {

      default:

        break;

      case SH_OP_DSP_REG_PRE:

        SStream_concat(O, "@-%s",

                 s_reg_names[info->op.operands[0]

                   .dsp.r[i]]);

        break;

      case SH_OP_DSP_REG_IND:

        SStream_concat(O, "@%s",

                 s_reg_names[info->op.operands[0]

                   .dsp.r[i]]);

        break;

      case SH_OP_DSP_REG_POST:

        SStream_concat(O, "@%s+",

                 s_reg_names[info->op.operands[0]

                   .dsp.r[i]]);

        break;

      case SH_OP_DSP_REG_INDEX:

        SStream_concat(O, "@%s+%s",

                 s_reg_names[info->op.operands[0]

                   .dsp.r[i]],

                 s_reg_names[SH_REG_R8]);

        break;

      case SH_OP_DSP_REG:

        SStream_concat(O, "%s",

                 s_reg_names[info->op.operands[0]

                   .dsp.r[i]]);

      }

      if (i == 0)

        SStream_concat0(O, ",");

    }

    break;

  case 2: // Double transfer

    print_dsp_double(O, info, 0);

    print_dsp_double(O, info, 1);

    break;

  case 3: // Parallel

    switch (info->op.operands[2].dsp.cc) {

    default:

      break;

    case SH_DSP_CC_DCT:

      SStream_concat0(O, "dct ");

      break;

    case SH_DSP_CC_DCF:

      SStream_concat0(O, "dcf ");

      break;

    }

    switch (info->op.operands[2].dsp.insn) {

    case SH_INS_DSP_PSUB_PMULS:

    case SH_INS_DSP_PADD_PMULS:

      switch (info->op.operands[2].dsp.insn) {

      default:

        break;

      case SH_INS_DSP_PSUB_PMULS:

        SStream_concat0(O, "psub ");

        break;

      case SH_INS_DSP_PADD_PMULS:

        SStream_concat0(O, "padd ");

        break;

      }

      for (i = 0; i < 6; i++) {

        SStream_concat(O, "%s",

                 s_reg_names[info->op.operands[2]

                   .dsp.r[i]]);

        if ((i % 3) < 2)

          SStream_concat0(O, ",");

        if (i == 2)

          SStream_concat(

            O, " %s ",

            s_dsp_insns[SH_INS_DSP_PMULS]);

      }

      break;

    case SH_INS_DSP_PCLR_PMULS:

      SStream_concat0(O, s_dsp_insns[SH_INS_DSP_PCLR]);

      SStream_concat(

        O, " %s ",

        s_reg_names[info->op.operands[2].dsp.r[3]]);

      SStream_concat(O, "%s ", s_dsp_insns[SH_INS_DSP_PMULS]);

      for (i = 0; i < 3; i++) {

        SStream_concat(O, "%s",

                 s_reg_names[info->op.operands[2]

                   .dsp.r[i]]);

        if (i < 2)

          SStream_concat0(O, ",");

      }

      break;

    default:

      SStream_concat0(

        O, s_dsp_insns[info->op.operands[2].dsp.insn]);

      SStream_concat0(O, " ");

      for (i = 0; i < 3; i++) {

        if (info->op.operands[2].dsp.r[i] ==

            SH_REG_INVALID) {

          if (i == 0) {

            SStream_concat(

              O, "#%d",

              info->op.operands[2]

                .dsp.imm);

          }

        } else

          SStream_concat(

            O, "%s",

            s_reg_names[info->op.operands[2]

                    .dsp.r[i]]);

        if (i < 2 &&

            info->op.operands[2].dsp.r[i + 1] !=

              SH_REG_INVALID)

          SStream_concat0(O, ",");

      }

    }

    if (info->op.operands[0].dsp.insn != SH_INS_DSP_NOP) {

      SStream_concat0(O, " ");

      print_dsp_double(O, info, 0);

    }

    if (info->op.operands[1].dsp.insn != SH_INS_DSP_NOP) {

      SStream_concat0(O, " ");

      print_dsp_double(O, info, 1);

    }

    break;

  }

}

static void PrintMemop(SStream *O, sh_op_mem *op)

{

  switch (op->address) {

  case SH_OP_MEM_INVALID:

    break;

  case SH_OP_MEM_REG_IND:

    SStream_concat(O, "@%s", s_reg_names[op->reg]);

    break;

  case SH_OP_MEM_REG_POST:

    SStream_concat(O, "@%s+", s_reg_names[op->reg]);

    break;

  case SH_OP_MEM_REG_PRE:

    SStream_concat(O, "@-%s", s_reg_names[op->reg]);

    break;

  case SH_OP_MEM_REG_DISP:

    SStream_concat(O, "@(%d,%s)", op->disp, s_reg_names[op->reg]);

    break;

  case SH_OP_MEM_REG_R0: /// <= R0 indexed

    SStream_concat(O, "@(%s,%s)", s_reg_names[SH_REG_R0],

             s_reg_names[op->reg]);

    break;

  case SH_OP_MEM_GBR_DISP: /// <= GBR based displaysment

    SStream_concat(O, "@(%d,%s)", op->disp,

             s_reg_names[SH_REG_GBR]);

    break;

  case SH_OP_MEM_GBR_R0: /// <= GBR based R0 indexed

    SStream_concat(O, "@(%s,%s)", s_reg_names[SH_REG_R0],

             s_reg_names[SH_REG_GBR]);

    break;

  case SH_OP_MEM_PCR: /// <= PC relative

    SStream_concat(O, "0x%x", op->disp);

    break;

  case SH_OP_MEM_TBR_DISP: /// <= GBR based displaysment

    SStream_concat(O, "@@(%d,%s)", op->disp,

             s_reg_names[SH_REG_TBR]);

    break;

  }

}

#endif

void SH_printInst(MCInst *MI, SStream *O, void *PrinterInfo)

{

#ifndef CAPSTONE_DIET

  sh_info *info = (sh_info *)PrinterInfo;

  int i;

  int imm;

  if (MI->Opcode == SH_INS_DSP) {

    print_dsp(O, info);

    return;

  }

  SStream_concat0(O, (char *)s_insn_names[MI->Opcode]);

  switch (info->op.size) {

  case 8:

    SStream_concat0(O, ".b");

    break;

  case 16:

    SStream_concat0(O, ".w");

    break;

  case 32:

    SStream_concat0(O, ".l");

    break;

  case 64:

    SStream_concat0(O, ".d");

    break;

  }

  SStream_concat0(O, " ");

  for (i = 0; i < info->op.op_count; i++) {

    switch (info->op.operands[i].type) {

    case SH_OP_INVALID:

      break;

    case SH_OP_REG:

      SStream_concat0(O,

          s_reg_names[info->op.operands[i].reg]);

      break;

    case SH_OP_IMM:

      imm = info->op.operands[i].imm;

      SStream_concat(O, "#%d", imm);

      break;

    case SH_OP_MEM:

      PrintMemop(O, &info->op.operands[i].mem);

      break;

    }

    if (i < (info->op.op_count - 1)) {

      SStream_concat0(O, ",");

    }

  }

#endif

}

#ifndef CAPSTONE_DIET

static const name_map group_name_maps[] = {

  { SH_GRP_INVALID, NULL },

  { SH_GRP_JUMP, "jump" },

  { SH_GRP_CALL, "call" },

  { SH_GRP_INT, "int" },

  { SH_GRP_RET, "ret" },

  { SH_GRP_IRET, "iret" },

  { SH_GRP_PRIVILEGE, "privilege" },

  { SH_GRP_BRANCH_RELATIVE, "branch_relative" },

  { SH_GRP_SH2, "SH2" },

  { SH_GRP_SH2E, "SH2E" },

  { SH_GRP_SH2DSP, "SH2-DSP" },

  { SH_GRP_SH2A, "SH2A" },

  { SH_GRP_SH2AFPU, "SH2A-FPU" },

  { SH_GRP_SH3, "SH3" },

  { SH_GRP_SH3DSP, "SH3-DSP" },

  { SH_GRP_SH4, "SH4" },

  { SH_GRP_SH4A, "SH4A" },

};

#endif

const char *SH_group_name(csh handle, unsigned int id)

{

#ifndef CAPSTONE_DIET

  return id2name(group_name_maps, ARR_SIZE(group_name_maps), id);

#else

  return NULL;

#endif

}