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

#ifdef CAPSTONE_HAS_HPPA

#include <capstone/platform.h>
#include "../../Mapping.h"
#include "../../utils.h"

#include "HPPAInstPrinter.h"
#include "HPPAMapping.h"

static const struct pa_insn pa_insns[] = {
	{ HPPA_INS_LDI, HPPA_GRP_LONG_IMM },
	{ HPPA_INS_CMPIB, HPPA_GRP_BRANCH },
	{ HPPA_INS_COMIB, HPPA_GRP_BRANCH },
	{ HPPA_INS_CMPB, HPPA_GRP_BRANCH },
	{ HPPA_INS_COMB, HPPA_GRP_BRANCH },
	{ HPPA_INS_ADDB, HPPA_GRP_BRANCH },
	{ HPPA_INS_ADDIB, HPPA_GRP_BRANCH },
	{ HPPA_INS_NOP, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_COPY, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_MTSAR, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_LDD, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDW, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDH, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDB, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STD, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STW, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STH, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STB, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDWM, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STWM, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDWX, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDHX, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDBX, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDWA, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDCW, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STWA, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STBY, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDDA, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDCD, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STDA, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDWAX, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDCWX, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDWS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDHS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDBS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDWAS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDCWS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STWS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STHS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STBS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STWAS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STDBY, HPPA_GRP_MEM_REF },
	{ HPPA_INS_STBYS, HPPA_GRP_MEM_REF },
	{ HPPA_INS_LDO, HPPA_GRP_LONG_IMM },
	{ HPPA_INS_LDIL, HPPA_GRP_LONG_IMM },
	{ HPPA_INS_ADDIL, HPPA_GRP_LONG_IMM },
	{ HPPA_INS_B, HPPA_GRP_BRANCH },
	{ HPPA_INS_BL, HPPA_GRP_BRANCH },
	{ HPPA_INS_GATE, HPPA_GRP_BRANCH },
	{ HPPA_INS_BLR, HPPA_GRP_BRANCH },
	{ HPPA_INS_BV, HPPA_GRP_BRANCH },
	{ HPPA_INS_BVE, HPPA_GRP_BRANCH },
	{ HPPA_INS_BE, HPPA_GRP_BRANCH },
	{ HPPA_INS_BLE, HPPA_GRP_BRANCH },
	{ HPPA_INS_MOVB, HPPA_GRP_BRANCH },
	{ HPPA_INS_MOVIB, HPPA_GRP_BRANCH },
	{ HPPA_INS_COMBT, HPPA_GRP_BRANCH },
	{ HPPA_INS_COMBF, HPPA_GRP_BRANCH },
	{ HPPA_INS_COMIBT, HPPA_GRP_BRANCH },
	{ HPPA_INS_COMIBF, HPPA_GRP_BRANCH },
	{ HPPA_INS_ADDBT, HPPA_GRP_BRANCH },
	{ HPPA_INS_ADDBF, HPPA_GRP_BRANCH },
	{ HPPA_INS_ADDIBT, HPPA_GRP_BRANCH },
	{ HPPA_INS_ADDIBF, HPPA_GRP_BRANCH },
	{ HPPA_INS_BB, HPPA_GRP_BRANCH },
	{ HPPA_INS_BVB, HPPA_GRP_BRANCH },
	{ HPPA_INS_CLRBTS, HPPA_GRP_BRANCH },
	{ HPPA_INS_POPBTS, HPPA_GRP_BRANCH },
	{ HPPA_INS_PUSHNOM, HPPA_GRP_BRANCH },
	{ HPPA_INS_PUSHBTS, HPPA_GRP_BRANCH },
	{ HPPA_INS_CMPCLR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_COMCLR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_OR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_XOR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_AND, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ANDCM, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_UXOR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_UADDCM, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_UADDCMT, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DCOR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_IDCOR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDIO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDIT, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDITO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDL, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDC, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ADDCO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUB, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUBO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUBB, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUBBO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUBT, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUBTO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DS, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUBI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SUBIO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_CMPICLR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_COMICLR, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SHLADD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH1ADD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH1ADDL, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH1ADDO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH2ADD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH2ADDL, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH2ADDO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH3ADD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH3ADDL, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SH3ADDO, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_HADD, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_HAVG, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_HSHL, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_HSHLADD, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_HSHR, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_HSHRADD, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_HSUB, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_MIXH, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_MIXW, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_PERMH, HPPA_GRP_MULTIMEDIA },
	{ HPPA_INS_SHRPD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SHRPW, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_VSHD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_SHD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_EXTRD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_EXTRW, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_VEXTRU, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_VEXTRS, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_EXTRU, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_EXTRS, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DEPD, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DEPDI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DEPW, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DEPWI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ZVDEP, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_VDEP, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ZDEP, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DEP, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ZVDEPI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_VDEPI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_ZDEPI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_DEPI, HPPA_GRP_COMPUTATION },
	{ HPPA_INS_BREAK, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_RFI, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_RFIR, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_SSM, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_RSM, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MTSM, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_LDSID, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MTSP, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MTCTL, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MTSARCM, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MFIA, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MFSP, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MFCTL, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_SYNC, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_SYNCDMA, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PROBE, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PROBEI, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PROBER, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PROBERI, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PROBEW, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PROBEWI, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_LPA, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_LCI, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PDTLB, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PITLB, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PDTLBE, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PITLBE, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_IDTLBA, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_IITLBA, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_IDTLBP, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_IITLBP, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_PDC, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_FDC, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_FIC, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_FDCE, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_FICE, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_DIAG, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_IDTLBT, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_IITLBT, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MTCPU, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_MFCPU, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_TOCEN, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_TOCDIS, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_SHDWGR, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_GRSHDW, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_GFW, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_GFR, HPPA_GRP_SYSCTRL },
	{ HPPA_INS_FLDW, HPPA_GRP_FLOAT },
	{ HPPA_INS_FLDD, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTW, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTD, HPPA_GRP_FLOAT },
	{ HPPA_INS_FLDWX, HPPA_GRP_FLOAT },
	{ HPPA_INS_FLDDX, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTWX, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTDX, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTQX, HPPA_GRP_FLOAT },
	{ HPPA_INS_FLDWS, HPPA_GRP_FLOAT },
	{ HPPA_INS_FLDDS, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTWS, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTDS, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSTQS, HPPA_GRP_FLOAT },
	{ HPPA_INS_FADD, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSUB, HPPA_GRP_FLOAT },
	{ HPPA_INS_FMPY, HPPA_GRP_FLOAT },
	{ HPPA_INS_FDIV, HPPA_GRP_FLOAT },
	{ HPPA_INS_FSQRT, HPPA_GRP_FLOAT },
	{ HPPA_INS_FABS, HPPA_GRP_FLOAT },
	{ HPPA_INS_FREM, HPPA_GRP_FLOAT },
	{ HPPA_INS_FRND, HPPA_GRP_FLOAT },
	{ HPPA_INS_FCPY, HPPA_GRP_FLOAT },
	{ HPPA_INS_FCNVFF, HPPA_GRP_FLOAT },
	{ HPPA_INS_FCNVXF, HPPA_GRP_FLOAT },
	{ HPPA_INS_FCNVFX, HPPA_GRP_FLOAT },
	{ HPPA_INS_FCNVFXT, HPPA_GRP_FLOAT },
	{ HPPA_INS_FMPYFADD, HPPA_GRP_FLOAT },
	{ HPPA_INS_FMPYNFADD, HPPA_GRP_FLOAT },
	{ HPPA_INS_FNEG, HPPA_GRP_FLOAT },
	{ HPPA_INS_FNEGABS, HPPA_GRP_FLOAT },
	{ HPPA_INS_FCNV, HPPA_GRP_FLOAT },
	{ HPPA_INS_FCMP, HPPA_GRP_FLOAT },
	{ HPPA_INS_XMPYU, HPPA_GRP_FLOAT },
	{ HPPA_INS_FMPYADD, HPPA_GRP_FLOAT },
	{ HPPA_INS_FMPYSUB, HPPA_GRP_FLOAT },
	{ HPPA_INS_FTEST, HPPA_GRP_FLOAT },
	{ HPPA_INS_FID, HPPA_GRP_FLOAT },
	{ HPPA_INS_PMDIS, HPPA_GRP_PERFMON },
	{ HPPA_INS_PMENB, HPPA_GRP_PERFMON },
	{ HPPA_INS_SPOP0, HPPA_GRP_ASSIST },
	{ HPPA_INS_SPOP1, HPPA_GRP_ASSIST },
	{ HPPA_INS_SPOP2, HPPA_GRP_ASSIST },
	{ HPPA_INS_SPOP3, HPPA_GRP_ASSIST },
	{ HPPA_INS_COPR, HPPA_GRP_ASSIST },
	{ HPPA_INS_CLDW, HPPA_GRP_ASSIST },
	{ HPPA_INS_CLDD, HPPA_GRP_ASSIST },
	{ HPPA_INS_CSTW, HPPA_GRP_ASSIST },
	{ HPPA_INS_CSTD, HPPA_GRP_ASSIST },
	{ HPPA_INS_CLDWX, HPPA_GRP_ASSIST },
	{ HPPA_INS_CLDDX, HPPA_GRP_ASSIST },
	{ HPPA_INS_CSTWX, HPPA_GRP_ASSIST },
	{ HPPA_INS_CSTDX, HPPA_GRP_ASSIST },
	{ HPPA_INS_CLDWS, HPPA_GRP_ASSIST },
	{ HPPA_INS_CLDDS, HPPA_GRP_ASSIST },
	{ HPPA_INS_CSTWS, HPPA_GRP_ASSIST },
	{ HPPA_INS_CSTDS, HPPA_GRP_ASSIST },
	{ HPPA_INS_CALL, HPPA_GRP_INVALID },
	{ HPPA_INS_RET, HPPA_GRP_INVALID },
};

