/* Capstone Disassembly Engine */

/* By Dmitry Sibirtsev  <sibirtsevdl@gmail.com>, 2023 */

#ifdef CAPSTONE_HAS_HPPA

#include <string.h>

#include <stdlib.h>

#include "HPPAMapping.h"

#include "HPPAConstants.h"

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

#include "../../utils.h"

#ifndef CAPSTONE_DIET

static const name_map group_name_maps[] = {

  { HPPA_GRP_INVALID, NULL },

  { HPPA_GRP_COMPUTATION, "computation" },

  { HPPA_GRP_MULTIMEDIA, "multimedia" },

  { HPPA_GRP_MEM_REF, "memory_reference" },

  { HPPA_GRP_LONG_IMM, "long_imm" },

  { HPPA_GRP_BRANCH, "branch" },

  { HPPA_GRP_SYSCTRL, "system_control" },

  { HPPA_GRP_ASSIST, "assist" },

  { HPPA_GRP_FLOAT, "float" },

};

#endif

const char *HPPA_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

}

#ifndef CAPSTONE_DIET

static const name_map insn_name_maps[HPPA_INS_ENDING] = {

  { HPPA_INS_INVALID, NULL },

  { HPPA_INS_ADD, "add" },

  { HPPA_INS_ADDI, "addi" },

  { HPPA_INS_ADDIO, "addio" },

  { HPPA_INS_ADDIT, "addit" },

  { HPPA_INS_ADDITO, "addito" },

  { HPPA_INS_ADDB, "addb" },

  { HPPA_INS_ADDBT, "addbt" },

  { HPPA_INS_ADDBF, "addbf" },

  { HPPA_INS_ADDIB, "addib" },

  { HPPA_INS_ADDIBT, "addibt" },

  { HPPA_INS_ADDIBF, "addibf" },

  { HPPA_INS_ADDIL, "addil" },

  { HPPA_INS_ADDC, "addc" },

  { HPPA_INS_ADDCO, "addco" },

  { HPPA_INS_ADDL, "addl" },

  { HPPA_INS_ADDO, "addo" },

  { HPPA_INS_AND, "and" },

  { HPPA_INS_ANDCM, "andcm" },

  { HPPA_INS_B, "b" },

  { HPPA_INS_BB, "bb" },

  { HPPA_INS_BE, "be" },

  { HPPA_INS_BL, "bl" },

  { HPPA_INS_BLE, "ble" },

  { HPPA_INS_BLR, "blr" },

  { HPPA_INS_BREAK, "break" },

  { HPPA_INS_BV, "bv" },

  { HPPA_INS_BVB, "bvb" },

  { HPPA_INS_BVE, "bve" },

  { HPPA_INS_CALL, "call" },

  { HPPA_INS_CLDD, "cldd" },

  { HPPA_INS_CLDDS, "cldds" },

  { HPPA_INS_CLDDX, "clddx" },

  { HPPA_INS_CLDW, "cldw" },

  { HPPA_INS_CLDWS, "cldws" },

  { HPPA_INS_CLDWX, "cldwx" },

  { HPPA_INS_CLRBTS, "clrbts" },

  { HPPA_INS_CMPB, "cmpb" },

  { HPPA_INS_CMPCLR, "cmpclr" },

  { HPPA_INS_CMPIB, "cmpib" },

  { HPPA_INS_CMPICLR, "cmpiclr" },

  { HPPA_INS_COMB, "comb" },

  { HPPA_INS_COMBT, "combt" },

  { HPPA_INS_COMBF, "combf" },

  { HPPA_INS_COMCLR, "comclr" },

  { HPPA_INS_COMIB, "comib" },

  { HPPA_INS_COMIBT, "comibt" },

  { HPPA_INS_COMIBF, "comibf" },

  { HPPA_INS_COMICLR, "comiclr" },

  { HPPA_INS_COPR, "copr" },

  { HPPA_INS_COPY, "copy" },

  { HPPA_INS_CSTD, "cstd" },

  { HPPA_INS_CSTDS, "cstds" },

  { HPPA_INS_CSTDX, "cstdx" },

  { HPPA_INS_CSTW, "cstw" },

  { HPPA_INS_CSTWS, "cstws" },

  { HPPA_INS_CSTWX, "cstwx" },

  { HPPA_INS_DCOR, "dcor" },

  { HPPA_INS_DEP, "dep" },

  { HPPA_INS_DEPI, "depi" },

  { HPPA_INS_DEPD, "depd" },

  { HPPA_INS_DEPDI, "depdi" },

  { HPPA_INS_DEPW, "depw" },

  { HPPA_INS_DEPWI, "depwi" },

  { HPPA_INS_DIAG, "diag" },

  { HPPA_INS_DS, "ds" },

  { HPPA_INS_EXTRD, "extrd" },

  { HPPA_INS_EXTRS, "extrs" },

  { HPPA_INS_EXTRU, "extru" },

  { HPPA_INS_EXTRW, "extrw" },

  { HPPA_INS_FABS, "fabs" },

  { HPPA_INS_FADD, "fadd" },

  { HPPA_INS_FCMP, "fcmp" },

  { HPPA_INS_FCNV, "fcnv" },

  { HPPA_INS_FCNVFF, "fcnvff" },

  { HPPA_INS_FCNVFX, "fcnvfx" },

  { HPPA_INS_FCNVFXT, "fcnvfxt" },

  { HPPA_INS_FCNVXF, "fcnvxf" },

  { HPPA_INS_FCPY, "fcpy" },

  { HPPA_INS_FDC, "fdc" },

  { HPPA_INS_FDCE, "fdce" },

  { HPPA_INS_FDIV, "fdiv" },

  { HPPA_INS_FIC, "fic" },

  { HPPA_INS_FICE, "fice" },

  { HPPA_INS_FID, "fid" },

  { HPPA_INS_FLDD, "fldd" },

  { HPPA_INS_FLDDS, "fldds" },

  { HPPA_INS_FLDDX, "flddx" },

  { HPPA_INS_FLDW, "fldw" },

  { HPPA_INS_FLDWS, "fldws" },

  { HPPA_INS_FLDWX, "fldwx" },

  { HPPA_INS_FMPY, "fmpy" },

  { HPPA_INS_FMPYADD, "fmpyadd" },

  { HPPA_INS_FMPYFADD, "fmpyfadd" },

  { HPPA_INS_FMPYNFADD, "fmpynfadd" },

  { HPPA_INS_FMPYSUB, "fmpysub" },

  { HPPA_INS_FNEG, "fneg" },

  { HPPA_INS_FNEGABS, "fnegabs" },

  { HPPA_INS_FREM, "frem" },

  { HPPA_INS_FRND, "frnd" },

  { HPPA_INS_FSQRT, "fsqrt" },

  { HPPA_INS_FSTD, "fstd" },

  { HPPA_INS_FSTDS, "fstds" },

  { HPPA_INS_FSTDX, "fstdx" },

  { HPPA_INS_FSTW, "fstw" },

  { HPPA_INS_FSTWS, "fstws" },

  { HPPA_INS_FSTWX, "fstwx" },

  { HPPA_INS_FSTQS, "fstqs" },

  { HPPA_INS_FSTQX, "fstqx" },

  { HPPA_INS_FSUB, "fsub" },

  { HPPA_INS_FTEST, "ftest" },

  { HPPA_INS_GATE, "gate" },

  { HPPA_INS_GFR, "gfr" },

  { HPPA_INS_GFW, "gfw" },

  { HPPA_INS_GRSHDW, "grshdw" },

  { HPPA_INS_HADD, "hadd" },

  { HPPA_INS_HAVG, "havg" },

  { HPPA_INS_HSHL, "hshl" },

  { HPPA_INS_HSHLADD, "hshladd" },

  { HPPA_INS_HSHR, "hshr" },

  { HPPA_INS_HSHRADD, "hshradd" },

  { HPPA_INS_HSUB, "hsub" },

  { HPPA_INS_IDTLBA, "idtlba" },

  { HPPA_INS_IDTLBP, "idtlbp" },

  { HPPA_INS_IDTLBT, "idtlbt" },

  { HPPA_INS_IDCOR, "idcor" },

  { HPPA_INS_IITLBA, "iitlba" },

  { HPPA_INS_IITLBP, "iitlbp" },

  { HPPA_INS_IITLBT, "iitlbt" },

  { HPPA_INS_LCI, "lci" },

  { HPPA_INS_LDB, "ldb" },

  { HPPA_INS_LDBS, "ldbs" },

  { HPPA_INS_LDBX, "ldbx" },

  { HPPA_INS_LDCD, "ldcd" },

  { HPPA_INS_LDCW, "ldcw" },

  { HPPA_INS_LDCWS, "ldcws" },

  { HPPA_INS_LDCWX, "ldcwx" },

  { HPPA_INS_LDD, "ldd" },

  { HPPA_INS_LDDA, "ldda" },

  { HPPA_INS_LDH, "ldh" },

  { HPPA_INS_LDHS, "ldhs" },

  { HPPA_INS_LDHX, "ldhx" },

  { HPPA_INS_LDI, "ldi" },

  { HPPA_INS_LDIL, "ldil" },

  { HPPA_INS_LDO, "ldo" },

  { HPPA_INS_LDSID, "ldsid" },

  { HPPA_INS_LDW, "ldw" },

  { HPPA_INS_LDWA, "ldwa" },

  { HPPA_INS_LDWAS, "ldwas" },

  { HPPA_INS_LDWAX, "ldwax" },

  { HPPA_INS_LDWM, "ldwm" },

  { HPPA_INS_LDWS, "ldws" },

  { HPPA_INS_LDWX, "ldwx" },

  { HPPA_INS_LPA, "lpa" },

  { HPPA_INS_MFCPU, "mfcpu" },

  { HPPA_INS_MFCTL, "mfctl" },

  { HPPA_INS_MFIA, "mfia" },

  { HPPA_INS_MFSP, "mfsp" },

  { HPPA_INS_MIXH, "mixh" },

  { HPPA_INS_MIXW, "mixw" },

  { HPPA_INS_MOVB, "movb" },

  { HPPA_INS_MOVIB, "movib" },

  { HPPA_INS_MTCPU, "mtcpu" },

  { HPPA_INS_MTCTL, "mtctl" },

  { HPPA_INS_MTSAR, "mtsar" },

  { HPPA_INS_MTSARCM, "mtsarcm" },

  { HPPA_INS_MTSM, "mtsm" },

  { HPPA_INS_MTSP, "mtsp" },

  { HPPA_INS_NOP, "nop" },

  { HPPA_INS_OR, "or" },

  { HPPA_INS_PDC, "pdc" },

  { HPPA_INS_PDTLB, "pdtlb" },

  { HPPA_INS_PDTLBE, "pdtlbe" },

  { HPPA_INS_PERMH, "permh" },

  { HPPA_INS_PITLB, "pitlb" },

  { HPPA_INS_PITLBE, "pitlbe" },

  { HPPA_INS_PMDIS, "pmdis" },

  { HPPA_INS_PMENB, "pmenb" },

  { HPPA_INS_POPBTS, "popbts" },

  { HPPA_INS_PROBE, "probe" },

  { HPPA_INS_PROBEI, "probei" },

  { HPPA_INS_PROBER, "prober" },

  { HPPA_INS_PROBERI, "proberi" },

  { HPPA_INS_PROBEW, "probew" },

  { HPPA_INS_PROBEWI, "probewi" },

  { HPPA_INS_PUSHBTS, "pushbts" },

  { HPPA_INS_PUSHNOM, "pushnom" },

  { HPPA_INS_RET, "ret" },

  { HPPA_INS_RFI, "rfi" },

  { HPPA_INS_RFIR, "rfir" },

  { HPPA_INS_RSM, "rsm" },

  { HPPA_INS_SHDWGR, "shdwgr" },

  { HPPA_INS_SHLADD, "shladd" },

  { HPPA_INS_SH1ADD, "sh1add" },

  { HPPA_INS_SH1ADDL, "sh1addl" },

  { HPPA_INS_SH1ADDO, "sh1addo" },

  { HPPA_INS_SH2ADD, "sh2add" },

  { HPPA_INS_SH2ADDL, "sh2addl" },

  { HPPA_INS_SH2ADDO, "sh2addo" },

  { HPPA_INS_SH3ADD, "sh3add" },

  { HPPA_INS_SH3ADDL, "sh3addl" },

  { HPPA_INS_SH3ADDO, "sh3addo" },

  { HPPA_INS_SHD, "shd" },

  { HPPA_INS_SHRPD, "shrpd" },

  { HPPA_INS_SHRPW, "shrpw" },

  { HPPA_INS_SPOP0, "spop0" },

  { HPPA_INS_SPOP1, "spop1" },

  { HPPA_INS_SPOP2, "spop2" },

  { HPPA_INS_SPOP3, "spop3" },

  { HPPA_INS_SSM, "ssm" },

  { HPPA_INS_STB, "stb" },

  { HPPA_INS_STBS, "stbs" },

  { HPPA_INS_STBY, "stby" },

  { HPPA_INS_STBYS, "stbys" },

  { HPPA_INS_STD, "std" },

  { HPPA_INS_STDA, "stda" },

  { HPPA_INS_STDBY, "stdby" },

  { HPPA_INS_STH, "sth" },

  { HPPA_INS_STHS, "sths" },

  { HPPA_INS_STW, "stw" },

  { HPPA_INS_STWA, "stwa" },

  { HPPA_INS_STWAS, "stwas" },

  { HPPA_INS_STWS, "stws" },

  { HPPA_INS_STWM, "stwm" },

  { HPPA_INS_SUB, "sub" },

  { HPPA_INS_SUBB, "subb" },

  { HPPA_INS_SUBBO, "subbo" },

  { HPPA_INS_SUBI, "subi" },

  { HPPA_INS_SUBIO, "subio" },

  { HPPA_INS_SUBO, "subo" },

  { HPPA_INS_SUBT, "subt" },

  { HPPA_INS_SUBTO, "subto" },

  { HPPA_INS_SYNC, "sync" },

  { HPPA_INS_SYNCDMA, "syncdma" },

  { HPPA_INS_TOCDIS, "tocdis" },

  { HPPA_INS_TOCEN, "tocen" },

  { HPPA_INS_UADDCM, "uaddcm" },

  { HPPA_INS_UADDCMT, "uaddcmt" },

  { HPPA_INS_UXOR, "uxor" },

  { HPPA_INS_VDEP, "vdep" },

  { HPPA_INS_VDEPI, "vdepi" },

  { HPPA_INS_VEXTRS, "vextrs" },

  { HPPA_INS_VEXTRU, "vextru" },

  { HPPA_INS_VSHD, "vshd" },

  { HPPA_INS_XMPYU, "xmpyu" },

  { HPPA_INS_XOR, "xor" },

  { HPPA_INS_ZDEP, "zdep" },

  { HPPA_INS_ZDEPI, "zdepi" },

  { HPPA_INS_ZVDEP, "zvdep" },

  { HPPA_INS_ZVDEPI, "zvdepi" },

};

