path: root/src/core/arm/disassembler/arm_disasm.cpp

// Copyright 2006 The Android Open Source Project

#include <string>
#include <unordered_set>

#include "common/common_types.h"
#include "common/string_util.h"

#include "core/arm/disassembler/arm_disasm.h"
#include "core/arm/skyeye_common/armsupp.h"

static const char *cond_names[] = {
    "eq",
    "ne",
    "cs",
    "cc",
    "mi",
    "pl",
    "vs",
    "vc",
    "hi",
    "ls",
    "ge",
    "lt",
    "gt",
    "le",
    "",
    "RESERVED"
};

static const char *opcode_names[] = {
    "invalid",
    "undefined",
    "adc",
    "add",
    "and",
    "b",
    "bl",
    "bic",
    "bkpt",
    "blx",
    "bx",
    "cdp",
    "clrex",
    "clz",
    "cmn",
    "cmp",
    "eor",
    "ldc",
    "ldm",
    "ldr",
    "ldrb",
    "ldrbt",
    "ldrex",
    "ldrexb",
    "ldrexd",
    "ldrexh",
    "ldrh",
    "ldrsb",
    "ldrsh",
    "ldrt",
    "mcr",
    "mla",
    "mov",
    "mrc",
    "mrs",
    "msr",
    "mul",
    "mvn",
    "nop",
    "orr",
    "pkh",
    "pld",
    "qadd16",
    "qadd8",
    "qasx",
    "qsax",
    "qsub16",
    "qsub8",
    "rev",
    "rev16",
    "revsh",
    "rsb",
    "rsc",
    "sadd16",
    "sadd8",
    "sasx",
    "sbc",
    "sel",
    "sev",
    "shadd16",
    "shadd8",
    "shasx",
    "shsax",
    "shsub16",
    "shsub8",
    "smlad",
    "smlal",
    "smlald",
    "smlsd",
    "smlsld",
    "smmla",
    "smmls",
    "smmul",
    "smuad",
    "smull",
    "smusd",
    "ssat",
    "ssat16",
    "ssax",
    "ssub16",
    "ssub8",
    "stc",
    "stm",
    "str",
    "strb",
    "strbt",
    "strex",
    "strexb",
    "strexd",
    "strexh",
    "strh",
    "strt",
    "sub",
    "swi",
    "swp",
    "swpb",
    "sxtab",
    "sxtab16",
    "sxtah",
    "sxtb",
    "sxtb16",
    "sxth",
    "teq",
    "tst",
    "uadd16",
    "uadd8",
    "uasx",
    "uhadd16",
    "uhadd8",
    "uhasx",
    "uhsax",
    "uhsub16",
    "uhsub8",
    "umlal",
    "umull",
    "uqadd16",
    "uqadd8",
    "uqasx",
    "uqsax",
    "uqsub16",
    "uqsub8",
    "usad8",
    "usada8",
    "usat",
    "usat16",
    "usax",
    "usub16",
    "usub8",
    "uxtab",
    "uxtab16",
    "uxtah",
    "uxtb",
    "uxtb16",
    "uxth",
    "wfe",
    "wfi",
    "yield",

    "undefined",
    "adc",
    "add",
    "and",
    "asr",
    "b",
    "bic",
    "bkpt",
    "bl",
    "blx",
    "bx",
    "cmn",
    "cmp",
    "eor",
    "ldmia",
    "ldr",
    "ldrb",
    "ldrh",
    "ldrsb",
    "ldrsh",
    "lsl",
    "lsr",
    "mov",
    "mul",
    "mvn",
    "neg",
    "orr",
    "pop",
    "push",
    "ror",
    "sbc",
    "stmia",
    "str",
    "strb",
    "strh",
    "sub",
    "swi",
    "tst",

    NULL
};

// Indexed by the shift type (bits 6-5)
static const char *shift_names[] = {
    "LSL",
    "LSR",
    "ASR",
    "ROR"
};

static const char* cond_to_str(u32 cond) {
    return cond_names[cond];
}