static void set_op_imm(cs_hppa *hppa, uint64_t val)
{
	cs_hppa_op *op = &hppa->operands[hppa->op_count++];
	op->type = HPPA_OP_IMM;
	op->imm = val;
}

static void set_op_reg(cs_hppa *hppa, uint64_t val, cs_ac_type access)
{
	cs_hppa_op *op = &hppa->operands[hppa->op_count++];
	op->type = HPPA_OP_REG;
	op->reg = val;
	op->access = access;
}

static void set_op_idx_reg(cs_hppa *hppa, uint64_t reg)
{
	cs_hppa_op *op = &hppa->operands[hppa->op_count++];
	op->type = HPPA_OP_IDX_REG;
	op->reg = reg;
	op->access = CS_AC_READ;
}

static void set_op_disp(cs_hppa *hppa, uint64_t val)
{
	cs_hppa_op *op = &hppa->operands[hppa->op_count++];
	op->type = HPPA_OP_DISP;
	op->imm = val;
}

static void set_op_target(cs_hppa *hppa, uint64_t val)
{
	cs_hppa_op *op = &hppa->operands[hppa->op_count++];
	op->type = HPPA_OP_TARGET;
	op->imm = val;
}

static void set_op_mem(cs_hppa *hppa, uint32_t base, uint32_t space,
		       cs_ac_type base_access)
{
	cs_hppa_op *op = &hppa->operands[hppa->op_count++];
	op->type = HPPA_OP_MEM;
	op->mem.base = base;
	op->mem.space = space;
	op->mem.base_access = base_access;
}
/* HPPA instruction formats (access)
   i - imm arguments
   R - read access register
   W - write access register
   w - read + write access register
   r - index register (read only)
   T - offset (pc relative)
   o - displacement (imm)
   x - [r] or [o] defined by the operand kind
   b - base register (may be writable in some cases)
*/
static const struct pa_insn_fmt pa_formats[] = {
	{ HPPA_INS_LDI, "iW", false },

	{ HPPA_INS_CMPIB, "iRT", false },
	{ HPPA_INS_COMIB, "iRT", false },

	{ HPPA_INS_CMPB, "RRT", false },
	{ HPPA_INS_COMB, "RRT", false },

	{ HPPA_INS_ADDB, "RwT", false },

	{ HPPA_INS_ADDIB, "iwT", false },

	{ HPPA_INS_NOP, "", false },
	{ HPPA_INS_COPY, "RW", false },
	{ HPPA_INS_MTSAR, "R", false },

	{ HPPA_INS_LDD, "x(Rb)W", false },
	{ HPPA_INS_LDW, "x(Rb)W", false },
	{ HPPA_INS_LDH, "x(Rb)W", false },
	{ HPPA_INS_LDB, "x(Rb)W", false },
	{ HPPA_INS_STD, "Ro(Rb)", false },
	{ HPPA_INS_STW, "Ro(Rb)", false },
	{ HPPA_INS_STH, "Ro(Rb)", false },
	{ HPPA_INS_STB, "Ro(Rb)", false },
	{ HPPA_INS_LDWM, "o(Rw)W", false },
	{ HPPA_INS_STWM, "Ro(Rw)", false },
	{ HPPA_INS_LDWX, "r(Rb)W", false },
	{ HPPA_INS_LDHX, "r(Rb)W", false },
	{ HPPA_INS_LDBX, "r(Rb)W", false },
	{ HPPA_INS_LDWA, "x(R)W", false },
	{ HPPA_INS_LDCW, "x(Rb)W", false },
	{ HPPA_INS_STWA, "Ro(b)", false },
	{ HPPA_INS_STBY, "Ro(Rb)", false },
	{ HPPA_INS_LDDA, "x(b)W", false },
	{ HPPA_INS_LDCD, "x(Rb)W", false },
	{ HPPA_INS_STDA, "Ro(b)", false },
	{ HPPA_INS_LDWAX, "r(b)W", false },
	{ HPPA_INS_LDCWX, "r(Rb)W", false },
	{ HPPA_INS_LDWS, "o(Rb)W", false },
	{ HPPA_INS_LDHS, "o(Rb)W", false },
	{ HPPA_INS_LDBS, "o(Rb)W", false },
	{ HPPA_INS_LDWAS, "o(b)W", false },
	{ HPPA_INS_LDCWS, "o(Rb)W", false },
	{ HPPA_INS_STWS, "Ro(Rb)", false },
	{ HPPA_INS_STHS, "Ro(Rb)", false },
	{ HPPA_INS_STBS, "Ro(Rb)", false },
	{ HPPA_INS_STWAS, "Ro(b)", false },
	{ HPPA_INS_STDBY, "Ro(Rb)", false },
	{ HPPA_INS_STBYS, "Ro(Rb)", false },

	{ HPPA_INS_LDO, "o(R)W", false },
	{ HPPA_INS_LDIL, "iW", false },
	{ HPPA_INS_ADDIL, "iR", false },

	{ HPPA_INS_B, "TW", false },
	{ HPPA_INS_BL, "TW", false },
	{ HPPA_INS_GATE, "TW", false },
	{ HPPA_INS_BLR, "RW", false },
	{ HPPA_INS_BV, "x(R)", false },
	{ HPPA_INS_BVE, "(b)", false },
	{ HPPA_INS_BVE, "(b)W", true },
	{ HPPA_INS_BE, "o(RR)", false },
	{ HPPA_INS_BE, "o(RR)WW", true },
	{ HPPA_INS_BLE, "o(RR)", false },
	{ HPPA_INS_MOVB, "RWT", false },
	{ HPPA_INS_MOVIB, "iWT", false },
	{ HPPA_INS_COMBT, "RRT", false },
	{ HPPA_INS_COMBF, "RRT", false },
	{ HPPA_INS_COMIBT, "iRT", false },
	{ HPPA_INS_COMIBF, "iRT", false },
	{ HPPA_INS_ADDBT, "RwT", false },
	{ HPPA_INS_ADDBF, "RwT", false },
	{ HPPA_INS_ADDIBT, "iwT", false },
	{ HPPA_INS_ADDIBF, "iwT", false },
	{ HPPA_INS_BB, "RiT", false },
	{ HPPA_INS_BVB, "RT", false },
	{ HPPA_INS_CLRBTS, "", false },
	{ HPPA_INS_POPBTS, "i", false },
	{ HPPA_INS_PUSHNOM, "", false },
	{ HPPA_INS_PUSHBTS, "R", false },

	{ HPPA_INS_CMPCLR, "RRW", false },
	{ HPPA_INS_COMCLR, "RRW", false },
	{ HPPA_INS_OR, "RRW", false },
	{ HPPA_INS_XOR, "RRW", false },
	{ HPPA_INS_AND, "RRW", false },
	{ HPPA_INS_ANDCM, "RRW", false },
	{ HPPA_INS_UXOR, "RRW", false },
	{ HPPA_INS_UADDCM, "RRW", false },
	{ HPPA_INS_UADDCMT, "RRW", false },
	{ HPPA_INS_DCOR, "RW", false },
	{ HPPA_INS_IDCOR, "RW", false },
	{ HPPA_INS_ADDI, "iRW", false },
	{ HPPA_INS_ADDIO, "iRW", false },
	{ HPPA_INS_ADDIT, "iRW", false },
	{ HPPA_INS_ADDITO, "iRW", false },
	{ HPPA_INS_ADD, "RRW", false },
	{ HPPA_INS_ADDL, "RRW", false },
	{ HPPA_INS_ADDO, "RRW", false },
	{ HPPA_INS_ADDC, "RRW", false },
	{ HPPA_INS_ADDCO, "RRW", false },
	{ HPPA_INS_SUB, "RRW", false },
	{ HPPA_INS_SUBO, "RRW", false },
	{ HPPA_INS_SUBB, "RRW", false },
	{ HPPA_INS_SUBBO, "RRW", false },
	{ HPPA_INS_SUBT, "RRW", false },
	{ HPPA_INS_SUBTO, "RRW", false },
	{ HPPA_INS_DS, "RRW", false },
	{ HPPA_INS_SUBI, "iRW", false },
	{ HPPA_INS_SUBIO, "iRW", false },
	{ HPPA_INS_CMPICLR, "iRW", false },
	{ HPPA_INS_COMICLR, "iRW", false },
	{ HPPA_INS_SHLADD, "RiRW", false },
	{ HPPA_INS_SH1ADD, "RRW", false },
	{ HPPA_INS_SH1ADDL, "RRW", false },
	{ HPPA_INS_SH1ADDO, "RRW", false },
	{ HPPA_INS_SH2ADD, "RRW", false },
	{ HPPA_INS_SH2ADDL, "RRW", false },
	{ HPPA_INS_SH2ADDO, "RRW", false },
	{ HPPA_INS_SH3ADD, "RRW", false },
	{ HPPA_INS_SH3ADDL, "RRW", false },
	{ HPPA_INS_SH3ADDO, "RRW", false },

	{ HPPA_INS_HADD, "RRW", false },
	{ HPPA_INS_HAVG, "RRW", false },
	{ HPPA_INS_HSHL, "RiW", false },
	{ HPPA_INS_HSHLADD, "RiRW", false },
	{ HPPA_INS_HSHR, "RiW", false },
	{ HPPA_INS_HSHRADD, "RiRW", false },
	{ HPPA_INS_HSUB, "RRW", false },
	{ HPPA_INS_MIXH, "RRW", false },
	{ HPPA_INS_MIXW, "RRW", false },
	{ HPPA_INS_PERMH, "RW", false },

	{ HPPA_INS_SHRPD, "RRiW", false },
	{ HPPA_INS_SHRPD, "RRRW", true },
	{ HPPA_INS_SHRPW, "RRiW", false },
	{ HPPA_INS_SHRPW, "RRRW", true },
	{ HPPA_INS_VSHD, "RRW", false },
	{ HPPA_INS_SHD, "RRiW", false },
	{ HPPA_INS_EXTRD, "RiiW", false },
	{ HPPA_INS_EXTRD, "RRiW", true },
	{ HPPA_INS_EXTRW, "RiiW", false },
	{ HPPA_INS_EXTRW, "RRiW", true },
	{ HPPA_INS_VEXTRU, "RiW", false },
	{ HPPA_INS_VEXTRS, "RiW", false },
	{ HPPA_INS_EXTRU, "RiiW", false },
	{ HPPA_INS_EXTRS, "RiiW", false },
	{ HPPA_INS_DEPD, "RiiW", false },
	{ HPPA_INS_DEPDI, "iiiW", false },
	{ HPPA_INS_DEPW, "RiiW", false },
	{ HPPA_INS_DEPW, "RRiW", true },
	{ HPPA_INS_DEPWI, "iiiW", false },
	{ HPPA_INS_DEPWI, "iRiW", true },
	{ HPPA_INS_ZVDEP, "RiW", false },
	{ HPPA_INS_VDEP, "RiW", false },
	{ HPPA_INS_ZDEP, "RiiW", false },
	{ HPPA_INS_DEP, "RiiW", false },
	{ HPPA_INS_ZVDEPI, "iiW", false },
	{ HPPA_INS_VDEPI, "iiW", false },
	{ HPPA_INS_ZDEPI, "iiiW", false },
	{ HPPA_INS_DEPI, "iiiW", false },

	{ HPPA_INS_BREAK, "ii", false },
	{ HPPA_INS_RFI, "", false },
	{ HPPA_INS_RFIR, "", false },
	{ HPPA_INS_SSM, "iW", false },
	{ HPPA_INS_RSM, "iW", false },
	{ HPPA_INS_MTSM, "R", false },
	{ HPPA_INS_LDSID, "(RR)W", false },
	{ HPPA_INS_MTSP, "RW", false },
	{ HPPA_INS_MTCTL, "RW", false },
	{ HPPA_INS_MTSARCM, "R", false },
	{ HPPA_INS_MFIA, "W", false },
	{ HPPA_INS_MFSP, "RW", false },
	{ HPPA_INS_MFCTL, "RW", false },
	{ HPPA_INS_SYNC, "", false },
	{ HPPA_INS_SYNCDMA, "", false },
	{ HPPA_INS_PROBE, "(RR)RW", false },
	{ HPPA_INS_PROBEI, "(RR)iW", false },
	{ HPPA_INS_PROBER, "(RR)RW", false },
	{ HPPA_INS_PROBERI, "(RR)iW", false },
	{ HPPA_INS_PROBEW, "(RR)RW", false },
	{ HPPA_INS_PROBEWI, "(RR)iW", false },
	{ HPPA_INS_LPA, "r(Rb)W", false },
	{ HPPA_INS_LCI, "r(RR)W", false },
	{ HPPA_INS_PDTLB, "r(Rb)", false },
	{ HPPA_INS_PITLB, "r(Rb)", false },
	{ HPPA_INS_PDTLBE, "r(Rb)", false },
	{ HPPA_INS_PITLBE, "r(Rb)", false },
	{ HPPA_INS_IDTLBA, "R(RR)", false },
	{ HPPA_INS_IITLBA, "R(RR)", false },
	{ HPPA_INS_IDTLBP, "R(RR)", false },
	{ HPPA_INS_IITLBP, "R(RR)", false },
	{ HPPA_INS_PDC, "r(Rb)", false },
	{ HPPA_INS_FDC, "x(Rb)", false },
	{ HPPA_INS_FIC, "r(Rb)", false },
	{ HPPA_INS_FDCE, "r(Rb)", false },
	{ HPPA_INS_FICE, "r(Rb)", false },
	{ HPPA_INS_DIAG, "i", false },
	{ HPPA_INS_IDTLBT, "RR", false },
	{ HPPA_INS_IITLBT, "RR", false },

	{ HPPA_INS_FLDW, "x(Rb)W", false },
	{ HPPA_INS_FLDD, "x(Rb)W", false },
	{ HPPA_INS_FSTW, "Rx(Rb)", false },
	{ HPPA_INS_FSTD, "Rx(Rb)", false },
	{ HPPA_INS_FLDWX, "r(Rb)W", false },
	{ HPPA_INS_FLDDX, "r(Rb)W", false },
	{ HPPA_INS_FSTWX, "Rr(Rb)", false },
	{ HPPA_INS_FSTDX, "Rr(Rb)", false },
	{ HPPA_INS_FSTQX, "", false },
	{ HPPA_INS_FLDWS, "o(Rb)W", false },
	{ HPPA_INS_FLDDS, "o(Rb)W", false },
	{ HPPA_INS_FSTWS, "Ro(Rb)", false },
	{ HPPA_INS_FSTDS, "Ro(Rb)", false },
	{ HPPA_INS_FSTQS, "Ro(Rb)", false },
	{ HPPA_INS_FADD, "RRW", false },
	{ HPPA_INS_FSUB, "RRW", false },
	{ HPPA_INS_FMPY, "RRW", false },
	{ HPPA_INS_FDIV, "RRW", false },
	{ HPPA_INS_FSQRT, "RW", false },
	{ HPPA_INS_FABS, "RW", false },
	{ HPPA_INS_FREM, "", false },
	{ HPPA_INS_FRND, "RW", false },
	{ HPPA_INS_FCPY, "RW", false },
	{ HPPA_INS_FCNVFF, "RW", false },
	{ HPPA_INS_FCNVXF, "RW", false },
	{ HPPA_INS_FCNVFX, "RW", false },
	{ HPPA_INS_FCNVFXT, "RW", false },
	{ HPPA_INS_FMPYFADD, "RRRW", false },
	{ HPPA_INS_FMPYNFADD, "RRRW", false },
	{ HPPA_INS_FNEG, "RW", false },
	{ HPPA_INS_FNEGABS, "RW", false },
	{ HPPA_INS_FCNV, "RW", false },
	{ HPPA_INS_FCMP, "RR", false },
	{ HPPA_INS_FCMP, "RRi", true },
	{ HPPA_INS_XMPYU, "RRW", false },
	{ HPPA_INS_FMPYADD, "RRWRw", false },
	{ HPPA_INS_FMPYSUB, "RRWRw", false },
	{ HPPA_INS_FTEST, "", false },
	{ HPPA_INS_FTEST, "i", true },
	{ HPPA_INS_FID, "", false },

	{ HPPA_INS_PMDIS, "", false },
	{ HPPA_INS_PMENB, "", false },

	{ HPPA_INS_SPOP0, "", false },
	{ HPPA_INS_SPOP1, "W", false },
	{ HPPA_INS_SPOP2, "R", false },
	{ HPPA_INS_SPOP3, "RR", false },
	{ HPPA_INS_COPR, "", false },
	{ HPPA_INS_CLDW, "x(Rb)W", false },
	{ HPPA_INS_CLDD, "o(Rb)W", false },
	{ HPPA_INS_CSTW, "Rx(Rb)", false },
	{ HPPA_INS_CSTD, "Rx(Rb)", false },
	{ HPPA_INS_CLDWX, "r(Rb)W", false },
	{ HPPA_INS_CLDDX, "r(Rb)W", false },
	{ HPPA_INS_CSTWX, "Rr(Rb)", false },
	{ HPPA_INS_CSTDX, "Rr(Rb)", false },
	{ HPPA_INS_CLDWS, "o(Rb)W", false },
	{ HPPA_INS_CLDDS, "o(Rb)W", false },
	{ HPPA_INS_CSTWS, "Ro(Rb)", false },
	{ HPPA_INS_CSTDS, "Ro(Rb)", false },

	{ HPPA_INS_CALL, "", false },
	{ HPPA_INS_RET, "", false },
};