#endif

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

{

#ifndef CAPSTONE_DIET

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

#else

  return NULL;

#endif

}

#ifndef CAPSTONE_DIET

/* Integer register names, indexed by the numbers which appear in the

   opcodes.  */

static const char *const reg_names[] = {

  "flags", "r1",  "rp",  "r3",  "r4",   "r5",   "r6",  "r7",

  "r8",  "r9",  "r10", "r11", "r12",  "r13",  "r14", "r15",

  "r16",   "r17", "r18", "r19", "r20",  "r21",  "r22", "r23",

  "r24",   "r25", "r26", "dp",  "ret0", "ret1", "sp",  "r31"

};

/* Floating point register names, indexed by the numbers which appear in the

   opcodes.  */

static const char *const fp_reg_names[] = {

  "fpsr", "fpe2", "fpe4", "fpe6", "fr4",  "fr5",  "fr6",  "fr7",

  "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",

  "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",

  "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31"

};

static const char *const control_reg[] = {

  "rctr",  "cr1",   "cr2",  "cr3", "cr4",   "cr5",   "cr6",  "cr7",

  "pidr1", "pidr2", "ccr",  "sar", "pidr3", "pidr4", "iva",  "eiem",

  "itmr",  "pcsq",  "pcoq", "iir", "isr",   "ior",   "ipsw", "eirr",

  "tr0",   "tr1",   "tr2",  "tr3", "tr4",   "tr5",   "tr6",  "tr7"

};