std::string ARM_Disasm::Disassemble(u32 addr, u32 insn)
{
    Opcode opcode = Decode(insn);
    switch (opcode) {
        case OP_INVALID:
            return "Invalid";
        case OP_UNDEFINED:
            return "Undefined";
        case OP_ADC:
        case OP_ADD:
        case OP_AND:
        case OP_BIC:
        case OP_CMN:
        case OP_CMP:
        case OP_EOR:
        case OP_MOV:
        case OP_MVN:
        case OP_ORR:
        case OP_RSB:
        case OP_RSC:
        case OP_SBC:
        case OP_SUB:
        case OP_TEQ:
        case OP_TST:
            return DisassembleALU(opcode, insn);
        case OP_B:
        case OP_BL:
            return DisassembleBranch(addr, opcode, insn);
        case OP_BKPT:
            return DisassembleBKPT(insn);
        case OP_BLX:
            // not supported yet
            break;
        case OP_BX:
            return DisassembleBX(insn);
        case OP_CDP:
            return "cdp";
        case OP_CLREX:
            return "clrex";
        case OP_CLZ:
            return DisassembleCLZ(insn);
        case OP_LDC:
            return "ldc";
        case OP_LDM:
        case OP_STM:
            return DisassembleMemblock(opcode, insn);
        case OP_LDR:
        case OP_LDRB:
        case OP_LDRBT:
        case OP_LDRT:
        case OP_STR:
        case OP_STRB:
        case OP_STRBT:
        case OP_STRT:
            return DisassembleMem(insn);
        case OP_LDREX:
        case OP_LDREXB:
        case OP_LDREXD:
        case OP_LDREXH:
        case OP_STREX:
        case OP_STREXB:
        case OP_STREXD:
        case OP_STREXH:
            return DisassembleREX(opcode, insn);
        case OP_LDRH:
        case OP_LDRSB:
        case OP_LDRSH:
        case OP_STRH:
            return DisassembleMemHalf(insn);
        case OP_MCR:
        case OP_MRC:
            return DisassembleMCR(opcode, insn);
        case OP_MLA:
            return DisassembleMLA(opcode, insn);
        case OP_MRS:
            return DisassembleMRS(insn);
        case OP_MSR:
            return DisassembleMSR(insn);
        case OP_MUL:
            return DisassembleMUL(opcode, insn);
        case OP_NOP:
        case OP_SEV:
        case OP_WFE:
        case OP_WFI:
        case OP_YIELD:
            return DisassembleNoOperands(opcode, insn);
        case OP_PKH:
            return DisassemblePKH(insn);
        case OP_PLD:
            return DisassemblePLD(insn);
        case OP_QADD16:
        case OP_QADD8:
        case OP_QASX:
        case OP_QSAX:
        case OP_QSUB16:
        case OP_QSUB8:
        case OP_SADD16:
        case OP_SADD8:
        case OP_SASX:
        case OP_SHADD16:
        case OP_SHADD8:
        case OP_SHASX:
        case OP_SHSAX:
        case OP_SHSUB16:
        case OP_SHSUB8:
        case OP_SSAX:
        case OP_SSUB16:
        case OP_SSUB8:
        case OP_UADD16:
        case OP_UADD8:
        case OP_UASX:
        case OP_UHADD16:
        case OP_UHADD8:
        case OP_UHASX:
        case OP_UHSAX:
        case OP_UHSUB16:
        case OP_UHSUB8:
        case OP_UQADD16:
        case OP_UQADD8:
        case OP_UQASX:
        case OP_UQSAX:
        case OP_UQSUB16:
        case OP_UQSUB8:
        case OP_USAX:
        case OP_USUB16:
        case OP_USUB8:
            return DisassembleParallelAddSub(opcode, insn);
        case OP_REV:
        case OP_REV16:
        case OP_REVSH:
            return DisassembleREV(opcode, insn);
        case OP_SEL:
            return DisassembleSEL(insn);
        case OP_SMLAD:
        case OP_SMLALD:
        case OP_SMLSD:
        case OP_SMLSLD:
        case OP_SMMLA:
        case OP_SMMLS:
        case OP_SMMUL:
        case OP_SMUAD:
        case OP_SMUSD:
        case OP_USAD8:
        case OP_USADA8:
            return DisassembleMediaMulDiv(opcode, insn);
        case OP_SSAT:
        case OP_SSAT16:
        case OP_USAT:
        case OP_USAT16:
            return DisassembleSAT(opcode, insn);
        case OP_STC:
            return "stc";
        case OP_SWI:
            return DisassembleSWI(insn);
        case OP_SWP:
        case OP_SWPB:
            return DisassembleSWP(opcode, insn);
        case OP_SXTAB:
        case OP_SXTAB16:
        case OP_SXTAH:
        case OP_SXTB:
        case OP_SXTB16:
        case OP_SXTH:
        case OP_UXTAB:
        case OP_UXTAB16:
        case OP_UXTAH:
        case OP_UXTB:
        case OP_UXTB16:
        case OP_UXTH:
            return DisassembleXT(opcode, insn);
        case OP_UMLAL:
        case OP_UMULL:
        case OP_SMLAL:
        case OP_SMULL:
            return DisassembleUMLAL(opcode, insn);
        default:
            return "Error";
    }
    return NULL;
}

std::string ARM_Disasm::DisassembleALU(Opcode opcode, u32 insn)
{
    static const u8 kNoOperand1 = 1;
    static const u8 kNoDest = 2;
    static const u8 kNoSbit = 4;

    std::string rn_str;
    std::string rd_str;

    u8 flags = 0;
    u8 cond = (insn >> 28) & 0xf;
    u8 is_immed = (insn >> 25) & 0x1;
    u8 bit_s = (insn >> 20) & 1;
    u8 rn = (insn >> 16) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 immed = insn & 0xff;

    const char* opname = opcode_names[opcode];
    switch (opcode) {
        case OP_CMN:
        case OP_CMP:
        case OP_TEQ:
        case OP_TST:
            flags = kNoDest | kNoSbit;
            break;
        case OP_MOV:
        case OP_MVN:
            flags = kNoOperand1;
            break;
        default:
            break;
    }

    // The "mov" instruction ignores the first operand (rn).
    rn_str[0] = 0;
    if ((flags & kNoOperand1) == 0) {
        rn_str = Common::StringFromFormat("r%d, ", rn);
    }

    // The following instructions do not write the result register (rd):
    // tst, teq, cmp, cmn.
    rd_str[0] = 0;
    if ((flags & kNoDest) == 0) {
        rd_str = Common::StringFromFormat("r%d, ", rd);
    }

    const char *sbit_str = "";
    if (bit_s && !(flags & kNoSbit))
        sbit_str = "s";

    if (is_immed) {
        return Common::StringFromFormat("%s%s%s\t%s%s#%u  ; 0x%x",
                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), immed, immed);
    }

    u8 shift_is_reg = (insn >> 4) & 1;
    u8 rotate = (insn >> 8) & 0xf;
    u8 rm = insn & 0xf;
    u8 shift_type = (insn >> 5) & 0x3;
    u8 rs = (insn >> 8) & 0xf;
    u8 shift_amount = (insn >> 7) & 0x1f;
    u32 rotated_val = immed;
    u8 rotate2 = rotate << 1;
    rotated_val = (rotated_val >> rotate2) | (rotated_val << (32 - rotate2));

    if (!shift_is_reg && shift_type == 0 && shift_amount == 0) {
        return Common::StringFromFormat("%s%s%s\t%s%sr%d",
                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm);
    }

    const char *shift_name = shift_names[shift_type];
    if (shift_is_reg) {
        return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s r%d",
                opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm,
                shift_name, rs);
    }
    if (shift_amount == 0) {
        if (shift_type == 3) {
            return Common::StringFromFormat("%s%s%s\t%s%sr%d, RRX",
                    opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm);
        }
        shift_amount = 32;
    }
    return Common::StringFromFormat("%s%s%s\t%s%sr%d, %s #%u",
            opname, cond_to_str(cond), sbit_str, rd_str.c_str(), rn_str.c_str(), rm,
            shift_name, shift_amount);
}

