hexcore-capstone 1.2.0

package/deps/capstone/arch/SH/SHDisassembler.h

@@ -0,0 +1,19 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifndef CS_SHDISASSEMBLER_H
+#define CS_SHDISASSEMBLER_H
+
+#include "../../MCInst.h"
+
+typedef struct sh_info {
+	cs_sh op;
+} sh_info;
+
+bool SH_getInstruction(csh ud, const uint8_t *code, size_t code_len,
+		MCInst *instr, uint16_t *size, uint64_t address, void *info);
+
+void SH_reg_access(const cs_insn *insn,
+		   cs_regs regs_read, uint8_t *regs_read_count,
+		   cs_regs regs_write, uint8_t *regs_write_count);
+#endif

package/deps/capstone/arch/SH/SHInsnTable.inc

@@ -0,0 +1,66 @@
+bool (*decode[])(uint16_t code, uint64_t address, MCInst *MI, cs_mode mode, sh_info *info, cs_detail *detail) = {
+	/// 00000000
+	NULL, NULL, opSTC, op0xx3, opMOV_B, opMOV_W, opMOV_L, opMUL_L, 
+	/// 00001000
+	op0xx8, op0xx9, op0xxa, op0xxb, opMOV_B, opMOV_W, opMOV_L, opMAC_L, 
+	/// 00010000
+	opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, 
+	/// 00011000
+	opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, 
+	/// 00100000
+	opMOV_rind, opMOV_rind, opMOV_rind, NULL, opMOV_rpd, opMOV_rpd, opMOV_rpd, opDIV0S, 
+	/// 00101000
+	opTST, opAND, opXOR, opOR, opCMP_STR, opXTRCT, opMULU_W, opMULS_W, 
+	/// 00110000
+	opCMP_EQ, NULL, opCMP_HS, opCMP_GE, opDIV1, opDMULU_L, opCMP_HI, opCMP_GT, 
+	/// 00111000
+	opSUB, NULL, opSUBC, opSUBV, opADD_r, opDMULS_L, opADDC, opADDV, 
+	/// 01000000
+	op4xx0, op4xx1, op4xx2, opSTC_L, op4xx4, op4xx5, op4xx6, opLDC_L, 
+	/// 01001000
+	op4xx8, op4xx9, op4xxa, op4xxb, opSHAD, opSHLD, opLDC, opMAC_W, 
+	/// 01010000
+	opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, 
+	/// 01011000
+	opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, opMOV_L_dsp, 
+	/// 01100000
+	opMOV_rind, opMOV_rind, opMOV_rind, opMOV, opMOV_rpi, opMOV_rpi, opMOV_rpi, opNOT, 
+	/// 01101000
+	opSWAP_B, opSWAP_W, opNEGC, opNEG, opEXTU_B, opEXTU_W, opEXTS_B, opEXTS_W, 
+	/// 01110000
+	opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, 
+	/// 01111000
+	opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, opADD_i, 
+	/// 10000000
+	opMOV_BW_dsp, opMOV_BW_dsp, opSETRC, opJSR_N, opMOV_BW_dsp, opMOV_BW_dsp, op86xx, op87xx, 
+	/// 10001000
+	opCMP_EQi, opBT, opLDRC, opBF, opLDRS, opBT_S, opLDRE, opBF_S, 
+	/// 10010000
+	opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, 
+	/// 10011000
+	opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, 
+	/// 10100000
+	opBRA, opBRA, opBRA, opBRA, opBRA, opBRA, opBRA, opBRA, 
+	/// 10101000
+	opBRA, opBRA, opBRA, opBRA, opBRA, opBRA, opBRA, opBRA, 
+	/// 10110000
+	opBSR, opBSR, opBSR, opBSR, opBSR, opBSR, opBSR, opBSR, 
+	/// 10111000
+	opBSR, opBSR, opBSR, opBSR, opBSR, opBSR, opBSR, opBSR, 
+	/// 11000000
+	opMOV_gbr, opMOV_gbr, opMOV_gbr, opTRAPA, opMOV_gbr, opMOV_gbr, opMOV_gbr, opMOVA, 
+	/// 11001000
+	opTST_i, opAND_i, opXOR_i, opOR_i, opTST_B, opAND_B, opXOR_B, opOR_B, 
+	/// 11010000
+	opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, 
+	/// 11011000
+	opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, opMOV_pc, 
+	/// 11100000
+	opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, 
+	/// 11101000
+	opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, opMOV_i, 
+	/// 11110000
+	opFADD, opFSUB, opFMUL, opFDIV, opFCMP_EQ, opFCMP_GT, opfxx6, opfxx7, 
+	/// 11111000
+	opfxx8, opfxx9, opfxxa, opfxxb, opFMOV, opfxxd, opFMAC, NULL, 
+};