static const char *const space_reg[] = { "sr0", "sr1", "sr2", "sr3",

           "sr4", "sr5", "sr6", "sr7" };

static const char *const fpe_reg[] = {

  "fpe1",  "fpe3",  "fpe5",  "fpe7",  "fr4R",  "fr5R",  "fr6R",  "fr7R",

  "fr8R",  "fr9R",  "fr10R", "fr11R", "fr12R", "fr13R", "fr14R", "fr15R",

  "fr16R", "fr17R", "fr18R", "fr19R", "fr20R", "fr21R", "fr22R", "fr23R",

  "fr24R", "fr25R", "fr26R", "fr27R", "fr28R", "fr29R", "fr30R", "fr31R"

};

static const char *const sp_fp_reg[] = {

  "fr16L", "fr17L", "fr18L", "fr19L", "fr20L", "fr21L", "fr22L", "fr23L",

  "fr24L", "fr25L", "fr26L", "fr27L", "fr28L", "fr29L", "fr30L", "fr31L",

  "fr16R", "fr17R", "fr18R", "fr19R", "fr20R", "fr21R", "fr22R", "fr23R",

  "fr24R", "fr25R", "fr26R", "fr27R", "fr28R", "fr29R", "fr30R", "fr31R"

};

#endif

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

{

#ifndef CAPSTONE_DIET

  if (reg >= HPPA_REG_GR0 && reg <= HPPA_REG_GR31)

    return reg_names[reg - HPPA_REG_GR0];

  else if (reg >= HPPA_REG_FPR0 && reg <= HPPA_REG_FPR31)

    return fp_reg_names[reg - HPPA_REG_FPR0];

  else if (reg >= HPPA_REG_SR0 && reg <= HPPA_REG_SR7)

    return space_reg[reg - HPPA_REG_SR0];

  else if (reg >= HPPA_REG_CR0 && reg <= HPPA_REG_CR31)

    return control_reg[reg - HPPA_REG_CR0];

  else if (reg >= HPPA_REG_FPE0 && reg <= HPPA_REG_FPE31)

    return fpe_reg[reg - HPPA_REG_FPE0];

  else if (reg >= HPPA_REG_SP_FPR0 && reg <= HPPA_REG_SP_FPR31)

    return sp_fp_reg[reg - HPPA_REG_SP_FPR0];

  return NULL;

#else

  return NULL;

#endif

}

