Virtualization
/
capstone
mirror of https://gitlab.com/qemu-project/capstone.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
capstone/arch/HPPA/HPPAMapping.c

443 lines
12 KiB
C
Raw Permalink Blame History

/* 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
Reference in New Issue View Git Blame Copy Permalink