/src/capstonenext/arch/MOS65XX/MOS65XXDisassembler.c

Source
/* Capstone Disassembly Engine */
/* MOS65XX Backend by Sebastian Macke <sebastian@macke.de> 2018 */

#include "capstone/mos65xx.h"
#include "MOS65XXDisassembler.h"
#include "MOS65XXDisassemblerInternals.h"

typedef struct OpInfo {
  mos65xx_insn ins;
  mos65xx_address_mode am;
  int operand_bytes;
} OpInfo;

static const struct OpInfo OpInfoTable[] = {

#include "m6502.inc"
#include "m65c02.inc"
#include "mw65c02.inc"
#include "m65816.inc"

};

#ifndef CAPSTONE_DIET
static const char *const RegNames[] = { "invalid", "A",  "X", "Y", "P",
          "SP",    "DP", "B", "K" };

static const char *const GroupNames[] = {
  NULL, "jump", "call", "ret", "int", "iret", "branch_relative"
};

typedef struct InstructionInfo {
  const char *name;
  mos65xx_group_type group_type;
  mos65xx_reg write, read;
  bool modifies_status;
} InstructionInfo;

static const struct InstructionInfo InstructionInfoTable[] = {

#include "instruction_info.inc"

};
#endif

#ifndef CAPSTONE_DIET
static void fillDetails(MCInst *MI, struct OpInfo opinfo, int cpu_type)
{
  int i;
  cs_detail *detail = MI->flat_insn->detail;

  InstructionInfo insinfo = InstructionInfoTable[opinfo.ins];

  detail->mos65xx.am = opinfo.am;
  detail->mos65xx.modifies_flags = insinfo.modifies_status;
  detail->groups_count = 0;
  detail->regs_read_count = 0;
  detail->regs_write_count = 0;
  detail->mos65xx.op_count = 0;

  if (insinfo.group_type != MOS65XX_GRP_INVALID) {
    detail->groups[detail->groups_count] = insinfo.group_type;
    detail->groups_count++;
  }

  if (opinfo.am == MOS65XX_AM_REL || opinfo.am == MOS65XX_AM_ZP_REL) {
    detail->groups[detail->groups_count] =
      MOS65XX_GRP_BRANCH_RELATIVE;
    detail->groups_count++;
  }

  if (insinfo.read != MOS65XX_REG_INVALID) {
    detail->regs_read[detail->regs_read_count++] = insinfo.read;
  } else
    switch (opinfo.am) {
    case MOS65XX_AM_ACC:
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_ACC;
      break;
    case MOS65XX_AM_ZP_Y:
    case MOS65XX_AM_ZP_IND_Y:
    case MOS65XX_AM_ABS_Y:
    case MOS65XX_AM_ZP_IND_LONG_Y:
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_Y;
      break;

    case MOS65XX_AM_ZP_X:
    case MOS65XX_AM_ZP_X_IND:
    case MOS65XX_AM_ABS_X:
    case MOS65XX_AM_ABS_X_IND:
    case MOS65XX_AM_ABS_LONG_X:
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_X;
      break;

    case MOS65XX_AM_SR:
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_SP;
      break;
    case MOS65XX_AM_SR_IND_Y:
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_SP;
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_Y;
      break;

    default:
      break;
    }

  if (insinfo.write != MOS65XX_REG_INVALID) {
    detail->regs_write[detail->regs_write_count++] = insinfo.write;
  } else if (opinfo.am == MOS65XX_AM_ACC) {
    detail->regs_write[detail->regs_write_count++] =
      MOS65XX_REG_ACC;
  }

  switch (opinfo.ins) {
  case MOS65XX_INS_ADC:
  case MOS65XX_INS_SBC:
  case MOS65XX_INS_ROL:
  case MOS65XX_INS_ROR:
    /* these read carry flag (and decimal for ADC/SBC) */
    detail->regs_read[detail->regs_read_count++] = MOS65XX_REG_P;
    break;
  /* stack operations */
  case MOS65XX_INS_JSL:
  case MOS65XX_INS_JSR:
  case MOS65XX_INS_PEA:
  case MOS65XX_INS_PEI:
  case MOS65XX_INS_PER:
  case MOS65XX_INS_PHA:
  case MOS65XX_INS_PHB:
  case MOS65XX_INS_PHD:
  case MOS65XX_INS_PHK:
  case MOS65XX_INS_PHP:
  case MOS65XX_INS_PHX:
  case MOS65XX_INS_PHY:
  case MOS65XX_INS_PLA:
  case MOS65XX_INS_PLB:
  case MOS65XX_INS_PLD:
  case MOS65XX_INS_PLP:
  case MOS65XX_INS_PLX:
  case MOS65XX_INS_PLY:
  case MOS65XX_INS_RTI:
  case MOS65XX_INS_RTL:
  case MOS65XX_INS_RTS:
    detail->regs_read[detail->regs_read_count++] = MOS65XX_REG_SP;
    detail->regs_write[detail->regs_write_count++] = MOS65XX_REG_SP;
    break;
  default:
    break;
  }

  if (cpu_type == MOS65XX_CPU_TYPE_65816) {
    switch (opinfo.am) {
    case MOS65XX_AM_ZP:
    case MOS65XX_AM_ZP_X:
    case MOS65XX_AM_ZP_Y:
    case MOS65XX_AM_ZP_IND:
    case MOS65XX_AM_ZP_X_IND:
    case MOS65XX_AM_ZP_IND_Y:
    case MOS65XX_AM_ZP_IND_LONG:
    case MOS65XX_AM_ZP_IND_LONG_Y:
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_DP;
      break;
    case MOS65XX_AM_BLOCK:
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_ACC;
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_X;
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_Y;
      detail->regs_write[detail->regs_write_count++] =
        MOS65XX_REG_ACC;
      detail->regs_write[detail->regs_write_count++] =
        MOS65XX_REG_X;
      detail->regs_write[detail->regs_write_count++] =
        MOS65XX_REG_Y;
      detail->regs_write[detail->regs_write_count++] =
        MOS65XX_REG_B;
      break;
    default:
      break;
    }

    switch (opinfo.am) {
    case MOS65XX_AM_ZP_IND:
    case MOS65XX_AM_ZP_X_IND:
    case MOS65XX_AM_ZP_IND_Y:
    case MOS65XX_AM_ABS:
    case MOS65XX_AM_ABS_X:
    case MOS65XX_AM_ABS_Y:
    case MOS65XX_AM_ABS_X_IND:
      /* these depend on the databank to generate a 24-bit address */
      /* exceptions: PEA, PEI, and JMP (abs) */
      if (opinfo.ins == MOS65XX_INS_PEI ||
          opinfo.ins == MOS65XX_INS_PEA)
        break;
      detail->regs_read[detail->regs_read_count++] =
        MOS65XX_REG_B;
      break;
    default:
      break;
    }
  }

  if (insinfo.modifies_status) {
    detail->regs_write[detail->regs_write_count++] = MOS65XX_REG_P;
  }

  switch (opinfo.am) {
  case MOS65XX_AM_IMP:
    break;
  case MOS65XX_AM_IMM:
    detail->mos65xx.operands[detail->mos65xx.op_count].type =
      MOS65XX_OP_IMM;
    detail->mos65xx.operands[detail->mos65xx.op_count].imm =
      MI->Operands[0].ImmVal;
    detail->mos65xx.op_count++;
    break;
  case MOS65XX_AM_ACC:
    detail->mos65xx.operands[detail->mos65xx.op_count].type =
      MOS65XX_OP_REG;
    detail->mos65xx.operands[detail->mos65xx.op_count].reg =
      MOS65XX_REG_ACC;
    detail->mos65xx.op_count++;
    break;
  case MOS65XX_AM_REL: {
    int value = MI->Operands[0].ImmVal;
    if (MI->op1_size == 1)
      value = 2 + (signed char)value;
    else
      value = 3 + (signed short)value;
    detail->mos65xx.operands[detail->mos65xx.op_count].type =
      MOS65XX_OP_MEM;
    detail->mos65xx.operands[detail->mos65xx.op_count].mem =
      (MI->address + value) & 0xffff;
    detail->mos65xx.op_count++;
    break;
  }
  case MOS65XX_AM_ZP_REL: {
    int value = 3 + (signed char)MI->Operands[1].ImmVal;
    /* BBR0, zp, rel  and BBS0, zp, rel */
    detail->mos65xx.operands[detail->mos65xx.op_count].type =
      MOS65XX_OP_MEM;
    detail->mos65xx.operands[detail->mos65xx.op_count].mem =
      MI->Operands[0].ImmVal;
    detail->mos65xx.operands[detail->mos65xx.op_count + 1].type =
      MOS65XX_OP_MEM;
    detail->mos65xx.operands[detail->mos65xx.op_count + 1].mem =
      (MI->address + value) & 0xffff;
    detail->mos65xx.op_count += 2;
    break;
  }
  default:
    for (i = 0; i < MI->size; ++i) {
      detail->mos65xx.operands[detail->mos65xx.op_count].type =
        MOS65XX_OP_MEM;
      detail->mos65xx.operands[detail->mos65xx.op_count].mem =
        MI->Operands[i].ImmVal;
      detail->mos65xx.op_count++;
    }
    break;
  }
}
#endif

