/* ======================================================================== */

/* ========================= LICENSING & COPYRIGHT ======================== */

/* ======================================================================== */

/*

 *                                  MUSASHI

 *                                Version 3.4

 *

 * A portable Motorola M680x0 processor emulation engine.

 * Copyright 1998-2001 Karl Stenerud.  All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

/* The code below is based on MUSASHI but has been heavily modified for Capstone by

 * Daniel Collin <daniel@collin.com> 2015-2019 */

/* ======================================================================== */

/* ================================ INCLUDES ============================== */

/* ======================================================================== */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "../../cs_priv.h"

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

#include "../../MCInst.h"

#include "../../MCInstrDesc.h"

#include "../../MCRegisterInfo.h"

#include "M68KInstPrinter.h"

#include "M68KDisassembler.h"

/* ======================================================================== */

/* ============================ GENERAL DEFINES =========================== */

/* ======================================================================== */

/* Bit Isolation Functions */

#define BIT_0(A)  ((A) & 0x00000001)

#define BIT_1(A)  ((A) & 0x00000002)

#define BIT_2(A)  ((A) & 0x00000004)

#define BIT_3(A)  ((A) & 0x00000008)

#define BIT_4(A)  ((A) & 0x00000010)

#define BIT_5(A)  ((A) & 0x00000020)

#define BIT_6(A)  ((A) & 0x00000040)

#define BIT_7(A)  ((A) & 0x00000080)

#define BIT_8(A)  ((A) & 0x00000100)

#define BIT_9(A)  ((A) & 0x00000200)

#define BIT_A(A)  ((A) & 0x00000400)

#define BIT_B(A)  ((A) & 0x00000800)

#define BIT_C(A)  ((A) & 0x00001000)

#define BIT_D(A)  ((A) & 0x00002000)

#define BIT_E(A)  ((A) & 0x00004000)

#define BIT_F(A)  ((A) & 0x00008000)

#define BIT_10(A) ((A) & 0x00010000)

#define BIT_11(A) ((A) & 0x00020000)

#define BIT_12(A) ((A) & 0x00040000)

#define BIT_13(A) ((A) & 0x00080000)

#define BIT_14(A) ((A) & 0x00100000)

#define BIT_15(A) ((A) & 0x00200000)

#define BIT_16(A) ((A) & 0x00400000)

#define BIT_17(A) ((A) & 0x00800000)

#define BIT_18(A) ((A) & 0x01000000)

#define BIT_19(A) ((A) & 0x02000000)

#define BIT_1A(A) ((A) & 0x04000000)

#define BIT_1B(A) ((A) & 0x08000000)

#define BIT_1C(A) ((A) & 0x10000000)

#define BIT_1D(A) ((A) & 0x20000000)

#define BIT_1E(A) ((A) & 0x40000000)

#define BIT_1F(A) ((A) & 0x80000000)

/* These are the CPU types understood by this disassembler */

#define TYPE_68000 1

#define TYPE_68010 2

#define TYPE_68020 4

#define TYPE_68030 8

#define TYPE_68040 16

#define M68000_ONLY   TYPE_68000

#define M68010_ONLY   TYPE_68010

#define M68010_LESS   (TYPE_68000 | TYPE_68010)

#define M68010_PLUS   (TYPE_68010 | TYPE_68020 | TYPE_68030 | TYPE_68040)

#define M68020_ONLY   TYPE_68020

#define M68020_LESS   (TYPE_68010 | TYPE_68020)

#define M68020_PLUS   (TYPE_68020 | TYPE_68030 | TYPE_68040)

#define M68030_ONLY   TYPE_68030

#define M68030_LESS   (TYPE_68010 | TYPE_68020 | TYPE_68030)

#define M68030_PLUS   (TYPE_68030 | TYPE_68040)

#define M68040_PLUS   TYPE_68040

enum {

  M68K_CPU_TYPE_INVALID,

  M68K_CPU_TYPE_68000,

  M68K_CPU_TYPE_68010,

  M68K_CPU_TYPE_68EC020,

  M68K_CPU_TYPE_68020,

  M68K_CPU_TYPE_68030,  /* Supported by disassembler ONLY */

  M68K_CPU_TYPE_68040   /* Supported by disassembler ONLY */

};

/* Extension word formats */

#define EXT_8BIT_DISPLACEMENT(A)          ((A)&0xff)

#define EXT_FULL(A)                       BIT_8(A)

#define EXT_EFFECTIVE_ZERO(A)             (((A)&0xe4) == 0xc4 || ((A)&0xe2) == 0xc0)