void HPPA_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int opcode)

{

  insn->id = opcode;

}

static void sort_and_uniq(cs_regs arr, uint8_t n, uint8_t *new_n)

{

  /* arr is always a tiny (usually n < 3) array,

   * a simple O(n^2) sort is efficient enough. */

  int i;

  int j;

  int iMin;

  int tmp;

  /* a modified selection sort for sorting and making unique */

  for (j = 0; j < n; j++) {

    /* arr[iMin] will be min(arr[j .. n-1]) */

    iMin = j;

    for (i = j + 1; i < n; i++) {

      if (arr[i] < arr[iMin])

        iMin = i;

    }

    if (j != 0 && arr[iMin] == arr[j - 1]) { // duplicate ele found

      arr[iMin] = arr[n - 1];

      --n;

    } else {

      tmp = arr[iMin];

      arr[iMin] = arr[j];

      arr[j] = tmp;

    }

  }

  *new_n = n;

}

void HPPA_reg_access(const cs_insn *insn, cs_regs regs_read,

         uint8_t *regs_read_count, cs_regs regs_write,

         uint8_t *regs_write_count)

{

  uint8_t read_count = 0;

  uint8_t write_count = 0;

  const cs_hppa *hppa = &(insn->detail->hppa);

  for (unsigned i = 0; i < hppa->op_count; ++i) {

    const cs_hppa_op *op = &(hppa->operands[i]);

    switch (op->type) {

    case HPPA_OP_REG:

    case HPPA_OP_IDX_REG:

      if (op->access & CS_AC_READ) {

        regs_read[read_count++] = op->reg;

      }

      if (op->access & CS_AC_WRITE) {

        regs_write[write_count++] = op->reg;

      }

      break;

    case HPPA_OP_MEM:

      if (op->mem.space != HPPA_REG_INVALID)

        regs_read[read_count++] = op->mem.space;

      if (op->mem.base_access & CS_AC_READ) {

        regs_read[read_count++] = op->mem.base;

      }

      if (op->mem.base_access & CS_AC_WRITE) {

        regs_write[write_count++] = op->mem.base;

      }

      break;

    default:

      break;

    }

  }

  sort_and_uniq(regs_read, read_count, regs_read_count);

  sort_and_uniq(regs_write, write_count, regs_write_count);

}

#endif