std::string ARM_Disasm::DisassembleBranch(u32 addr, Opcode opcode, u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u32 offset = insn & 0xffffff;
    // Sign-extend the 24-bit offset
    if ((offset >> 23) & 1)
        offset |= 0xff000000;

    // Pre-compute the left-shift and the prefetch offset
    offset <<= 2;
    offset += 8;
    addr += offset;
    const char *opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s\t0x%x", opname, cond_to_str(cond), addr);
}

std::string ARM_Disasm::DisassembleBX(u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 rn = insn & 0xf;
    return Common::StringFromFormat("bx%s\tr%d", cond_to_str(cond), rn);
}

std::string ARM_Disasm::DisassembleBKPT(u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u32 immed = (((insn >> 8) & 0xfff) << 4) | (insn & 0xf);
    return Common::StringFromFormat("bkpt%s\t#%d", cond_to_str(cond), immed);
}

std::string ARM_Disasm::DisassembleCLZ(u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 rm = insn & 0xf;
    return Common::StringFromFormat("clz%s\tr%d, r%d", cond_to_str(cond), rd, rm);
}

std::string ARM_Disasm::DisassembleMediaMulDiv(Opcode opcode, u32 insn) {
    u32 cond = BITS(insn, 28, 31);
    u32 rd = BITS(insn, 16, 19);
    u32 ra = BITS(insn, 12, 15);
    u32 rm = BITS(insn, 8, 11);
    u32 m = BIT(insn, 5);
    u32 rn = BITS(insn, 0, 3);

    std::string cross = "";
    if (m) {
        if (opcode == OP_SMMLA || opcode == OP_SMMUL || opcode == OP_SMMLS)
            cross = "r";
        else
            cross = "x";
    }

    std::string ext_reg = "";
    std::unordered_set<Opcode, std::hash<int>> with_ext_reg = {
            OP_SMLAD, OP_SMLSD, OP_SMMLA, OP_SMMLS, OP_USADA8
    };
    if (with_ext_reg.find(opcode) != with_ext_reg.end())
        ext_reg = Common::StringFromFormat(", r%u", ra);

    std::string rd_low = "";
    if (opcode == OP_SMLALD || opcode == OP_SMLSLD)
        rd_low = Common::StringFromFormat("r%u, ", ra);

    return Common::StringFromFormat("%s%s%s\t%sr%u, r%u, r%u%s", opcode_names[opcode],
                                    cross.c_str(), cond_to_str(cond), rd_low.c_str(), rd, rn, rm,
                                    ext_reg.c_str());
}

std::string ARM_Disasm::DisassembleMemblock(Opcode opcode, u32 insn)
{
    std::string tmp_list;

    u8 cond = (insn >> 28) & 0xf;
    u8 write_back = (insn >> 21) & 0x1;
    u8 bit_s = (insn >> 22) & 0x1;
    u8 is_up = (insn >> 23) & 0x1;
    u8 is_pre = (insn >> 24) & 0x1;
    u8 rn = (insn >> 16) & 0xf;
    u16 reg_list = insn & 0xffff;

    const char *opname = opcode_names[opcode];

    const char *bang = "";
    if (write_back)
        bang = "!";

    const char *carret = "";
    if (bit_s)
        carret = "^";

    const char *comma = "";
    tmp_list[0] = 0;
    for (int ii = 0; ii < 16; ++ii) {
        if (reg_list & (1 << ii)) {
            tmp_list += Common::StringFromFormat("%sr%d", comma, ii);
            comma = ",";
        }
    }

    const char *addr_mode = "";
    if (is_pre) {
        if (is_up) {
            addr_mode = "ib";
        } else {
            addr_mode = "db";
        }
    } else {
        if (is_up) {
            addr_mode = "ia";
        } else {
            addr_mode = "da";
        }
    }

    return Common::StringFromFormat("%s%s%s\tr%d%s, {%s}%s",
            opname, cond_to_str(cond), addr_mode, rn, bang, tmp_list.c_str(), carret);
}

std::string ARM_Disasm::DisassembleMem(u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 is_reg = (insn >> 25) & 0x1;
    u8 is_load = (insn >> 20) & 0x1;
    u8 write_back = (insn >> 21) & 0x1;
    u8 is_byte = (insn >> 22) & 0x1;
    u8 is_up = (insn >> 23) & 0x1;
    u8 is_pre = (insn >> 24) & 0x1;
    u8 rn = (insn >> 16) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u16 offset = insn & 0xfff;

    const char *opname = "ldr";
    if (!is_load)
        opname = "str";

    const char *bang = "";
    if (write_back)
        bang = "!";

    const char *minus = "";
    if (is_up == 0)
        minus = "-";

    const char *byte = "";
    if (is_byte)
        byte = "b";

    if (is_reg == 0) {
        if (is_pre) {
            if (offset == 0) {
                return Common::StringFromFormat("%s%s%s\tr%d, [r%d]",
                        opname, cond_to_str(cond), byte, rd, rn);
            } else {
                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, #%s%u]%s",
                        opname, cond_to_str(cond), byte, rd, rn, minus, offset, bang);
            }
        } else {
            const char *transfer = "";
            if (write_back)
                transfer = "t";

            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], #%s%u",
                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, offset);
        }
    }

    u8 rm = insn & 0xf;
    u8 shift_type = (insn >> 5) & 0x3;
    u8 shift_amount = (insn >> 7) & 0x1f;

    const char *shift_name = shift_names[shift_type];

    if (is_pre) {
        if (shift_amount == 0) {
            if (shift_type == 0) {
                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d]%s",
                        opname, cond_to_str(cond), byte, rd, rn, minus, rm, bang);
            }
            if (shift_type == 3) {
                return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, RRX]%s",
                        opname, cond_to_str(cond), byte, rd, rn, minus, rm, bang);
            }
            shift_amount = 32;
        }
        return Common::StringFromFormat("%s%s%s\tr%d, [r%d, %sr%d, %s #%u]%s",
                opname, cond_to_str(cond), byte, rd, rn, minus, rm,
                shift_name, shift_amount, bang);
    }

    const char *transfer = "";
    if (write_back)
        transfer = "t";

    if (shift_amount == 0) {
        if (shift_type == 0) {
            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d",
                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
        }
        if (shift_type == 3) {
            return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, RRX",
                    opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm);
        }
        shift_amount = 32;
    }

    return Common::StringFromFormat("%s%s%s%s\tr%d, [r%d], %sr%d, %s #%u",
            opname, cond_to_str(cond), byte, transfer, rd, rn, minus, rm,
            shift_name, shift_amount);
}