#define EXT_BASE_REGISTER_PRESENT(A)      (!BIT_7(A))

#define EXT_INDEX_REGISTER_PRESENT(A)     (!BIT_6(A))

#define EXT_INDEX_REGISTER(A)             (((A)>>12)&7)

#define EXT_INDEX_PRE_POST(A)             (EXT_INDEX_PRESENT(A) && (A)&3)

#define EXT_INDEX_PRE(A)                  (EXT_INDEX_PRESENT(A) && ((A)&7) < 4 && ((A)&7) != 0)

#define EXT_INDEX_POST(A)                 (EXT_INDEX_PRESENT(A) && ((A)&7) > 4)

#define EXT_INDEX_SCALE(A)                (((A)>>9)&3)

#define EXT_INDEX_LONG(A)                 BIT_B(A)

#define EXT_INDEX_AR(A)                   BIT_F(A)

#define EXT_BASE_DISPLACEMENT_PRESENT(A)  (((A)&0x30) > 0x10)

#define EXT_BASE_DISPLACEMENT_WORD(A)     (((A)&0x30) == 0x20)

#define EXT_BASE_DISPLACEMENT_LONG(A)     (((A)&0x30) == 0x30)

#define EXT_OUTER_DISPLACEMENT_PRESENT(A) (((A)&3) > 1 && ((A)&0x47) < 0x44)

#define EXT_OUTER_DISPLACEMENT_WORD(A)    (((A)&3) == 2 && ((A)&0x47) < 0x44)

#define EXT_OUTER_DISPLACEMENT_LONG(A)    (((A)&3) == 3 && ((A)&0x47) < 0x44)

#define IS_BITSET(val,b) ((val) & (1 << (b)))

#define BITFIELD_MASK(sb,eb)  (((1 << ((sb) + 1))-1) & (~((1 << (eb))-1)))

#define BITFIELD(val,sb,eb) ((BITFIELD_MASK(sb,eb) & (val)) >> (eb))

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static unsigned int m68k_read_disassembler_16(const m68k_info *info, const uint64_t addr)

{

  const uint16_t v0 = info->code[addr + 0];

  const uint16_t v1 = info->code[addr + 1];

  return (v0 << 8) | v1;

}

static unsigned int m68k_read_disassembler_32(const m68k_info *info, const uint64_t addr)

{

  const uint32_t v0 = info->code[addr + 0];

  const uint32_t v1 = info->code[addr + 1];

  const uint32_t v2 = info->code[addr + 2];

  const uint32_t v3 = info->code[addr + 3];

  return (v0 << 24) | (v1 << 16) | (v2 << 8) | v3;

}

static uint64_t m68k_read_disassembler_64(const m68k_info *info, const uint64_t addr)

{

  const uint64_t v0 = info->code[addr + 0];

  const uint64_t v1 = info->code[addr + 1];

  const uint64_t v2 = info->code[addr + 2];

  const uint64_t v3 = info->code[addr + 3];

  const uint64_t v4 = info->code[addr + 4];

  const uint64_t v5 = info->code[addr + 5];

  const uint64_t v6 = info->code[addr + 6];

  const uint64_t v7 = info->code[addr + 7];

  return (v0 << 56) | (v1 << 48) | (v2 << 40) | (v3 << 32) | (v4 << 24) | (v5 << 16) | (v6 << 8) | v7;

}

static unsigned int m68k_read_safe_16(const m68k_info *info, const uint64_t address)

{

  const uint64_t addr = (address - info->baseAddress) & info->address_mask;

  if (info->code_len < addr + 2) {

    return 0xaaaa;

  }

  return m68k_read_disassembler_16(info, addr);

}

static unsigned int m68k_read_safe_32(const m68k_info *info, const uint64_t address)

{

  const uint64_t addr = (address - info->baseAddress) & info->address_mask;

  if (info->code_len < addr + 4) {

    return 0xaaaaaaaa;

  }

  return m68k_read_disassembler_32(info, addr);

}

static uint64_t m68k_read_safe_64(const m68k_info *info, const uint64_t address)

{

  const uint64_t addr = (address - info->baseAddress) & info->address_mask;

  if (info->code_len < addr + 8) {

    return 0xaaaaaaaaaaaaaaaaLL;

  }

  return m68k_read_disassembler_64(info, addr);

}

/* ======================================================================== */

/* =============================== PROTOTYPES ============================= */

/* ======================================================================== */

/* make signed integers 100% portably */

static int make_int_8(int value);

static int make_int_16(int value);

/* Stuff to build the opcode handler jump table */