void MOS65XX_printInst(MCInst *MI, struct SStream *O, void *PrinterInfo)
{
#ifndef CAPSTONE_DIET
  unsigned int value;
  unsigned opcode = MCInst_getOpcode(MI);
  mos65xx_info *info = (mos65xx_info *)PrinterInfo;

  OpInfo opinfo = OpInfoTable[opcode];

  const char *prefix = info->hex_prefix ? info->hex_prefix : "0x";

  SStream_concat0(O, InstructionInfoTable[opinfo.ins].name);
  switch (opinfo.ins) {
  /* special case - bit included as part of the instruction name */
  case MOS65XX_INS_BBR:
  case MOS65XX_INS_BBS:
  case MOS65XX_INS_RMB:
  case MOS65XX_INS_SMB:
    SStream_concat(O, "%" PRId8, (opcode >> 4) & 0x07);
    break;
  default:
    break;
  }

  value = MI->Operands[0].ImmVal;

  switch (opinfo.am) {
  default:
    break;

  case MOS65XX_AM_IMP:
    break;

  case MOS65XX_AM_ACC:
    SStream_concat0(O, " a");
    break;

  case MOS65XX_AM_IMM:
    if (MI->imm_size == 1)
      SStream_concat(O, " #%s%02" PRIx32, prefix, value);
    else
      SStream_concat(O, " #%s%04" PRIx32, prefix, value);
    break;

  case MOS65XX_AM_ZP:
    SStream_concat(O, " %s%02" PRIx32, prefix, value);
    break;

  case MOS65XX_AM_ABS:
    SStream_concat(O, " %s%04" PRIx32, prefix, value);
    break;

  case MOS65XX_AM_ABS_LONG_X:
    SStream_concat(O, " %s%06" PRIx32 ", x", prefix, value);
    break;

  case MOS65XX_AM_INT:
    SStream_concat(O, " %s%02" PRIx32, prefix, value);
    break;

  case MOS65XX_AM_ABS_X:
    SStream_concat(O, " %s%04" PRIx32 ", x", prefix, value);
    break;

  case MOS65XX_AM_ABS_Y:
    SStream_concat(O, " %s%04" PRIx32 ", y", prefix, value);
    break;

  case MOS65XX_AM_ABS_LONG:
    SStream_concat(O, " %s%06" PRIx32, prefix, value);
    break;

  case MOS65XX_AM_ZP_X:
    SStream_concat(O, " %s%02" PRIx32 ", x", prefix, value);
    break;

  case MOS65XX_AM_ZP_Y:
    SStream_concat(O, " %s%02" PRIx32 ", y", prefix, value);
    break;

  case MOS65XX_AM_REL: {
    if (MI->op1_size == 1)
      value = 2 + (int8_t)value;
    else
      value = 3 + (int16_t)value;

    uint32_t addr = MI->address;
    SStream_concat(O, " %s%04" PRIx16, prefix,
             (addr + value) & 0xffff);

    break;
  }
  case MOS65XX_AM_ABS_IND:
    SStream_concat(O, " (%s%04" PRIx32 ")", prefix, value);
    break;

  case MOS65XX_AM_ABS_X_IND:
    SStream_concat(O, " (%s%04" PRIx32 ", x)", prefix, value);
    break;

  case MOS65XX_AM_ABS_IND_LONG:
    SStream_concat(O, " [%s%04" PRIx32 "]", prefix, value);
    break;

  case MOS65XX_AM_ZP_IND:
    SStream_concat(O, " (%s%02" PRIx32 ")", prefix, value);
    break;

  case MOS65XX_AM_ZP_X_IND:
    SStream_concat(O, " (%s%02" PRIx32 ", x)", prefix, value);
    break;

  case MOS65XX_AM_ZP_IND_Y:
    SStream_concat(O, " (%s%02" PRIx32 "), y", prefix, value);
    break;

  case MOS65XX_AM_ZP_IND_LONG:
    SStream_concat(O, " [%s%02" PRIx32 "]", prefix, value);
    break;

  case MOS65XX_AM_ZP_IND_LONG_Y:
    SStream_concat(O, " [%s%02" PRIx32 "], y", prefix, value);
    break;

  case MOS65XX_AM_SR:
    SStream_concat(O, " %s%02" PRIx32 ", s", prefix, value);
    break;

  case MOS65XX_AM_SR_IND_Y:
    SStream_concat(O, " (%s%02" PRIx32 ", s), y", prefix, value);
    break;

  case MOS65XX_AM_BLOCK:
    SStream_concat(O, " %s%02" PRIx32 ", %s%02" PRIx32, prefix,
             (uint32_t)MI->Operands[0].ImmVal, prefix,
             (uint32_t)MI->Operands[1].ImmVal);
    break;

  case MOS65XX_AM_ZP_REL: {
    value = 3 + (int8_t)MI->Operands[1].ImmVal;
    uint32_t addr = MI->address;
    uint32_t target = (addr + value) & 0xffff;
    /* BBR0, zp, rel  and BBS0, zp, rel */
    SStream_concat(O, " %s%02" PRIx32 ", %s%04" PRIx32, prefix,
             (uint32_t)MI->Operands[0].ImmVal, prefix,
             target);
    break;
  }
  }
#endif
}