std::string ARM_Disasm::DisassembleMemHalf(u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 is_load = (insn >> 20) & 0x1;
    u8 write_back = (insn >> 21) & 0x1;
    u8 is_immed = (insn >> 22) & 0x1;
    u8 is_up = (insn >> 23) & 0x1;
    u8 is_pre = (insn >> 24) & 0x1;
    u8 rn = (insn >> 16) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 bits_65 = (insn >> 5) & 0x3;
    u8 rm = insn & 0xf;
    u8 offset = (((insn >> 8) & 0xf) << 4) | (insn & 0xf);

    const char *opname = "ldr";
    if (is_load == 0)
        opname = "str";

    const char *width = "";
    if (bits_65 == 1)
        width = "h";
    else if (bits_65 == 2)
        width = "sb";
    else
        width = "sh";

    const char *bang = "";
    if (write_back)
        bang = "!";
    const char *minus = "";
    if (is_up == 0)
        minus = "-";

    if (is_immed) {
        if (is_pre) {
            if (offset == 0) {
                return Common::StringFromFormat("%s%sh\tr%d, [r%d]", opname, cond_to_str(cond), rd, rn);
            } else {
                return Common::StringFromFormat("%s%sh\tr%d, [r%d, #%s%u]%s",
                        opname, cond_to_str(cond), rd, rn, minus, offset, bang);
            }
        } else {
            return Common::StringFromFormat("%s%sh\tr%d, [r%d], #%s%u",
                    opname, cond_to_str(cond), rd, rn, minus, offset);
        }
    }

    if (is_pre) {
        return Common::StringFromFormat("%s%sh\tr%d, [r%d, %sr%d]%s",
                opname, cond_to_str(cond), rd, rn, minus, rm, bang);
    } else {
        return Common::StringFromFormat("%s%sh\tr%d, [r%d], %sr%d",
                opname, cond_to_str(cond), rd, rn, minus, rm);
    }
}

std::string ARM_Disasm::DisassembleMCR(Opcode opcode, u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 crn = (insn >> 16) & 0xf;
    u8 crd = (insn >> 12) & 0xf;
    u8 cpnum = (insn >> 8) & 0xf;
    u8 opcode2 = (insn >> 5) & 0x7;
    u8 crm = insn & 0xf;

    const char *opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s\t%d, 0, r%d, cr%d, cr%d, {%d}",
            opname, cond_to_str(cond), cpnum, crd, crn, crm, opcode2);
}

std::string ARM_Disasm::DisassembleMLA(Opcode opcode, u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 16) & 0xf;
    u8 rn = (insn >> 12) & 0xf;
    u8 rs = (insn >> 8) & 0xf;
    u8 rm = insn & 0xf;
    u8 bit_s = (insn >> 20) & 1;

    const char *opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d",
            opname, cond_to_str(cond), bit_s ? "s" : "", rd, rm, rs, rn);
}

std::string ARM_Disasm::DisassembleUMLAL(Opcode opcode, u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 rdhi = (insn >> 16) & 0xf;
    u8 rdlo = (insn >> 12) & 0xf;
    u8 rs = (insn >> 8) & 0xf;
    u8 rm = insn & 0xf;
    u8 bit_s = (insn >> 20) & 1;

    const char *opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d, r%d",
            opname, cond_to_str(cond), bit_s ? "s" : "", rdlo, rdhi, rm, rs);
}

std::string ARM_Disasm::DisassembleMUL(Opcode opcode, u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 16) & 0xf;
    u8 rs = (insn >> 8) & 0xf;
    u8 rm = insn & 0xf;
    u8 bit_s = (insn >> 20) & 1;

    const char *opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s%s\tr%d, r%d, r%d",
            opname, cond_to_str(cond), bit_s ? "s" : "", rd, rm, rs);
}

std::string ARM_Disasm::DisassembleMRS(u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 ps = (insn >> 22) & 1;

    return Common::StringFromFormat("mrs%s\tr%d, %s", cond_to_str(cond), rd, ps ? "spsr" : "cpsr");
}