static void d68000_invalid(m68k_info *info);

static int instruction_is_valid(m68k_info *info, const unsigned int word_check);

typedef struct {

  void (*instruction)(m68k_info *info);   /* handler function */

  uint16_t word2_mask;                  /* mask the 2nd word */

  uint16_t word2_match;                 /* what to match after masking */

} instruction_struct;

/* ======================================================================== */

/* ================================= DATA ================================= */

/* ======================================================================== */

static const instruction_struct g_instruction_table[0x10000];

/* used by ops like asr, ror, addq, etc */

static const uint32_t g_3bit_qdata_table[8] = {8, 1, 2, 3, 4, 5, 6, 7};

static const uint32_t g_5bit_data_table[32] = {

  32,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,

  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31

};

static const m68k_insn s_branch_lut[] = {

  M68K_INS_INVALID, M68K_INS_INVALID, M68K_INS_BHI, M68K_INS_BLS,

  M68K_INS_BCC, M68K_INS_BCS, M68K_INS_BNE, M68K_INS_BEQ,

  M68K_INS_BVC, M68K_INS_BVS, M68K_INS_BPL, M68K_INS_BMI,

  M68K_INS_BGE, M68K_INS_BLT, M68K_INS_BGT, M68K_INS_BLE,

};

static const m68k_insn s_dbcc_lut[] = {

  M68K_INS_DBT, M68K_INS_DBF, M68K_INS_DBHI, M68K_INS_DBLS,

  M68K_INS_DBCC, M68K_INS_DBCS, M68K_INS_DBNE, M68K_INS_DBEQ,

  M68K_INS_DBVC, M68K_INS_DBVS, M68K_INS_DBPL, M68K_INS_DBMI,

  M68K_INS_DBGE, M68K_INS_DBLT, M68K_INS_DBGT, M68K_INS_DBLE,

};

static const m68k_insn s_scc_lut[] = {

  M68K_INS_ST, M68K_INS_SF, M68K_INS_SHI, M68K_INS_SLS,

  M68K_INS_SCC, M68K_INS_SCS, M68K_INS_SNE, M68K_INS_SEQ,

  M68K_INS_SVC, M68K_INS_SVS, M68K_INS_SPL, M68K_INS_SMI,

  M68K_INS_SGE, M68K_INS_SLT, M68K_INS_SGT, M68K_INS_SLE,

};

static const m68k_insn s_trap_lut[] = {

  M68K_INS_TRAPT, M68K_INS_TRAPF, M68K_INS_TRAPHI, M68K_INS_TRAPLS,

  M68K_INS_TRAPCC, M68K_INS_TRAPCS, M68K_INS_TRAPNE, M68K_INS_TRAPEQ,

  M68K_INS_TRAPVC, M68K_INS_TRAPVS, M68K_INS_TRAPPL, M68K_INS_TRAPMI,

  M68K_INS_TRAPGE, M68K_INS_TRAPLT, M68K_INS_TRAPGT, M68K_INS_TRAPLE,

};

/* ======================================================================== */

/* =========================== UTILITY FUNCTIONS ========================== */

/* ======================================================================== */

#define LIMIT_CPU_TYPES(info, ALLOWED_CPU_TYPES)  \

  do {           \

    if (!(info->type & ALLOWED_CPU_TYPES)) { \

      d68000_invalid(info);   \

      return;       \

    }          \

  } while (0)

static unsigned int peek_imm_8(const m68k_info *info)  { return (m68k_read_safe_16((info), (info)->pc)&0xff); }

static unsigned int peek_imm_16(const m68k_info *info) { return m68k_read_safe_16((info), (info)->pc); }

static unsigned int peek_imm_32(const m68k_info *info) { return m68k_read_safe_32((info), (info)->pc); }

static unsigned long long peek_imm_64(const m68k_info *info) { return m68k_read_safe_64((info), (info)->pc); }

static unsigned int read_imm_8(m68k_info *info)  { const unsigned int value = peek_imm_8(info);  (info)->pc+=2; return value; }

static unsigned int read_imm_16(m68k_info *info) { const unsigned int value = peek_imm_16(info); (info)->pc+=2; return value; }

static unsigned int read_imm_32(m68k_info *info) { const unsigned int value = peek_imm_32(info); (info)->pc+=4; return value; }

static unsigned long long read_imm_64(m68k_info *info) { const unsigned long long value = peek_imm_64(info); (info)->pc+=8; return value; }

/* Fake a split interface */

#define get_ea_mode_str_8(instruction) get_ea_mode_str(instruction, 0)