static void print_operand(MCInst *MI, SStream *O, const cs_hppa_op *op)
{
	switch (op->type) {
	case HPPA_OP_INVALID:
		SStream_concat(O, "invalid");
		break;
	case HPPA_OP_REG:
		SStream_concat(O, HPPA_reg_name((csh)MI->csh, op->reg));
		break;
	case HPPA_OP_IMM:
		printInt32(O, op->imm);
		break;
	case HPPA_OP_DISP:
		printInt32(O, op->imm);
		break;
	case HPPA_OP_IDX_REG:
		SStream_concat(O, HPPA_reg_name((csh)MI->csh, op->reg));
		break;
	case HPPA_OP_MEM:
		SStream_concat(O, "(");
		if (op->mem.space != HPPA_REG_INVALID &&
		    op->mem.space != HPPA_REG_SR0) {
			SStream_concat(O, HPPA_reg_name((csh)MI->csh,
							op->mem.space));
			SStream_concat(O, ",");
		}
		SStream_concat(O, HPPA_reg_name((csh)MI->csh, op->mem.base));
		SStream_concat(O, ")");
		break;
	case HPPA_OP_TARGET:
		printUInt64(O, MI->address + op->imm);
		break;
	}
}

#define NUMFMTS ARR_SIZE(pa_formats)