std::string ARM_Disasm::DisassembleMSR(u32 insn)
{
    char flags[8];
    int flag_index = 0;
    u8 cond = (insn >> 28) & 0xf;
    u8 is_immed = (insn >> 25) & 0x1;
    u8 pd = (insn >> 22) & 1;
    u8 mask = (insn >> 16) & 0xf;

    if (mask & 1)
        flags[flag_index++] = 'c';
    if (mask & 2)
        flags[flag_index++] = 'x';
    if (mask & 4)
        flags[flag_index++] = 's';
    if (mask & 8)
        flags[flag_index++] = 'f';
    flags[flag_index] = 0;

    if (is_immed) {
        u32 immed = insn & 0xff;
        u8 rotate = (insn >> 8) & 0xf;
        u8 rotate2 = rotate << 1;
        u32 rotated_val = (immed >> rotate2) | (immed << (32 - rotate2));
        return Common::StringFromFormat("msr%s\t%s_%s, #0x%x",
                cond_to_str(cond), pd ? "spsr" : "cpsr", flags, rotated_val);
    }

    u8 rm = insn & 0xf;

    return Common::StringFromFormat("msr%s\t%s_%s, r%d",
            cond_to_str(cond), pd ? "spsr" : "cpsr", flags, rm);
}

std::string ARM_Disasm::DisassembleNoOperands(Opcode opcode, u32 insn)
{
    u32 cond = BITS(insn, 28, 31);
    return Common::StringFromFormat("%s%s", opcode_names[opcode], cond_to_str(cond));
}

std::string ARM_Disasm::DisassembleParallelAddSub(Opcode opcode, u32 insn) {
    u32 cond = BITS(insn, 28, 31);
    u32 rn = BITS(insn, 16, 19);
    u32 rd = BITS(insn, 12, 15);
    u32 rm = BITS(insn, 0, 3);

    return Common::StringFromFormat("%s%s\tr%u, r%u, r%u", opcode_names[opcode], cond_to_str(cond),
                                    rd, rn, rm);
}

std::string ARM_Disasm::DisassemblePKH(u32 insn)
{
    u32 cond = BITS(insn, 28, 31);
    u32 rn = BITS(insn, 16, 19);
    u32 rd = BITS(insn, 12, 15);
    u32 imm5 = BITS(insn, 7, 11);
    u32 tb = BIT(insn, 6);
    u32 rm = BITS(insn, 0, 3);

    std::string suffix = tb ? "tb" : "bt";
    std::string shift = "";

    if (tb && imm5 == 0)
        imm5 = 32;

    if (imm5 > 0) {
        shift = tb ? ", ASR" : ", LSL";
        shift += " #" + std::to_string(imm5);
    }

    return Common::StringFromFormat("pkh%s%s\tr%u, r%u, r%u%s", suffix.c_str(), cond_to_str(cond),
                                    rd, rn, rm, shift.c_str());
}

std::string ARM_Disasm::DisassemblePLD(u32 insn)
{
    u8 is_reg = (insn >> 25) & 0x1;
    u8 is_up = (insn >> 23) & 0x1;
    u8 rn = (insn >> 16) & 0xf;

    const char *minus = "";
    if (is_up == 0)
        minus = "-";

    if (is_reg) {
        u8 rm = insn & 0xf;
        return Common::StringFromFormat("pld\t[r%d, %sr%d]", rn, minus, rm);
    }

    u16 offset = insn & 0xfff;
    if (offset == 0) {
        return Common::StringFromFormat("pld\t[r%d]", rn);
    } else {
        return Common::StringFromFormat("pld\t[r%d, #%s%u]", rn, minus, offset);
    }
}

std::string ARM_Disasm::DisassembleREV(Opcode opcode, u32 insn) {
    u32 cond = BITS(insn, 28, 31);
    u32 rd = BITS(insn, 12, 15);
    u32 rm = BITS(insn, 0, 3);

    return Common::StringFromFormat("%s%s\tr%u, r%u", opcode_names[opcode], cond_to_str(cond),
                                    rd, rm);
}

std::string ARM_Disasm::DisassembleREX(Opcode opcode, u32 insn) {
    u32 rn = BITS(insn, 16, 19);
    u32 rd = BITS(insn, 12, 15);
    u32 rt = BITS(insn, 0, 3);
    u32 cond = BITS(insn, 28, 31);

    switch (opcode) {
        case OP_STREX:
        case OP_STREXB:
        case OP_STREXH:
            return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
                                            cond_to_str(cond), rd, rt, rn);
        case OP_STREXD:
            return Common::StringFromFormat("%s%s\tr%d, r%d, r%d, [r%d]", opcode_names[opcode],
                                            cond_to_str(cond), rd, rt, rt + 1, rn);

        // for LDREX instructions, rd corresponds to Rt from reference manual
        case OP_LDREX:
        case OP_LDREXB:
        case OP_LDREXH:
            return Common::StringFromFormat("%s%s\tr%d, [r%d]", opcode_names[opcode],
                                            cond_to_str(cond), rd, rn);
        case OP_LDREXD:
            return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opcode_names[opcode],
                                            cond_to_str(cond), rd, rd + 1, rn);
        default:
            return opcode_names[OP_UNDEFINED];
    }
}

std::string ARM_Disasm::DisassembleSAT(Opcode opcode, u32 insn) {
    u32 cond = BITS(insn, 28, 31);
    u32 sat_imm = BITS(insn, 16, 20);
    u32 rd = BITS(insn, 12, 15);
    u32 imm5 = BITS(insn, 7, 11);
    u32 sh = BIT(insn, 6);
    u32 rn = BITS(insn, 0, 3);

    std::string shift_part = "";
    bool opcode_has_shift = (opcode == OP_SSAT) || (opcode == OP_USAT);
    if (opcode_has_shift && !(sh == 0 && imm5 == 0)) {
        if (sh == 0)
            shift_part += ", LSL #";
        else
            shift_part += ", ASR #";

        if (imm5 == 0)
            imm5 = 32;
        shift_part += std::to_string(imm5);
    }

    if (opcode == OP_SSAT || opcode == OP_SSAT16)
        sat_imm++;

    return Common::StringFromFormat("%s%s\tr%u, #%u, r%u%s", opcode_names[opcode], cond_to_str(cond), rd,
                                    sat_imm, rn, shift_part.c_str());
}