#define get_ea_mode_str_16(instruction) get_ea_mode_str(instruction, 1)

#define get_ea_mode_str_32(instruction) get_ea_mode_str(instruction, 2)

#define get_imm_str_s8() get_imm_str_s(0)

#define get_imm_str_s16() get_imm_str_s(1)

#define get_imm_str_s32() get_imm_str_s(2)

#define get_imm_str_u8() get_imm_str_u(0)

#define get_imm_str_u16() get_imm_str_u(1)

#define get_imm_str_u32() get_imm_str_u(2)

/* 100% portable signed int generators */

static int make_int_8(int value)

{

  return (value & 0x80) ? value | ~0xff : value & 0xff;

}

static int make_int_16(int value)

{

  return (value & 0x8000) ? value | ~0xffff : value & 0xffff;

}

static void get_with_index_address_mode(m68k_info *info, cs_m68k_op* op, uint32_t instruction, uint32_t size, bool is_pc)

{

  uint32_t extension = read_imm_16(info);

  op->address_mode = M68K_AM_AREGI_INDEX_BASE_DISP;

  if (EXT_FULL(extension)) {

    uint32_t preindex;

    uint32_t postindex;

    op->mem.base_reg = M68K_REG_INVALID;

    op->mem.index_reg = M68K_REG_INVALID;

    /* Not sure how to deal with this?

       if (EXT_EFFECTIVE_ZERO(extension)) {

       strcpy(mode, "0");

       break;

       }

     */

    op->mem.in_disp = EXT_BASE_DISPLACEMENT_PRESENT(extension) ? (EXT_BASE_DISPLACEMENT_LONG(extension) ? read_imm_32(info) : read_imm_16(info)) : 0;

    op->mem.out_disp = EXT_OUTER_DISPLACEMENT_PRESENT(extension) ? (EXT_OUTER_DISPLACEMENT_LONG(extension) ? read_imm_32(info) : read_imm_16(info)) : 0;

    if (EXT_BASE_REGISTER_PRESENT(extension)) {

      if (is_pc) {

        op->mem.base_reg = M68K_REG_PC;

      } else {

        op->mem.base_reg = M68K_REG_A0 + (instruction & 7);

      }

    }

    if (EXT_INDEX_REGISTER_PRESENT(extension)) {

      if (EXT_INDEX_AR(extension)) {

        op->mem.index_reg = M68K_REG_A0 + EXT_INDEX_REGISTER(extension);

      } else {

        op->mem.index_reg = M68K_REG_D0 + EXT_INDEX_REGISTER(extension);

      }

      op->mem.index_size = EXT_INDEX_LONG(extension) ? 1 : 0;

      if (EXT_INDEX_SCALE(extension)) {

        op->mem.scale = 1 << EXT_INDEX_SCALE(extension);

      }

    }

    preindex = (extension & 7) > 0 && (extension & 7) < 4;

    postindex = (extension & 7) > 4;

    if (preindex) {

      op->address_mode = is_pc ? M68K_AM_PC_MEMI_PRE_INDEX : M68K_AM_MEMI_PRE_INDEX;

    } else if (postindex) {

      op->address_mode = is_pc ? M68K_AM_PC_MEMI_POST_INDEX : M68K_AM_MEMI_POST_INDEX;

    }

    return;

  }

  op->mem.index_reg = (EXT_INDEX_AR(extension) ? M68K_REG_A0 : M68K_REG_D0) + EXT_INDEX_REGISTER(extension);

  op->mem.index_size = EXT_INDEX_LONG(extension) ? 1 : 0;

  if (EXT_8BIT_DISPLACEMENT(extension) == 0) {

    if (is_pc) {

      op->mem.base_reg = M68K_REG_PC;

      op->address_mode = M68K_AM_PCI_INDEX_BASE_DISP;

    } else {

      op->mem.base_reg = M68K_REG_A0 + (instruction & 7);

    }

  } else {

    if (is_pc) {

      op->mem.base_reg = M68K_REG_PC;

      op->address_mode = M68K_AM_PCI_INDEX_8_BIT_DISP;

    } else {

      op->mem.base_reg = M68K_REG_A0 + (instruction & 7);

      op->address_mode = M68K_AM_AREGI_INDEX_8_BIT_DISP;

    }

    op->mem.disp = (int8_t)(extension & 0xff);

  }

  if (EXT_INDEX_SCALE(extension)) {

    op->mem.scale = 1 << EXT_INDEX_SCALE(extension);

  }

}

/* Make string of effective address mode */