static void fill_operands(MCInst *MI, cs_hppa *hppa)
{
	hppa->op_count = 0;
	unsigned mc_op_count = MCInst_getNumOperands(MI);
	if (mc_op_count == 0)
		return;

	hppa_ext *hppa_ext = &MI->hppa_ext;
	uint32_t opcode = MCInst_getOpcode(MI);

	for (int i = 0; i < NUMFMTS; ++i) {
		const struct pa_insn_fmt *pa_fmt = &pa_formats[i];
		if (opcode != pa_fmt->insn_id ||
		    hppa_ext->is_alternative != pa_fmt->is_alternative) {
			continue;
		}
		const char *fmt = pa_fmt->format;
		uint8_t idx = 0;
		uint32_t space_regs[2] = { HPPA_REG_INVALID, HPPA_REG_INVALID };
		uint8_t space_reg_idx = 0;
		cs_ac_type base_access = CS_AC_INVALID;
		MCOperand *op = NULL;
		while (*fmt) {
			op = MCInst_getOperand(MI, idx++);
			switch (*fmt++) {
			case 'i':
				if (MCOperand_isReg(op)) {
					set_op_reg(hppa, MCOperand_getReg(op),
						   CS_AC_READ);
				} else {
					set_op_imm(hppa, MCOperand_getImm(op));
				}
				break;
			case 'o':
				set_op_disp(hppa, MCOperand_getImm(op));
				break;

			case 'R':
				set_op_reg(hppa, MCOperand_getReg(op),
					   CS_AC_READ);
				break;

			case 'W':
				set_op_reg(hppa, MCOperand_getReg(op),
					   CS_AC_WRITE);
				break;

			case 'w':
				set_op_reg(hppa, MCOperand_getReg(op),
					   CS_AC_READ_WRITE);
				break;

			case 'r':
				set_op_idx_reg(hppa, MCOperand_getReg(op));
				break;

			case 'T':
				set_op_target(hppa, MCOperand_getImm(op) + 8);
				break;

			case 'x':
				if (MCOperand_isReg(op)) {
					set_op_idx_reg(hppa,
						       MCOperand_getReg(op));
				} else {
					set_op_disp(hppa, MCOperand_getImm(op));
				}
				break;

			case '(':
				while (*fmt != ')') {
					if (space_reg_idx > 0) {
						op = MCInst_getOperand(MI,
								       idx++);
					}
					assert(space_reg_idx <
					       ARR_SIZE(space_regs));
					space_regs[space_reg_idx] =
						MCOperand_getReg(op);
					if (*fmt == 'R') {
						base_access = CS_AC_READ;
					} else if (*fmt == 'W') {
						base_access = CS_AC_WRITE;
					} else if (*fmt == 'b') {
						base_access = CS_AC_READ;
						if (hppa_ext->b_writeble)
							base_access |=
								CS_AC_WRITE;
					}
					fmt++;
					space_reg_idx++;
				}

				if (space_regs[1] == HPPA_REG_INVALID)
					set_op_mem(hppa, space_regs[0],
						   space_regs[1], base_access);
				else
					set_op_mem(hppa, space_regs[1],
						   space_regs[0], base_access);
				fmt++;
				break;

			default:
				printf("Unknown: %c\n", *(fmt - 1));
				break;
			}
		}
		break;
	}
}