std::string ARM_Disasm::DisassembleSEL(u32 insn) {
    u32 cond = BITS(insn, 28, 31);
    u32 rn = BITS(insn, 16, 19);
    u32 rd = BITS(insn, 12, 15);
    u32 rm = BITS(insn, 0, 3);

    return Common::StringFromFormat("%s%s\tr%u, r%u, r%u", opcode_names[OP_SEL], cond_to_str(cond),
                                    rd, rn, rm);
}

std::string ARM_Disasm::DisassembleSWI(u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u32 sysnum = insn & 0x00ffffff;

    return Common::StringFromFormat("swi%s 0x%x", cond_to_str(cond), sysnum);
}

std::string ARM_Disasm::DisassembleSWP(Opcode opcode, u32 insn)
{
    u8 cond = (insn >> 28) & 0xf;
    u8 rn = (insn >> 16) & 0xf;
    u8 rd = (insn >> 12) & 0xf;
    u8 rm = insn & 0xf;

    const char *opname = opcode_names[opcode];
    return Common::StringFromFormat("%s%s\tr%d, r%d, [r%d]", opname, cond_to_str(cond), rd, rm, rn);
}

std::string ARM_Disasm::DisassembleXT(Opcode opcode, u32 insn)
{
    u32 cond = BITS(insn, 28, 31);
    u32 rn = BITS(insn, 16, 19);
    u32 rd = BITS(insn, 12, 15);
    u32 rotate = BITS(insn, 10, 11);
    u32 rm = BITS(insn, 0, 3);

    std::string rn_part = "";
    static std::unordered_set<Opcode, std::hash<int>> extend_with_add = {
        OP_SXTAB, OP_SXTAB16, OP_SXTAH,
        OP_UXTAB, OP_UXTAB16, OP_UXTAH
    };
    if (extend_with_add.find(opcode) != extend_with_add.end())
        rn_part = ", r" + std::to_string(rn);

    std::string rotate_part = "";
    if (rotate != 0)
        rotate_part = ", ROR #" + std::to_string(rotate << 3);

    return Common::StringFromFormat("%s%s\tr%u%s, r%u%s", opcode_names[opcode], cond_to_str(cond),
                                    rd, rn_part.c_str(), rm, rotate_part.c_str());
}

Opcode ARM_Disasm::Decode(u32 insn) {
    u32 bits27_26 = (insn >> 26) & 0x3;
    switch (bits27_26) {
        case 0x0:
            return Decode00(insn);
        case 0x1:
            return Decode01(insn);
        case 0x2:
            return Decode10(insn);
        case 0x3:
            return Decode11(insn);
    }
    return OP_INVALID;
}

Opcode ARM_Disasm::Decode00(u32 insn) {
    u8 bit25 = (insn >> 25) & 0x1;
    u8 bit4 = (insn >> 4) & 0x1;
    if (bit25 == 0 && bit4 == 1) {
        if ((insn & 0x0ffffff0) == 0x012fff10) {
            // Bx instruction
            return OP_BX;
        }
        if ((insn & 0x0ff000f0) == 0x01600010) {
            // Clz instruction
            return OP_CLZ;
        }
        if ((insn & 0xfff000f0) == 0xe1200070) {
            // Bkpt instruction
            return OP_BKPT;
        }
        u32 bits7_4 = (insn >> 4) & 0xf;
        if (bits7_4 == 0x9) {
            u32 bit24 = BIT(insn, 24);
            if (bit24) {
                return DecodeSyncPrimitive(insn);
            }
            // One of the multiply instructions
            return DecodeMUL(insn);
        }

        u8 bit7 = (insn >> 7) & 0x1;
        if (bit7 == 1) {
            // One of the load/store halfword/byte instructions
            return DecodeLDRH(insn);
        }
    }

    u32 op1 = BITS(insn, 20, 24);
    if (bit25 && (op1 == 0x12 || op1 == 0x16)) {
        // One of the MSR (immediate) and hints instructions
        return DecodeMSRImmAndHints(insn);
    }

    // One of the data processing instructions
    return DecodeALU(insn);
}

Opcode ARM_Disasm::Decode01(u32 insn) {
    u8 is_reg = (insn >> 25) & 0x1;
    u8 bit4 = (insn >> 4) & 0x1;
    if (is_reg == 1 && bit4 == 1)
        return DecodeMedia(insn);
    u8 is_load = (insn >> 20) & 0x1;
    u8 is_byte = (insn >> 22) & 0x1;
    if ((insn & 0xfd70f000) == 0xf550f000) {
        // Pre-load
        return OP_PLD;
    }
    if (insn == 0xf57ff01f) {
        // Clear-Exclusive
        return OP_CLREX;
    }
    if (is_load) {
        if (is_byte) {
            // Load byte
            return OP_LDRB;
        }
        // Load word
        return OP_LDR;
    }
    if (is_byte) {
        // Store byte
        return OP_STRB;
    }
    // Store word
    return OP_STR;
}

Opcode ARM_Disasm::Decode10(u32 insn) {
    u8 bit25 = (insn >> 25) & 0x1;
    if (bit25 == 0) {
        // LDM/STM
        u8 is_load = (insn >> 20) & 0x1;
        if (is_load)
            return OP_LDM;
        return OP_STM;
    }

    // Branch with link
    if ((insn >> 24) & 1)
        return OP_BL;

    return OP_B;
}