static void get_ea_mode_op(m68k_info *info, cs_m68k_op* op, uint32_t instruction, uint32_t size)

{

  // default to memory

  op->type = M68K_OP_MEM;

  switch (instruction & 0x3f) {

    case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:

      /* data register direct */

      op->address_mode = M68K_AM_REG_DIRECT_DATA;

      op->reg = M68K_REG_D0 + (instruction & 7);

      op->type = M68K_OP_REG;

      break;

    case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:

      /* address register direct */

      op->address_mode = M68K_AM_REG_DIRECT_ADDR;

      op->reg = M68K_REG_A0 + (instruction & 7);

      op->type = M68K_OP_REG;

      break;

    case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:

      /* address register indirect */

      op->address_mode = M68K_AM_REGI_ADDR;

      op->reg = M68K_REG_A0 + (instruction & 7);

      break;

    case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:

      /* address register indirect with postincrement */

      op->address_mode = M68K_AM_REGI_ADDR_POST_INC;

      op->reg = M68K_REG_A0 + (instruction & 7);

      break;

    case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:

      /* address register indirect with predecrement */

      op->address_mode = M68K_AM_REGI_ADDR_PRE_DEC;

      op->reg = M68K_REG_A0 + (instruction & 7);

      break;

    case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:

      /* address register indirect with displacement*/

      op->address_mode = M68K_AM_REGI_ADDR_DISP;

      op->mem.base_reg = M68K_REG_A0 + (instruction & 7);

      op->mem.disp = (int16_t)read_imm_16(info);

      break;

    case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:

      /* address register indirect with index */

      get_with_index_address_mode(info, op, instruction, size, false);

      break;

    case 0x38:

      /* absolute short address */

      op->address_mode = M68K_AM_ABSOLUTE_DATA_SHORT;

      op->imm = read_imm_16(info);

      break;

    case 0x39:

      /* absolute long address */

      op->address_mode = M68K_AM_ABSOLUTE_DATA_LONG;

      op->imm = read_imm_32(info);

      break;

    case 0x3a:

      /* program counter with displacement */

      op->address_mode = M68K_AM_PCI_DISP;

      op->mem.disp = (int16_t)read_imm_16(info);

      break;

    case 0x3b:

      /* program counter with index */

      get_with_index_address_mode(info, op, instruction, size, true);

      break;

    case 0x3c:

      op->address_mode = M68K_AM_IMMEDIATE;

      op->type = M68K_OP_IMM;

      if (size == 1)

        op->imm = read_imm_8(info) & 0xff;

      else if (size == 2)

        op->imm = read_imm_16(info) & 0xffff;

      else if (size == 4)

        op->imm = read_imm_32(info);

      else

        op->imm = read_imm_64(info);

      break;

    default:

      break;

  }

}

static void set_insn_group(m68k_info *info, m68k_group_type group)

{

  info->groups[info->groups_count++] = (uint8_t)group;

}

static cs_m68k* build_init_op(m68k_info *info, int opcode, int count, int size)

{

  cs_m68k* ext;

  MCInst_setOpcode(info->inst, opcode);

  ext = &info->extension;

  ext->op_count = (uint8_t)count;

  ext->op_size.type = M68K_SIZE_TYPE_CPU;

  ext->op_size.cpu_size = size;

  return ext;

}

static void build_re_gen_1(m68k_info *info, bool isDreg, int opcode, uint8_t size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  if (isDreg) {

    op0->address_mode = M68K_AM_REG_DIRECT_DATA;

    op0->reg = M68K_REG_D0 + ((info->ir >> 9 ) & 7);

  } else {

    op0->address_mode = M68K_AM_REG_DIRECT_ADDR;

    op0->reg = M68K_REG_A0 + ((info->ir >> 9 ) & 7);

  }

  get_ea_mode_op(info, op1, info->ir, size);

}

static void build_re_1(m68k_info *info, int opcode, uint8_t size)

{

  build_re_gen_1(info, true, opcode, size);

}

static void build_er_gen_1(m68k_info *info, bool isDreg, int opcode, uint8_t size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  get_ea_mode_op(info, op0, info->ir, size);

  if (isDreg) {

    op1->address_mode = M68K_AM_REG_DIRECT_DATA;

    op1->reg = M68K_REG_D0 + ((info->ir >> 9) & 7);

  } else {

    op1->address_mode = M68K_AM_REG_DIRECT_ADDR;

    op1->reg = M68K_REG_A0 + ((info->ir >> 9) & 7);

  }

}