package/deps/capstone/arch/SH/SHInstPrinter.c

@@ -0,0 +1,438 @@
+/* Capstone Disassembly Engine */
+/* By Yoshinori Sato, 2022 */
+
+#include <string.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[] = {
+	"unknwon",
+	"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
+}
+

package/deps/capstone/arch/SH/SHInstPrinter.h

@@ -0,0 +1,23 @@
+/* Capstone Disassembly Engine */
+/* By Yoshinori Sato, 2022 */
+
+#ifndef CS_SHINSTPRINTER_H
+#define CS_SHINSTPRINTER_H
+
+
+#include "capstone/capstone.h"
+#include "../../utils.h"
+#include "../../MCInst.h"
+#include "../../SStream.h"
+#include "../../cs_priv.h"
+#include "SHDisassembler.h"
+
+struct SStream;
+
+void SH_printInst(MCInst *MI, struct SStream *O, void *Info);
+const char* SH_reg_name(csh handle, unsigned int reg);
+void SH_get_insn_id(cs_struct* h, cs_insn* insn, unsigned int id);
+const char* SH_insn_name(csh handle, unsigned int id);
+const char *SH_group_name(csh handle, unsigned int id);
+
+#endif

package/deps/capstone/arch/SH/SHModule.c

@@ -0,0 +1,39 @@
+/* Capstone Disassembly Engine */
+/* By Yoshinori Sato 2022 */
+
+#ifdef CAPSTONE_HAS_SH
+
+#include "../../cs_priv.h"
+#include "SHDisassembler.h"
+#include "SHInstPrinter.h"
+#include "SHModule.h"
+
+cs_err SH_global_init(cs_struct *ud)
+{
+	sh_info *info;
+
+	info = cs_mem_malloc(sizeof(sh_info));
+	if (!info) {
+		return CS_ERR_MEM;
+	}
+
+	ud->printer = SH_printInst;
+	ud->printer_info = info;
+	ud->reg_name = SH_reg_name;
+	ud->insn_id = SH_get_insn_id;
+	ud->insn_name = SH_insn_name;
+	ud->group_name = SH_group_name;
+	ud->disasm = SH_getInstruction;
+#ifndef CAPSTONE_DIET
+        ud->reg_access = SH_reg_access;
+#endif
+
+	return CS_ERR_OK;
+}
+
+cs_err SH_option(cs_struct *handle, cs_opt_type type, size_t value)
+{
+	return CS_ERR_OK;
+}
+
+#endif

package/deps/capstone/arch/SH/SHModule.h

@@ -0,0 +1,12 @@
+/* Capstone Disassembly Engine */
+/* By Yoshinori Sato, 2022 */
+
+#ifndef CS_SH_MODULE_H
+#define CS_SH_MODULE_H
+
+#include "../../utils.h"
+
+cs_err SH_global_init(cs_struct *ud);
+cs_err SH_option(cs_struct *handle, cs_opt_type type, size_t value);
+
+#endif