Opcode ARM_Disasm::Decode11(u32 insn) {
    u8 bit25 = (insn >> 25) & 0x1;
    if (bit25 == 0) {
        // LDC, SDC
        u8 is_load = (insn >> 20) & 0x1;
        if (is_load) {
            // LDC
            return OP_LDC;
        }
        // STC
        return OP_STC;
    }

    u8 bit24 = (insn >> 24) & 0x1;
    if (bit24 == 0x1) {
        // SWI
        return OP_SWI;
    }

    u8 bit4 = (insn >> 4) & 0x1;
    u8 cpnum = (insn >> 8) & 0xf;

    if (cpnum == 15) {
        // Special case for coprocessor 15
        u8 opcode = (insn >> 21) & 0x7;
        if (bit4 == 0 || opcode != 0) {
            // This is an unexpected bit pattern.  Create an undefined
            // instruction in case this is ever executed.
            return OP_UNDEFINED;
        }

        // MRC, MCR
        u8 is_mrc = (insn >> 20) & 0x1;
        if (is_mrc)
            return OP_MRC;
        return OP_MCR;
    }

    if (bit4 == 0) {
        // CDP
        return OP_CDP;
    }
    // MRC, MCR
    u8 is_mrc = (insn >> 20) & 0x1;
    if (is_mrc)
        return OP_MRC;
    return OP_MCR;
}

Opcode ARM_Disasm::DecodeSyncPrimitive(u32 insn) {
    u32 op = BITS(insn, 20, 23);
    u32 bit22 = BIT(insn, 22);
    switch (op) {
        case 0x0:
            if (bit22)
                return OP_SWPB;
            return OP_SWP;
        case 0x8:
            return OP_STREX;
        case 0x9:
            return OP_LDREX;
        case 0xA:
            return OP_STREXD;
        case 0xB:
            return OP_LDREXD;
        case 0xC:
            return OP_STREXB;
        case 0xD:
            return OP_LDREXB;
        case 0xE:
            return OP_STREXH;
        case 0xF:
            return OP_LDREXH;
        default:
            return OP_UNDEFINED;
    }
}

Opcode ARM_Disasm::DecodeParallelAddSub(u32 insn) {
    u32 op1 = BITS(insn, 20, 21);
    u32 op2 = BITS(insn, 5, 7);
    u32 is_unsigned = BIT(insn, 22);

    if (op1 == 0x0 || op2 == 0x5 || op2 == 0x6)
        return OP_UNDEFINED;

    // change op1 range from [1, 3] to range [0, 2]
    op1--;

    // change op2 range from [0, 4] U {7} to range [0, 5]
    if (op2 == 0x7)
        op2 = 0x5;

    static std::vector<Opcode> opcodes = {
        // op1 = 0
        OP_SADD16, OP_UADD16,
        OP_SASX, OP_UASX,
        OP_SSAX, OP_USAX,
        OP_SSUB16, OP_USUB16,
        OP_SADD8, OP_UADD8,
        OP_SSUB8, OP_USUB8,
        // op1 = 1
        OP_QADD16, OP_UQADD16,
        OP_QASX, OP_UQASX,
        OP_QSAX, OP_UQSAX,
        OP_QSUB16, OP_UQSUB16,
        OP_QADD8, OP_UQADD8,
        OP_QSUB8, OP_UQSUB8,
        // op1 = 2
        OP_SHADD16, OP_UHADD16,
        OP_SHASX, OP_UHASX,
        OP_SHSAX, OP_UHSAX,
        OP_SHSUB16, OP_UHSUB16,
        OP_SHADD8, OP_UHADD8,
        OP_SHSUB8, OP_UHSUB8
    };

    u32 opcode_index = op1 * 12 + op2 * 2 + is_unsigned;
    return opcodes[opcode_index];
}

Opcode ARM_Disasm::DecodePackingSaturationReversal(u32 insn) {
    u32 op1 = BITS(insn, 20, 22);
    u32 a = BITS(insn, 16, 19);
    u32 op2 = BITS(insn, 5, 7);

    switch (op1) {
        case 0x0:
            if (BIT(op2, 0) == 0)
                return OP_PKH;
            if (op2 == 0x3 && a != 0xf)
                return OP_SXTAB16;
            if (op2 == 0x3 && a == 0xf)
                return OP_SXTB16;
            if (op2 == 0x5)
                return OP_SEL;
            break;
        case 0x2:
            if (BIT(op2, 0) == 0)
                return OP_SSAT;
            if (op2 == 0x1)
                return OP_SSAT16;
            if (op2 == 0x3 && a != 0xf)
                return OP_SXTAB;
            if (op2 == 0x3 && a == 0xf)
                return OP_SXTB;
            break;
        case 0x3:
            if (op2 == 0x1)
                return OP_REV;
            if (BIT(op2, 0) == 0)
                return OP_SSAT;
            if (op2 == 0x3 && a != 0xf)
                return OP_SXTAH;
            if (op2 == 0x3 && a == 0xf)
                return OP_SXTH;
            if (op2 == 0x5)
                return OP_REV16;
            break;
        case 0x4:
            if (op2 == 0x3 && a != 0xf)
                return OP_UXTAB16;
            if (op2 == 0x3 && a == 0xf)
                return OP_UXTB16;
            break;
        case 0x6:
            if (BIT(op2, 0) == 0)
                return OP_USAT;
            if (op2 == 0x1)
                return OP_USAT16;
            if (op2 == 0x3 && a != 0xf)
                return OP_UXTAB;
            if (op2 == 0x3 && a == 0xf)
                return OP_UXTB;
            break;
        case 0x7:
            if (BIT(op2, 0) == 0)
                return OP_USAT;
            if (op2 == 0x3 && a != 0xf)
                return OP_UXTAH;
            if (op2 == 0x3 && a == 0xf)
                return OP_UXTH;
            if (op2 == 0x5)
                return OP_REVSH;
            break;
        default:
            break;
    }

    return OP_UNDEFINED;
}