static void build_rr(m68k_info *info, int opcode, uint8_t size, int imm)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k_op* op2;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op2 = &ext->operands[2];

  op0->address_mode = M68K_AM_REG_DIRECT_DATA;

  op0->reg = M68K_REG_D0 + (info->ir & 7);

  op1->address_mode = M68K_AM_REG_DIRECT_DATA;

  op1->reg = M68K_REG_D0 + ((info->ir >> 9) & 7);

  if (imm > 0) {

    ext->op_count = 3;

    op2->type = M68K_OP_IMM;

    op2->address_mode = M68K_AM_IMMEDIATE;

    op2->imm = imm;

  }

}

static void build_r(m68k_info *info, int opcode, uint8_t size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->address_mode = M68K_AM_REG_DIRECT_DATA;

  op0->reg = M68K_REG_D0 + ((info->ir >> 9) & 7);

  op1->address_mode = M68K_AM_REG_DIRECT_DATA;

  op1->reg = M68K_REG_D0 + (info->ir & 7);

}

static void build_imm_ea(m68k_info *info, int opcode, uint8_t size, int imm)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->type = M68K_OP_IMM;

  op0->address_mode = M68K_AM_IMMEDIATE;

  op0->imm = imm;

  get_ea_mode_op(info, op1, info->ir, size);

}

static void build_3bit_d(m68k_info *info, int opcode, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->type = M68K_OP_IMM;

  op0->address_mode = M68K_AM_IMMEDIATE;

  op0->imm = g_3bit_qdata_table[(info->ir >> 9) & 7];

  op1->address_mode = M68K_AM_REG_DIRECT_DATA;

  op1->reg = M68K_REG_D0 + (info->ir & 7);

}

static void build_3bit_ea(m68k_info *info, int opcode, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->type = M68K_OP_IMM;

  op0->address_mode = M68K_AM_IMMEDIATE;

  op0->imm = g_3bit_qdata_table[(info->ir >> 9) & 7];

  get_ea_mode_op(info, op1, info->ir, size);

}

static void build_mm(m68k_info *info, int opcode, uint8_t size, int imm)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k_op* op2;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op2 = &ext->operands[2];

  op0->address_mode = M68K_AM_REGI_ADDR_PRE_DEC;

  op0->reg = M68K_REG_A0 + (info->ir & 7);

  op1->address_mode = M68K_AM_REGI_ADDR_PRE_DEC;

  op1->reg = M68K_REG_A0 + ((info->ir >> 9) & 7);

  if (imm > 0) {

    ext->op_count = 3;

    op2->type = M68K_OP_IMM;

    op2->address_mode = M68K_AM_IMMEDIATE;

    op2->imm = imm;

  }

}

static void build_ea(m68k_info *info, int opcode, uint8_t size)

{

  cs_m68k* ext = build_init_op(info, opcode, 1, size);

  get_ea_mode_op(info, &ext->operands[0], info->ir, size);

}

static void build_ea_a(m68k_info *info, int opcode, uint8_t size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  get_ea_mode_op(info, op0, info->ir, size);

  op1->address_mode = M68K_AM_REG_DIRECT_ADDR;

  op1->reg = M68K_REG_A0 + ((info->ir >> 9) & 7);

}

static void build_ea_ea(m68k_info *info, int opcode, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  get_ea_mode_op(info, op0, info->ir, size);

  get_ea_mode_op(info, op1, (((info->ir>>9) & 7) | ((info->ir>>3) & 0x38)), size);

}

static void build_pi_pi(m68k_info *info, int opcode, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->address_mode = M68K_AM_REGI_ADDR_POST_INC;

  op0->reg = M68K_REG_A0 + (info->ir & 7);

  op1->address_mode = M68K_AM_REGI_ADDR_POST_INC;

  op1->reg = M68K_REG_A0 + ((info->ir >> 9) & 7);

}

static void build_imm_special_reg(m68k_info *info, int opcode, int imm, int size, m68k_reg reg)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->type = M68K_OP_IMM;

  op0->address_mode = M68K_AM_IMMEDIATE;

  op0->imm = imm;

  op1->address_mode = M68K_AM_NONE;

  op1->reg = reg;

}

static void build_relative_branch(m68k_info *info, int opcode, int size, int displacement)

{

  cs_m68k_op* op;

  cs_m68k* ext = build_init_op(info, opcode, 1, size);

  op = &ext->operands[0];

  op->type = M68K_OP_BR_DISP;

  op->address_mode = M68K_AM_BRANCH_DISPLACEMENT;

  op->br_disp.disp = displacement;

  op->br_disp.disp_size = size;

  set_insn_group(info, M68K_GRP_JUMP);

  set_insn_group(info, M68K_GRP_BRANCH_RELATIVE);

}