bool MOS65XX_getInstruction(csh ud, const uint8_t *code, size_t code_len,
          MCInst *MI, uint16_t *size, uint64_t address,
          void *inst_info)
{
  int i;
  unsigned char opcode;
  unsigned char len;
  unsigned cpu_offset = 0;
  int cpu_type = MOS65XX_CPU_TYPE_6502;
  cs_struct *handle = MI->csh;
  mos65xx_info *info = (mos65xx_info *)handle->printer_info;
  OpInfo opinfo;

  if (code_len == 0) {
    *size = 1;
    return false;
  }

  cpu_type = info->cpu_type;
  cpu_offset = cpu_type * 256;

  opcode = code[0];
  opinfo = OpInfoTable[cpu_offset + opcode];
  if (opinfo.ins == MOS65XX_INS_INVALID) {
    *size = 1;
    return false;
  }

  len = opinfo.operand_bytes + 1;

  if (cpu_type == MOS65XX_CPU_TYPE_65816 && opinfo.am == MOS65XX_AM_IMM) {
    switch (opinfo.ins) {
    case MOS65XX_INS_CPX:
    case MOS65XX_INS_CPY:
    case MOS65XX_INS_LDX:
    case MOS65XX_INS_LDY:
      if (info->long_x)
        ++len;
      break;
    case MOS65XX_INS_ADC:
    case MOS65XX_INS_AND:
    case MOS65XX_INS_BIT:
    case MOS65XX_INS_CMP:
    case MOS65XX_INS_EOR:
    case MOS65XX_INS_LDA:
    case MOS65XX_INS_ORA:
    case MOS65XX_INS_SBC:
      if (info->long_m)
        ++len;
      break;
    default:
      break;
    }
  }

  if (code_len < len) {
    *size = 1;
    return false;
  }

  MI->address = address;

  MCInst_setOpcode(MI, cpu_offset + opcode);
  MCInst_setOpcodePub(MI, opinfo.ins);

  *size = len;

  /* needed to differentiate relative vs relative long */
  MI->op1_size = len - 1;
  if (opinfo.ins == MOS65XX_INS_NOP) {
    for (i = 1; i < len; ++i)
      MCOperand_CreateImm0(MI, code[i]);
  }

  switch (opinfo.am) {
  case MOS65XX_AM_ZP_REL:
    MCOperand_CreateImm0(MI, code[1]);
    MCOperand_CreateImm0(MI, code[2]);
    break;
  case MOS65XX_AM_BLOCK:
    MCOperand_CreateImm0(MI, code[2]);
    MCOperand_CreateImm0(MI, code[1]);
    break;
  case MOS65XX_AM_IMP:
  case MOS65XX_AM_ACC:
    break;

  case MOS65XX_AM_IMM:
    MI->has_imm = 1;
    MI->imm_size = len - 1;
    /* 65816 immediate is either 1 or 2 bytes */
    /* drop through */
  default:
    if (len == 2)
      MCOperand_CreateImm0(MI, code[1]);
    else if (len == 3)
      MCOperand_CreateImm0(MI, (code[2] << 8) | code[1]);
    else if (len == 4)
      MCOperand_CreateImm0(
        MI, (code[3] << 16) | (code[2] << 8) | code[1]);
    break;
  }

#ifndef CAPSTONE_DIET
  if (MI->flat_insn->detail) {
    fillDetails(MI, opinfo, cpu_type);
  }
#endif

  return true;
}