Opcode ARM_Disasm::DecodeMUL(u32 insn) {
    u8 bit24 = (insn >> 24) & 0x1;
    if (bit24 != 0) {
        // This is an unexpected bit pattern.  Create an undefined
        // instruction in case this is ever executed.
        return OP_UNDEFINED;
    }
    u8 bit23 = (insn >> 23) & 0x1;
    u8 bit22_U = (insn >> 22) & 0x1;
    u8 bit21_A = (insn >> 21) & 0x1;
    if (bit23 == 0) {
        // 32-bit multiply
        if (bit22_U != 0) {
            // This is an unexpected bit pattern.  Create an undefined
            // instruction in case this is ever executed.
            return OP_UNDEFINED;
        }
        if (bit21_A == 0)
            return OP_MUL;
        return OP_MLA;
    }
    // 64-bit multiply
    if (bit22_U == 0) {
        // Unsigned multiply long
        if (bit21_A == 0)
            return OP_UMULL;
        return OP_UMLAL;
    }
    // Signed multiply long
    if (bit21_A == 0)
        return OP_SMULL;
    return OP_SMLAL;
}

Opcode ARM_Disasm::DecodeMSRImmAndHints(u32 insn) {
    u32 op = BIT(insn, 22);
    u32 op1 = BITS(insn, 16, 19);
    u32 op2 = BITS(insn, 0, 7);

    if (op == 0 && op1 == 0) {
        switch (op2) {
            case 0x0:
                return OP_NOP;
            case 0x1:
                return OP_YIELD;
            case 0x2:
                return OP_WFE;
            case 0x3:
                return OP_WFI;
            case 0x4:
                return OP_SEV;
            default:
                return OP_UNDEFINED;
        }
    }

    return OP_MSR;
}

Opcode ARM_Disasm::DecodeMediaMulDiv(u32 insn) {
    u32 op1 = BITS(insn, 20, 22);
    u32 op2_h = BITS(insn, 6, 7);
    u32 a = BITS(insn, 12, 15);

    switch (op1) {
        case 0x0:
            if (op2_h == 0x0) {
                if (a != 0xf)
                    return OP_SMLAD;
                else
                    return OP_SMUAD;
            } else if (op2_h == 0x1) {
                if (a != 0xf)
                    return OP_SMLSD;
                else
                    return OP_SMUSD;
            }
            break;
        case 0x4:
            if (op2_h == 0x0)
                return OP_SMLALD;
            else if (op2_h == 0x1)
                return OP_SMLSLD;
            break;
        case 0x5:
            if (op2_h == 0x0) {
                if (a != 0xf)
                    return OP_SMMLA;
                else
                    return OP_SMMUL;
            } else if (op2_h == 0x3) {
                return OP_SMMLS;
            }
            break;
        default:
            break;
    }

    return OP_UNDEFINED;
}

Opcode ARM_Disasm::DecodeMedia(u32 insn) {
    u32 op1 = BITS(insn, 20, 24);
    u32 rd = BITS(insn, 12, 15);
    u32 op2 = BITS(insn, 5, 7);

    switch (BITS(op1, 3, 4)) {
        case 0x0:
            // unsigned and signed parallel addition and subtraction
            return DecodeParallelAddSub(insn);
        case 0x1:
            // Packing, unpacking, saturation, and reversal
            return DecodePackingSaturationReversal(insn);
        case 0x2:
            // Signed multiply, signed and unsigned divide
            return DecodeMediaMulDiv(insn);
        case 0x3:
            if (op2 == 0 && rd == 0xf)
                return OP_USAD8;
            if (op2 == 0 && rd != 0xf)
                return OP_USADA8;
            break;
        default:
            break;
    }

    return OP_UNDEFINED;
}

Opcode ARM_Disasm::DecodeLDRH(u32 insn) {
    u8 is_load = (insn >> 20) & 0x1;
    u8 bits_65 = (insn >> 5) & 0x3;
    if (is_load) {
        if (bits_65 == 0x1) {
            // Load unsigned halfword
            return OP_LDRH;
        } else if (bits_65 == 0x2) {
            // Load signed byte
            return OP_LDRSB;
        }
        // Signed halfword
        if (bits_65 != 0x3) {
            // This is an unexpected bit pattern.  Create an undefined
            // instruction in case this is ever executed.
            return OP_UNDEFINED;
        }
        // Load signed halfword
        return OP_LDRSH;
    }
    // Store halfword
    if (bits_65 != 0x1) {
        // This is an unexpected bit pattern.  Create an undefined
        // instruction in case this is ever executed.
        return OP_UNDEFINED;
    }
    // Store halfword
    return OP_STRH;
}

Opcode ARM_Disasm::DecodeALU(u32 insn) {
    u8 is_immed = (insn >> 25) & 0x1;
    u8 opcode = (insn >> 21) & 0xf;
    u8 bit_s = (insn >> 20) & 1;
    u8 shift_is_reg = (insn >> 4) & 1;
    u8 bit7 = (insn >> 7) & 1;
    if (!is_immed && shift_is_reg && (bit7 != 0)) {
        // This is an unexpected bit pattern.  Create an undefined
        // instruction in case this is ever executed.
        return OP_UNDEFINED;
    }
    switch (opcode) {
        case 0x0:
            return OP_AND;
        case 0x1:
            return OP_EOR;
        case 0x2:
            return OP_SUB;
        case 0x3:
            return OP_RSB;
        case 0x4:
            return OP_ADD;
        case 0x5:
            return OP_ADC;
        case 0x6:
            return OP_SBC;
        case 0x7:
            return OP_RSC;
        case 0x8:
            if (bit_s)
                return OP_TST;
            return OP_MRS;
        case 0x9:
            if (bit_s)
                return OP_TEQ;
            return OP_MSR;
        case 0xa:
            if (bit_s)
                return OP_CMP;
            return OP_MRS;
        case 0xb:
            if (bit_s)
                return OP_CMN;
            return OP_MSR;
        case 0xc:
            return OP_ORR;
        case 0xd:
            return OP_MOV;
        case 0xe:
            return OP_BIC;
        case 0xf:
            return OP_MVN;
    }
    // Unreachable
    return OP_INVALID;
}