static void build_absolute_jump_with_immediate(m68k_info *info, int opcode, int size, int immediate)

{

  cs_m68k_op* op;

  cs_m68k* ext = build_init_op(info, opcode, 1, size);

  op = &ext->operands[0];

  op->type = M68K_OP_IMM;

  op->address_mode = M68K_AM_IMMEDIATE;

  op->imm = immediate;

  set_insn_group(info, M68K_GRP_JUMP);

}

static void build_bcc(m68k_info *info, int size, int displacement)

{

  build_relative_branch(info, s_branch_lut[(info->ir >> 8) & 0xf], size, displacement);

}

static void build_trap(m68k_info *info, int size, int immediate)

{

  build_absolute_jump_with_immediate(info, s_trap_lut[(info->ir >> 8) & 0xf], size, immediate);

}

static void build_dbxx(m68k_info *info, int opcode, int size, int displacement)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->address_mode = M68K_AM_REG_DIRECT_DATA;

  op0->reg = M68K_REG_D0 + (info->ir & 7);

  op1->type = M68K_OP_BR_DISP;

  op1->address_mode = M68K_AM_BRANCH_DISPLACEMENT;

  op1->br_disp.disp = displacement;

  op1->br_disp.disp_size = M68K_OP_BR_DISP_SIZE_LONG;

  set_insn_group(info, M68K_GRP_JUMP);

  set_insn_group(info, M68K_GRP_BRANCH_RELATIVE);

}

static void build_dbcc(m68k_info *info, int size, int displacement)

{

  build_dbxx(info, s_dbcc_lut[(info->ir >> 8) & 0xf], size, displacement);

}

static void build_d_d_ea(m68k_info *info, int opcode, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k_op* op2;

  uint32_t extension = read_imm_16(info);

  cs_m68k* ext = build_init_op(info, opcode, 3, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op2 = &ext->operands[2];

  op0->address_mode = M68K_AM_REG_DIRECT_DATA;

  op0->reg = M68K_REG_D0 + (extension & 7);

  op1->address_mode = M68K_AM_REG_DIRECT_DATA;

  op1->reg = M68K_REG_D0 + ((extension >> 6) & 7);

  get_ea_mode_op(info, op2, info->ir, size);

}

static void build_bitfield_ins(m68k_info *info, int opcode, int has_d_arg)

{

  uint8_t offset;

  uint8_t width;

  cs_m68k_op* op_ea;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 1, 0);

  uint32_t extension = read_imm_16(info);

  op_ea = &ext->operands[0];

  op1 = &ext->operands[1];

  if (BIT_B(extension))

    offset = (extension >> 6) & 7;

  else

    offset = (extension >> 6) & 31;

  if (BIT_5(extension))

    width = extension & 7;

  else

    width = (uint8_t)g_5bit_data_table[extension & 31];

  if (has_d_arg) {

    ext->op_count = 2;

    op1->address_mode = M68K_AM_REG_DIRECT_DATA;

    op1->reg = M68K_REG_D0 + ((extension >> 12) & 7);

  }

  get_ea_mode_op(info, op_ea, info->ir, 1);

  op_ea->mem.bitfield = 1;

  op_ea->mem.width = width;

  op_ea->mem.offset = offset;

}

static void build_d(m68k_info *info, int opcode, int size)

{

  cs_m68k* ext = build_init_op(info, opcode, 1, size);

  cs_m68k_op* op;

  op = &ext->operands[0];

  op->address_mode = M68K_AM_REG_DIRECT_DATA;

  op->reg = M68K_REG_D0 + (info->ir & 7);

}

static uint16_t reverse_bits(uint32_t v)

{

  uint32_t r = v; // r will be reversed bits of v; first get LSB of v

  uint32_t s = 16 - 1; // extra shift needed at end

  for (v >>= 1; v; v >>= 1) {

    r <<= 1;

    r |= v & 1;

    s--;

  }

  return r <<= s; // shift when v's highest bits are zero

}

static uint8_t reverse_bits_8(uint32_t v)

{

  uint32_t r = v; // r will be reversed bits of v; first get LSB of v

  uint32_t s = 8 - 1; // extra shift needed at end

  for (v >>= 1; v; v >>= 1) {

    r <<= 1;

    r |= v & 1;

    s--;

  }

  return r <<= s; // shift when v's highest bits are zero

}