static void print_modifiers(MCInst *MI, SStream *O)
{
	hppa_ext *hppa_ext = &MI->hppa_ext;
	for (uint8_t i = 0; i < hppa_ext->mod_num; ++i) {
		SStream_concat(O, ",");
		if (hppa_ext->modifiers[i].type == HPPA_MOD_STR)
			SStream_concat(O, hppa_ext->modifiers[i].str_mod);
		else
			SStream_concat(O, "%d", hppa_ext->modifiers[i].int_mod);
	}
}

static void add_groups(MCInst *MI)
{
	unsigned int opcode = MCInst_getOpcode(MI);
	for (unsigned i = 0; i < ARR_SIZE(pa_insns); ++i) {
		if (pa_insns[i].insn != opcode) {
			continue;
		}
		add_group(MI, pa_insns[i].grp);
	}
}

#ifndef CAPSTONE_DIET
static void update_regs_access(MCInst *MI, unsigned int opcode)
{
	if (opcode == HPPA_INS_INVALID)
		return;

	hppa_ext *hppa_ext = &MI->hppa_ext;
	switch (opcode) {
	default:
		break;
	case HPPA_INS_BLE:
		map_add_implicit_write(MI, HPPA_REG_GR31);
		map_add_implicit_write(MI, HPPA_REG_SR0);
		break;
	case HPPA_INS_BVB:
		map_add_implicit_read(MI, HPPA_REG_CR11);
		break;
	case HPPA_INS_RFI:
		if (hppa_ext->mod_num == 0) {
			break;
		}
		// fallthrough
	case HPPA_INS_RFIR:
		map_add_implicit_write(MI, HPPA_REG_GR1);
		map_add_implicit_write(MI, HPPA_REG_GR8);
		map_add_implicit_write(MI, HPPA_REG_GR9);
		map_add_implicit_write(MI, HPPA_REG_GR16);
		map_add_implicit_write(MI, HPPA_REG_GR17);
		map_add_implicit_write(MI, HPPA_REG_GR24);
		map_add_implicit_write(MI, HPPA_REG_GR25);
		break;
	case HPPA_INS_VDEP:
	case HPPA_INS_VDEPI:
	case HPPA_INS_VEXTRS:
	case HPPA_INS_VEXTRU:
	case HPPA_INS_VSHD:
	case HPPA_INS_ZVDEPI:
		map_add_implicit_read(MI, HPPA_REG_CR11);
		break;
	case HPPA_INS_ADDIL:
		map_add_implicit_write(MI, HPPA_REG_GR1);
		break;
	}
}
#endif

void HPPA_printInst(MCInst *MI, SStream *O, void *Info)
{
	cs_hppa hppa;

	/* set pubOpcode as instruction id */
	MCInst_setOpcodePub(MI, MCInst_getOpcode(MI));

	SStream_concat(O, HPPA_insn_name((csh)MI->csh, MCInst_getOpcode(MI)));
	print_modifiers(MI, O);
	SStream_concat(O, " ");
	fill_operands(MI, &hppa);
	for (int i = 0; i < hppa.op_count; i++) {
		cs_hppa_op *op = &hppa.operands[i];
		print_operand(MI, O, op);
		if (op->type != HPPA_OP_IDX_REG && op->type != HPPA_OP_DISP &&
		    i != hppa.op_count - 1) {
			SStream_concat(O, ",");
		}
	}

	if (detail_is_set(MI)) {
		cs_hppa *hppa_detail = HPPA_get_detail(MI);
		*hppa_detail = hppa;
		add_groups(MI);
#ifndef CAPSTONE_DIET
		update_regs_access(MI, MCInst_getOpcode(MI));
#endif
	}
}

#endif