const char *MOS65XX_insn_name(csh handle, unsigned int id)
{
#ifdef CAPSTONE_DIET
  return NULL;
#else
  if (id >= ARR_SIZE(InstructionInfoTable)) {
    return NULL;
  }
  return InstructionInfoTable[id].name;
#endif
}

const char *MOS65XX_reg_name(csh handle, unsigned int reg)
{
#ifdef CAPSTONE_DIET
  return NULL;
#else
  if (reg >= ARR_SIZE(RegNames)) {
    return NULL;
  }
  return RegNames[(int)reg];
#endif
}

void MOS65XX_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)
{
  /* id is cpu_offset + opcode */
  if (id < ARR_SIZE(OpInfoTable)) {
    insn->id = OpInfoTable[id].ins;
  }
}

const char *MOS65XX_group_name(csh handle, unsigned int id)
{
#ifdef CAPSTONE_DIET
  return NULL;
#else
  if (id >= ARR_SIZE(GroupNames)) {
    return NULL;
  }
  return GroupNames[(int)id];
#endif
}

Coverage Report

Created: 2026-08-31 06:58

Line	Count	Source
1		/* Capstone Disassembly Engine */
2		/* MOS65XX Backend by Sebastian Macke <sebastian@macke.de> 2018 */
3
4		#include "capstone/mos65xx.h"
5		#include "MOS65XXDisassembler.h"
6		#include "MOS65XXDisassemblerInternals.h"
7
8		typedef struct OpInfo {
9		mos65xx_insn ins;
10		mos65xx_address_mode am;
11		int operand_bytes;
12		} OpInfo;
13
14		static const struct OpInfo OpInfoTable[] = {
15
16		#include "m6502.inc"
17		#include "m65c02.inc"
18		#include "mw65c02.inc"
19		#include "m65816.inc"
20
21		};
22
23		#ifndef CAPSTONE_DIET
24		static const char *const RegNames[] = { "invalid", "A", "X", "Y", "P",
25		"SP", "DP", "B", "K" };
26
27		static const char *const GroupNames[] = {
28		NULL, "jump", "call", "ret", "int", "iret", "branch_relative"
29		};
30
31		typedef struct InstructionInfo {
32		const char *name;
33		mos65xx_group_type group_type;
34		mos65xx_reg write, read;
35		bool modifies_status;
36		} InstructionInfo;
37
38		static const struct InstructionInfo InstructionInfoTable[] = {
39
40		#include "instruction_info.inc"
41
42		};
43		#endif
44
45		#ifndef CAPSTONE_DIET
46		static void fillDetails(MCInst *MI, struct OpInfo opinfo, int cpu_type)
47	16.3k	{
48	16.3k	int i;
49	16.3k	cs_detail *detail = MI->flat_insn->detail;
50
51	16.3k	InstructionInfo insinfo = InstructionInfoTable[opinfo.ins];
52
53	16.3k	detail->mos65xx.am = opinfo.am;
54	16.3k	detail->mos65xx.modifies_flags = insinfo.modifies_status;
55	16.3k	detail->groups_count = 0;
56	16.3k	detail->regs_read_count = 0;
57	16.3k	detail->regs_write_count = 0;
58	16.3k	detail->mos65xx.op_count = 0;
59
60	16.3k	if (insinfo.group_type != MOS65XX_GRP_INVALID) {
61	4.21k	detail->groups[detail->groups_count] = insinfo.group_type;
62	4.21k	detail->groups_count++;
63	4.21k	}
64
65	16.3k	if (opinfo.am == MOS65XX_AM_REL \|\| opinfo.am == MOS65XX_AM_ZP_REL) {
66	849	detail->groups[detail->groups_count] =
67	849	MOS65XX_GRP_BRANCH_RELATIVE;
68	849	detail->groups_count++;
69	849	}
70
71	16.3k	if (insinfo.read != MOS65XX_REG_INVALID) {
72	5.40k	detail->regs_read[detail->regs_read_count++] = insinfo.read;
73	5.40k	} else
74	10.9k	switch (opinfo.am) {
75	1.05k	case MOS65XX_AM_ACC:
76	1.05k	detail->regs_read[detail->regs_read_count++] =
77	1.05k	MOS65XX_REG_ACC;
78	1.05k	break;
79	579	case MOS65XX_AM_ZP_Y:
80	994	case MOS65XX_AM_ZP_IND_Y:
81	2.24k	case MOS65XX_AM_ABS_Y:
82	2.24k	case MOS65XX_AM_ZP_IND_LONG_Y:
83	2.24k	detail->regs_read[detail->regs_read_count++] =
84	2.24k	MOS65XX_REG_Y;
85	2.24k	break;
86
87	523	case MOS65XX_AM_ZP_X:
88	1.04k	case MOS65XX_AM_ZP_X_IND:
89	1.48k	case MOS65XX_AM_ABS_X:
90	1.48k	case MOS65XX_AM_ABS_X_IND:
91	1.48k	case MOS65XX_AM_ABS_LONG_X:
92	1.48k	detail->regs_read[detail->regs_read_count++] =
93	1.48k	MOS65XX_REG_X;
94	1.48k	break;
95
96	0	case MOS65XX_AM_SR:
97	0	detail->regs_read[detail->regs_read_count++] =
98	0	MOS65XX_REG_SP;
99	0	break;
100	0	case MOS65XX_AM_SR_IND_Y:
101	0	detail->regs_read[detail->regs_read_count++] =
102	0	MOS65XX_REG_SP;
103	0	detail->regs_read[detail->regs_read_count++] =
104	0	MOS65XX_REG_Y;
105	0	break;
106
107	6.17k	default:
108	6.17k	break;
109	10.9k	}
110
111	16.3k	if (insinfo.write != MOS65XX_REG_INVALID) {
112	6.79k	detail->regs_write[detail->regs_write_count++] = insinfo.write;
113	9.58k	} else if (opinfo.am == MOS65XX_AM_ACC) {
114	1.05k	detail->regs_write[detail->regs_write_count++] =
115	1.05k	MOS65XX_REG_ACC;
116	1.05k	}
117
118	16.3k	switch (opinfo.ins) {
119	583	case MOS65XX_INS_ADC:
120	1.42k	case MOS65XX_INS_SBC:
121	2.12k	case MOS65XX_INS_ROL:
122	2.75k	case MOS65XX_INS_ROR:
123		/* these read carry flag (and decimal for ADC/SBC) */
124	2.75k	detail->regs_read[detail->regs_read_count++] = MOS65XX_REG_P;
125	2.75k	break;
126		/* stack operations */
127	0	case MOS65XX_INS_JSL:
128	407	case MOS65XX_INS_JSR:
129	407	case MOS65XX_INS_PEA:
130	407	case MOS65XX_INS_PEI:
131	407	case MOS65XX_INS_PER:
132	938	case MOS65XX_INS_PHA:
133	938	case MOS65XX_INS_PHB:
134	938	case MOS65XX_INS_PHD:
135	938	case MOS65XX_INS_PHK:
136	1.37k	case MOS65XX_INS_PHP:
137	1.37k	case MOS65XX_INS_PHX:
138	1.37k	case MOS65XX_INS_PHY:
139	1.80k	case MOS65XX_INS_PLA:
140	1.80k	case MOS65XX_INS_PLB:
141	1.80k	case MOS65XX_INS_PLD:
142	2.30k	case MOS65XX_INS_PLP:
143	2.30k	case MOS65XX_INS_PLX:
144	2.30k	case MOS65XX_INS_PLY:
145	3.21k	case MOS65XX_INS_RTI:
146	3.21k	case MOS65XX_INS_RTL:
147	3.66k	case MOS65XX_INS_RTS:
148	3.66k	detail->regs_read[detail->regs_read_count++] = MOS65XX_REG_SP;
149	3.66k	detail->regs_write[detail->regs_write_count++] = MOS65XX_REG_SP;
150	3.66k	break;
151	9.95k	default:
152	9.95k	break;
153	16.3k	}
154
155	16.3k	if (cpu_type == MOS65XX_CPU_TYPE_65816) {
156	0	switch (opinfo.am) {
157	0	case MOS65XX_AM_ZP:
158	0	case MOS65XX_AM_ZP_X:
159	0	case MOS65XX_AM_ZP_Y:
160	0	case MOS65XX_AM_ZP_IND:
161	0	case MOS65XX_AM_ZP_X_IND:
162	0	case MOS65XX_AM_ZP_IND_Y:
163	0	case MOS65XX_AM_ZP_IND_LONG:
164	0	case MOS65XX_AM_ZP_IND_LONG_Y:
165	0	detail->regs_read[detail->regs_read_count++] =
166	0	MOS65XX_REG_DP;
167	0	break;
168	0	case MOS65XX_AM_BLOCK:
169	0	detail->regs_read[detail->regs_read_count++] =
170	0	MOS65XX_REG_ACC;
171	0	detail->regs_read[detail->regs_read_count++] =
172	0	MOS65XX_REG_X;
173	0	detail->regs_read[detail->regs_read_count++] =
174	0	MOS65XX_REG_Y;
175	0	detail->regs_write[detail->regs_write_count++] =
176	0	MOS65XX_REG_ACC;
177	0	detail->regs_write[detail->regs_write_count++] =
178	0	MOS65XX_REG_X;
179	0	detail->regs_write[detail->regs_write_count++] =
180	0	MOS65XX_REG_Y;
181	0	detail->regs_write[detail->regs_write_count++] =
182	0	MOS65XX_REG_B;
183	0	break;
184	0	default:
185	0	break;
186	0	}
187
188	0	switch (opinfo.am) {
189	0	case MOS65XX_AM_ZP_IND:
190	0	case MOS65XX_AM_ZP_X_IND:
191	0	case MOS65XX_AM_ZP_IND_Y:
192	0	case MOS65XX_AM_ABS:
193	0	case MOS65XX_AM_ABS_X:
194	0	case MOS65XX_AM_ABS_Y:
195	0	case MOS65XX_AM_ABS_X_IND:
196		/* these depend on the databank to generate a 24-bit address */
197		/* exceptions: PEA, PEI, and JMP (abs) */
198	0	if (opinfo.ins == MOS65XX_INS_PEI \|\|
199	0	opinfo.ins == MOS65XX_INS_PEA)
200	0	break;
201	0	detail->regs_read[detail->regs_read_count++] =
202	0	MOS65XX_REG_B;
203	0	break;
204	0	default:
205	0	break;
206	0	}
207	0	}
208
209	16.3k	if (insinfo.modifies_status) {
210	11.0k	detail->regs_write[detail->regs_write_count++] = MOS65XX_REG_P;
211	11.0k	}
212
213	16.3k	switch (opinfo.am) {
214	4.19k	case MOS65XX_AM_IMP:
215	4.19k	break;
216	933	case MOS65XX_AM_IMM:
217	933	detail->mos65xx.operands[detail->mos65xx.op_count].type =
218	933	MOS65XX_OP_IMM;
219	933	detail->mos65xx.operands[detail->mos65xx.op_count].imm =
220	933	MI->Operands[0].ImmVal;
221	933	detail->mos65xx.op_count++;
222	933	break;
223	1.05k	case MOS65XX_AM_ACC:
224	1.05k	detail->mos65xx.operands[detail->mos65xx.op_count].type =
225	1.05k	MOS65XX_OP_REG;
226	1.05k	detail->mos65xx.operands[detail->mos65xx.op_count].reg =
227	1.05k	MOS65XX_REG_ACC;
228	1.05k	detail->mos65xx.op_count++;
229	1.05k	break;
230	849	case MOS65XX_AM_REL: {
231	849	int value = MI->Operands[0].ImmVal;
232	849	if (MI->op1_size == 1)
233	849	value = 2 + (signed char)value;
234	0	else
235	0	value = 3 + (signed short)value;
236	849	detail->mos65xx.operands[detail->mos65xx.op_count].type =
237	849	MOS65XX_OP_MEM;
238	849	detail->mos65xx.operands[detail->mos65xx.op_count].mem =
239	849	(MI->address + value) & 0xffff;
240	849	detail->mos65xx.op_count++;
241	849	break;
242	0	}
243	0	case MOS65XX_AM_ZP_REL: {
244	0	int value = 3 + (signed char)MI->Operands[1].ImmVal;
245		/* BBR0, zp, rel and BBS0, zp, rel */
246	0	detail->mos65xx.operands[detail->mos65xx.op_count].type =
247	0	MOS65XX_OP_MEM;
248	0	detail->mos65xx.operands[detail->mos65xx.op_count].mem =
249	0	MI->Operands[0].ImmVal;
250	0	detail->mos65xx.operands[detail->mos65xx.op_count + 1].type =
251	0	MOS65XX_OP_MEM;
252	0	detail->mos65xx.operands[detail->mos65xx.op_count + 1].mem =
253	0	(MI->address + value) & 0xffff;
254	0	detail->mos65xx.op_count += 2;
255	0	break;
256	0	}
257	9.33k	default:
258	18.6k	for (i = 0; i < MI->size; ++i) {
259	9.33k	detail->mos65xx.operands[detail->mos65xx.op_count].type =
260	9.33k	MOS65XX_OP_MEM;
261	9.33k	detail->mos65xx.operands[detail->mos65xx.op_count].mem =
262	9.33k	MI->Operands[i].ImmVal;
263	9.33k	detail->mos65xx.op_count++;
264	9.33k	}
265	9.33k	break;
266	16.3k	}
267	16.3k	}
268		#endif
269
270		void MOS65XX_printInst(MCInst MI, struct SStream O, void *PrinterInfo)
271	16.3k	{
272	16.3k	#ifndef CAPSTONE_DIET
273	16.3k	unsigned int value;
274	16.3k	unsigned opcode = MCInst_getOpcode(MI);
275	16.3k	mos65xx_info info = (mos65xx_info )PrinterInfo;
276
277	16.3k	OpInfo opinfo = OpInfoTable[opcode];
278
279	16.3k	const char *prefix = info->hex_prefix ? info->hex_prefix : "0x";
280
281	16.3k	SStream_concat0(O, InstructionInfoTable[opinfo.ins].name);
282	16.3k	switch (opinfo.ins) {
283		/* special case - bit included as part of the instruction name */
284	0	case MOS65XX_INS_BBR:
285	0	case MOS65XX_INS_BBS:
286	0	case MOS65XX_INS_RMB:
287	0	case MOS65XX_INS_SMB:
288	0	SStream_concat(O, "%" PRId8, (opcode >> 4) & 0x07);
289	0	break;
290	16.3k	default:
291	16.3k	break;
292	16.3k	}
293
294	16.3k	value = MI->Operands[0].ImmVal;
295
296	16.3k	switch (opinfo.am) {
297	0	default:
298	0	break;
299
300	4.19k	case MOS65XX_AM_IMP:
301	4.19k	break;
302
303	1.05k	case MOS65XX_AM_ACC:
304	1.05k	SStream_concat0(O, " a");
305	1.05k	break;
306
307	933	case MOS65XX_AM_IMM:
308	933	if (MI->imm_size == 1)
309	933	SStream_concat(O, " #%s%02" PRIx32, prefix, value);
310	0	else
311	0	SStream_concat(O, " #%s%04" PRIx32, prefix, value);
312	933	break;
313
314	629	case MOS65XX_AM_ZP:
315	629	SStream_concat(O, " %s%02" PRIx32, prefix, value);
316	629	break;
317
318	1.07k	case MOS65XX_AM_ABS:
319	1.07k	SStream_concat(O, " %s%04" PRIx32, prefix, value);
320	1.07k	break;
321
322	0	case MOS65XX_AM_ABS_LONG_X:
323	0	SStream_concat(O, " %s%06" PRIx32 ", x", prefix, value);
324	0	break;
325
326	1.07k	case MOS65XX_AM_INT:
327	1.07k	SStream_concat(O, " %s%02" PRIx32, prefix, value);
328	1.07k	break;
329
330	688	case MOS65XX_AM_ABS_X:
331	688	SStream_concat(O, " %s%04" PRIx32 ", x", prefix, value);
332	688	break;
333
334	1.64k	case MOS65XX_AM_ABS_Y:
335	1.64k	SStream_concat(O, " %s%04" PRIx32 ", y", prefix, value);
336	1.64k	break;
337
338	0	case MOS65XX_AM_ABS_LONG:
339	0	SStream_concat(O, " %s%06" PRIx32, prefix, value);
340	0	break;
341
342	760	case MOS65XX_AM_ZP_X:
343	760	SStream_concat(O, " %s%02" PRIx32 ", x", prefix, value);
344	760	break;
345
346	748	case MOS65XX_AM_ZP_Y:
347	748	SStream_concat(O, " %s%02" PRIx32 ", y", prefix, value);
348	748	break;
349
350	849	case MOS65XX_AM_REL: {
351	849	if (MI->op1_size == 1)
352	849	value = 2 + (int8_t)value;
353	0	else
354	0	value = 3 + (int16_t)value;
355
356	849	uint32_t addr = MI->address;
357	849	SStream_concat(O, " %s%04" PRIx16, prefix,
358	849	(addr + value) & 0xffff);
359
360	849	break;
361	0	}
362	508	case MOS65XX_AM_ABS_IND:
363	508	SStream_concat(O, " (%s%04" PRIx32 ")", prefix, value);
364	508	break;
365
366	0	case MOS65XX_AM_ABS_X_IND:
367	0	SStream_concat(O, " (%s%04" PRIx32 ", x)", prefix, value);
368	0	break;
369
370	0	case MOS65XX_AM_ABS_IND_LONG:
371	0	SStream_concat(O, " [%s%04" PRIx32 "]", prefix, value);
372	0	break;
373
374	0	case MOS65XX_AM_ZP_IND:
375	0	SStream_concat(O, " (%s%02" PRIx32 ")", prefix, value);
376	0	break;
377
378	912	case MOS65XX_AM_ZP_X_IND:
379	912	SStream_concat(O, " (%s%02" PRIx32 ", x)", prefix, value);
380	912	break;
381
382	1.29k	case MOS65XX_AM_ZP_IND_Y:
383	1.29k	SStream_concat(O, " (%s%02" PRIx32 "), y", prefix, value);
384	1.29k	break;
385
386	0	case MOS65XX_AM_ZP_IND_LONG:
387	0	SStream_concat(O, " [%s%02" PRIx32 "]", prefix, value);
388	0	break;
389
390	0	case MOS65XX_AM_ZP_IND_LONG_Y:
391	0	SStream_concat(O, " [%s%02" PRIx32 "], y", prefix, value);
392	0	break;
393
394	0	case MOS65XX_AM_SR:
395	0	SStream_concat(O, " %s%02" PRIx32 ", s", prefix, value);
396	0	break;
397
398	0	case MOS65XX_AM_SR_IND_Y:
399	0	SStream_concat(O, " (%s%02" PRIx32 ", s), y", prefix, value);
400	0	break;
401
402	0	case MOS65XX_AM_BLOCK:
403	0	SStream_concat(O, " %s%02" PRIx32 ", %s%02" PRIx32, prefix,
404	0	(uint32_t)MI->Operands[0].ImmVal, prefix,
405	0	(uint32_t)MI->Operands[1].ImmVal);
406	0	break;
407
408	0	case MOS65XX_AM_ZP_REL: {
409	0	value = 3 + (int8_t)MI->Operands[1].ImmVal;
410	0	uint32_t addr = MI->address;
411	0	uint32_t target = (addr + value) & 0xffff;
412		/* BBR0, zp, rel and BBS0, zp, rel */
413	0	SStream_concat(O, " %s%02" PRIx32 ", %s%04" PRIx32, prefix,
414	0	(uint32_t)MI->Operands[0].ImmVal, prefix,
415	0	target);
416	0	break;
417	0	}
418	16.3k	}
419	16.3k	#endif
420	16.3k	}
421
422		bool MOS65XX_getInstruction(csh ud, const uint8_t *code, size_t code_len,
423		MCInst MI, uint16_t size, uint64_t address,
424		void *inst_info)
425	16.5k	{
426	16.5k	int i;
427	16.5k	unsigned char opcode;
428	16.5k	unsigned char len;
429	16.5k	unsigned cpu_offset = 0;
430	16.5k	int cpu_type = MOS65XX_CPU_TYPE_6502;
431	16.5k	cs_struct *handle = MI->csh;
432	16.5k	mos65xx_info info = (mos65xx_info )handle->printer_info;
433	16.5k	OpInfo opinfo;
434
435	16.5k	if (code_len == 0) {
436	0	*size = 1;
437	0	return false;
438	0	}
439
440	16.5k	cpu_type = info->cpu_type;
441	16.5k	cpu_offset = cpu_type * 256;
442
443	16.5k	opcode = code[0];
444	16.5k	opinfo = OpInfoTable[cpu_offset + opcode];
445	16.5k	if (opinfo.ins == MOS65XX_INS_INVALID) {
446	134	*size = 1;
447	134	return false;
448	134	}
449
450	16.4k	len = opinfo.operand_bytes + 1;
451
452	16.4k	if (cpu_type == MOS65XX_CPU_TYPE_65816 && opinfo.am == MOS65XX_AM_IMM) {
453	0	switch (opinfo.ins) {
454	0	case MOS65XX_INS_CPX:
455	0	case MOS65XX_INS_CPY:
456	0	case MOS65XX_INS_LDX:
457	0	case MOS65XX_INS_LDY:
458	0	if (info->long_x)
459	0	++len;
460	0	break;
461	0	case MOS65XX_INS_ADC:
462	0	case MOS65XX_INS_AND:
463	0	case MOS65XX_INS_BIT:
464	0	case MOS65XX_INS_CMP:
465	0	case MOS65XX_INS_EOR:
466	0	case MOS65XX_INS_LDA:
467	0	case MOS65XX_INS_ORA:
468	0	case MOS65XX_INS_SBC:
469	0	if (info->long_m)
470	0	++len;
471	0	break;
472	0	default:
473	0	break;
474	0	}
475	0	}
476
477	16.4k	if (code_len < len) {
478	72	*size = 1;
479	72	return false;
480	72	}
481
482	16.3k	MI->address = address;
483
484	16.3k	MCInst_setOpcode(MI, cpu_offset + opcode);
485	16.3k	MCInst_setOpcodePub(MI, opinfo.ins);
486
487	16.3k	*size = len;
488
489		/* needed to differentiate relative vs relative long */
490	16.3k	MI->op1_size = len - 1;
491	16.3k	if (opinfo.ins == MOS65XX_INS_NOP) {
492	464	for (i = 1; i < len; ++i)
493	0	MCOperand_CreateImm0(MI, code[i]);
494	464	}
495
496	16.3k	switch (opinfo.am) {
497	0	case MOS65XX_AM_ZP_REL:
498	0	MCOperand_CreateImm0(MI, code[1]);
499	0	MCOperand_CreateImm0(MI, code[2]);
500	0	break;
501	0	case MOS65XX_AM_BLOCK:
502	0	MCOperand_CreateImm0(MI, code[2]);
503	0	MCOperand_CreateImm0(MI, code[1]);
504	0	break;
505	4.19k	case MOS65XX_AM_IMP:
506	5.25k	case MOS65XX_AM_ACC:
507	5.25k	break;
508
509	933	case MOS65XX_AM_IMM:
510	933	MI->has_imm = 1;
511	933	MI->imm_size = len - 1;
512		/* 65816 immediate is either 1 or 2 bytes */
513		/* drop through */
514	11.1k	default:
515	11.1k	if (len == 2)
516	7.20k	MCOperand_CreateImm0(MI, code[1]);
517	3.91k	else if (len == 3)
518	3.91k	MCOperand_CreateImm0(MI, (code[2] << 8) \| code[1]);
519	0	else if (len == 4)
520	0	MCOperand_CreateImm0(
521	0	MI, (code[3] << 16) \| (code[2] << 8) \| code[1]);
522	11.1k	break;
523	16.3k	}
524
525	16.3k	#ifndef CAPSTONE_DIET
526	16.3k	if (MI->flat_insn->detail) {
527	16.3k	fillDetails(MI, opinfo, cpu_type);
528	16.3k	}
529	16.3k	#endif
530
531	16.3k	return true;
532	16.3k	}
533
534		const char *MOS65XX_insn_name(csh handle, unsigned int id)
535	16.3k	{
536		#ifdef CAPSTONE_DIET
537		return NULL;
538		#else
539	16.3k	if (id >= ARR_SIZE(InstructionInfoTable)) {
540	0	return NULL;
541	0	}
542	16.3k	return InstructionInfoTable[id].name;
543	16.3k	#endif
544	16.3k	}
545
546		const char *MOS65XX_reg_name(csh handle, unsigned int reg)
547	39.2k	{
548		#ifdef CAPSTONE_DIET
549		return NULL;
550		#else
551	39.2k	if (reg >= ARR_SIZE(RegNames)) {
552	0	return NULL;
553	0	}
554	39.2k	return RegNames[(int)reg];
555	39.2k	#endif
556	39.2k	}
557
558		void MOS65XX_get_insn_id(cs_struct h, cs_insn insn, unsigned int id)
559	16.3k	{
560		/* id is cpu_offset + opcode */
561	16.3k	if (id < ARR_SIZE(OpInfoTable)) {
562	16.3k	insn->id = OpInfoTable[id].ins;
563	16.3k	}
564	16.3k	}
565
566		const char *MOS65XX_group_name(csh handle, unsigned int id)
567	5.05k	{
568		#ifdef CAPSTONE_DIET
569		return NULL;
570		#else
571	5.05k	if (id >= ARR_SIZE(GroupNames)) {
572	0	return NULL;
573	0	}
574	5.05k	return GroupNames[(int)id];
575	5.05k	#endif
576	5.05k	}