static void build_movem_re(m68k_info *info, int opcode, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->type = M68K_OP_REG_BITS;

  op0->register_bits = read_imm_16(info);

  get_ea_mode_op(info, op1, info->ir, size);

  if (op1->address_mode == M68K_AM_REGI_ADDR_PRE_DEC)

    op0->register_bits = reverse_bits(op0->register_bits);

}

static void build_movem_er(m68k_info *info, int opcode, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, opcode, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op1->type = M68K_OP_REG_BITS;

  op1->register_bits = read_imm_16(info);

  get_ea_mode_op(info, op0, info->ir, size);

}

static void build_imm(m68k_info *info, int opcode, int data)

{

  cs_m68k_op* op;

  cs_m68k* ext = build_init_op(info, opcode, 1, 0);

  MCInst_setOpcode(info->inst, opcode);

  op = &ext->operands[0];

  op->type = M68K_OP_IMM;

  op->address_mode = M68K_AM_IMMEDIATE;

  op->imm = data;

}

static void build_illegal(m68k_info *info, int data)

{

  build_imm(info, M68K_INS_ILLEGAL, data);

}

static void build_invalid(m68k_info *info, int data)

{

  build_imm(info, M68K_INS_INVALID, data);

}

static void build_cas2(m68k_info *info, int size)

{

  uint32_t word3;

  uint32_t extension;

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k_op* op2;

  cs_m68k* ext = build_init_op(info, M68K_INS_CAS2, 3, size);

  int reg_0, reg_1;

  /* cas2 is the only 3 words instruction, word2 and word3 have the same motif bits to check */

  word3 = peek_imm_32(info) & 0xffff;

  if (!instruction_is_valid(info, word3))

    return;

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op2 = &ext->operands[2];

  extension = read_imm_32(info);

  op0->address_mode = M68K_AM_NONE;

  op0->type = M68K_OP_REG_PAIR;

  op0->reg_pair.reg_0 = ((extension >> 16) & 7) + M68K_REG_D0;

  op0->reg_pair.reg_1 = (extension & 7) + M68K_REG_D0;

  op1->address_mode = M68K_AM_NONE;

  op1->type = M68K_OP_REG_PAIR;

  op1->reg_pair.reg_0 = ((extension >> 22) & 7) + M68K_REG_D0;

  op1->reg_pair.reg_1 = ((extension >> 6) & 7) + M68K_REG_D0;

  reg_0 = (extension >> 28) & 7;

  reg_1 = (extension >> 12) & 7;

  op2->address_mode = M68K_AM_NONE;

  op2->type = M68K_OP_REG_PAIR;

  op2->reg_pair.reg_0 = reg_0 + (BIT_1F(extension) ? 8 : 0) + M68K_REG_D0;

  op2->reg_pair.reg_1 = reg_1 + (BIT_F(extension) ? 8 : 0) + M68K_REG_D0;

}

static void build_chk2_cmp2(m68k_info *info, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, M68K_INS_CHK2, 2, size);

  uint32_t extension = read_imm_16(info);

  if (BIT_B(extension))

    MCInst_setOpcode(info->inst, M68K_INS_CHK2);

  else

    MCInst_setOpcode(info->inst, M68K_INS_CMP2);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  get_ea_mode_op(info, op0, info->ir, size);

  op1->address_mode = M68K_AM_NONE;

  op1->type = M68K_OP_REG;

  op1->reg = (BIT_F(extension) ? M68K_REG_A0 : M68K_REG_D0) + ((extension >> 12) & 7);

}

static void build_move16(m68k_info *info, int data[2], int modes[2])

{

  cs_m68k* ext = build_init_op(info, M68K_INS_MOVE16, 2, 0);

  int i;

  for (i = 0; i < 2; ++i) {

    cs_m68k_op* op = &ext->operands[i];

    const int d = data[i];

    const int m = modes[i];

    op->type = M68K_OP_MEM;

    if (m == M68K_AM_REGI_ADDR_POST_INC || m == M68K_AM_REG_DIRECT_ADDR) {

      op->address_mode = m;

      op->reg = M68K_REG_A0 + d;

    } else {

      op->address_mode = m;

      op->imm = d;

    }

  }

}

static void build_link(m68k_info *info, int disp, int size)

{

  cs_m68k_op* op0;

  cs_m68k_op* op1;

  cs_m68k* ext = build_init_op(info, M68K_INS_LINK, 2, size);

  op0 = &ext->operands[0];

  op1 = &ext->operands[1];

  op0->address_mode = M68K_AM_NONE;

  op0->reg = M68K_REG_A0 + (info->ir & 7);