msp430_disas.c File Reference

#include <rz_types.h>
#include <rz_util.h>
#include "msp430_disas.h"

Go to the source code of this file.

Enumerations
enum	{ MSP430_TWOOP_OPCODE_INVALID = 0 , MSP430_TWOOP_OPCODE_SINGLEOP , MSP430_TWOOP_OPCODE_JUMP2 , MSP430_TWOOP_OPCODE_JUMP3 }

Functions
static ut8	get_twoop_opcode (ut16 instr)
static ut8	get_as (ut16 instr)
static ut8	get_bw (ut16 instr)
static ut8	get_ad (ut16 instr)
static int	get_src (ut16 instr)
static int	get_dst (ut16 instr)
static void	remove_first_operand (struct msp430_cmd *cmd)
static void	remove_second_operand (struct msp430_cmd *cmd)
static int	decode_emulation (ut16 instr, struct msp430_cmd *cmd)
static int	decode_addressing_mode (ut16 instr, ut16 op1, ut16 op2, struct msp430_cmd *cmd)
static int	decode_twoop_opcode (ut16 instr, ut16 op1, ut16 op2, struct msp430_cmd *cmd)
static ut8	get_jmp_opcode (ut16 instr)
static ut8	get_jmp_cond (ut16 instr)
static void	decode_jmp (ut16 instr, struct msp430_cmd *cmd)
static int	get_oneop_opcode (ut16 instr)
static int	decode_oneop_opcode (ut16 instr, ut16 op, struct msp430_cmd *cmd)
int	msp430_decode_command (const ut8 *in, int len, struct msp430_cmd *cmd)

Variables
static const char *	msp430_register_names []
static const char *	two_op_instrs []
static const char *	one_op_instrs []
static const char *	jmp_instrs []

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MSP430_TWOOP_OPCODE_INVALID
MSP430_TWOOP_OPCODE_SINGLEOP
MSP430_TWOOP_OPCODE_JUMP2
MSP430_TWOOP_OPCODE_JUMP3

Definition at line 434 of file msp430_disas.c.

     {
    MSP430_TWOOP_OPCODE_INVALID = 0,
    MSP430_TWOOP_OPCODE_SINGLEOP,
    MSP430_TWOOP_OPCODE_JUMP2,
    MSP430_TWOOP_OPCODE_JUMP3,
};

Function Documentation

decode_addressing_mode()

static int decode_addressing_mode ( ut16  instr, ut16  op1, ut16  op2, struct msp430_cmd *  cmd  )

static

Definition at line 199 of file msp430_disas.c.

                                                                                          {
    int ret = 0, srcOperInCodeWord = 0;
    ut8 as, ad, src, dst;
    ut16 op;
    char dstbuf[16];
 
    memset(dstbuf, 0, sizeof(dstbuf));
 
    as = get_as(instr);
    ad = get_ad(instr);
    src = get_src(instr);
    dst = get_dst(instr);
 
    /* addressing mode of source operand */
    switch (as) {
    case 0:
        switch (src) {
        case MSP430_R3: /* CG2 */
            snprintf(cmd->operands, sizeof(cmd->operands), "#0");
            break;
        default: /* register mode */
            snprintf(cmd->operands, sizeof(cmd->operands), "%s", msp430_register_names[src]);
        }
        ret = 2;
        break;
    case 1:
        ret = 4;
        switch (src) {
        case MSP430_PC: /* symbolic mode */
            snprintf(cmd->operands, sizeof(cmd->operands), "0x%04x", op1);
            srcOperInCodeWord = 1;
            break;
        case MSP430_R3: /* CG2 */
            snprintf(cmd->operands, sizeof(cmd->operands), "%s", "#1");
            ret = 2;
            break;
        case MSP430_SR: /* absolute mode */
            snprintf(cmd->operands, sizeof(cmd->operands), "&0x%04x", op1);
            srcOperInCodeWord = 1;
            break;
        default: /* indexed mode */
            snprintf(cmd->operands, sizeof(cmd->operands), "0x%x(%s)", op1, msp430_register_names[src]);
            srcOperInCodeWord = 1;
        }
        break;
    case 2:
        switch (src) {
        case MSP430_SR: /* CG1 */
            snprintf(cmd->operands, sizeof(cmd->operands), "#4");
            break;
        case MSP430_R3: /* CG2 */
            snprintf(cmd->operands, sizeof(cmd->operands), "#2");
            break;
        default: /* indirect register mode */
            snprintf(cmd->operands, sizeof(cmd->operands), "@%s", msp430_register_names[src]);
        }
        ret = 2;
        break;
    case 3:
        ret = 2;
        switch (src) {
        case MSP430_SR: /* CG1 */
            snprintf(cmd->operands, sizeof(cmd->operands), "#8");
            break;
        case MSP430_R3: /* CG2 */
            snprintf(cmd->operands, sizeof(cmd->operands), "#-1");
            break;
        case MSP430_PC: /* immediate mode */
            snprintf(cmd->operands, sizeof(cmd->operands), "#0x%04x", op1);
            srcOperInCodeWord = 1;
            ret = 4;
            break;
        default: /* indirect autoincrement mode */
            snprintf(cmd->operands, sizeof(cmd->operands), "@%s+", msp430_register_names[src]);
        }
        break;
    }
 
    /* addressing mode of destination operand */
    switch (ad) {
    case 0: /* register mode */
        snprintf(dstbuf, sizeof(dstbuf), ", %s", msp430_register_names[dst]);
        break;
    case 1:
        /* check addr. mode of source operand */
        if (srcOperInCodeWord != 0) {
            op = op2;
            ret = 6;
        } else {
            op = op1;
            ret = 4;
        }
        switch (get_dst(instr)) {
        case MSP430_PC: /* symbolic mode */
            snprintf(dstbuf, sizeof(dstbuf), ", 0x%04x", op);
            break;
        case MSP430_SR: /* absolute mode */
            snprintf(dstbuf, sizeof(dstbuf), ", &0x%04x", op);
            break;
        default: /* indexed mode */
            snprintf(dstbuf, sizeof(dstbuf), ", 0x%x(%s)", op, msp430_register_names[dst]);
        }
        break;
    }
 
    strncat(cmd->operands, dstbuf, sizeof(cmd->operands) - 1 - strlen(cmd->operands));
    decode_emulation(instr, cmd);
    return ret;
}

References cmd, decode_emulation(), dst, get_ad(), get_as(), get_dst(), get_src(), memset(), MSP430_PC, MSP430_R3, msp430_register_names, MSP430_SR, op, snprintf, and src.

Referenced by decode_twoop_opcode().

decode_emulation()

static int decode_emulation ( ut16  instr, struct msp430_cmd *  cmd  )

static

Definition at line 107 of file msp430_disas.c.

                                                                {
    int ret = -1;
    ut8 as, ad, src, dst, bw, opcode;
 
    as = get_as(instr);
    ad = get_ad(instr);
    src = get_src(instr);
    dst = get_dst(instr);
    bw = get_bw(instr);
    opcode = get_twoop_opcode(instr);
 
    if (opcode == MSP430_ADDC && as == 0 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "adc.b" : "adc");
        snprintf(cmd->operands, sizeof(cmd->operands), "%s", msp430_register_names[dst]);
    } else if (opcode == MSP430_MOV && as == 0 && src == MSP430_R3) {
        if (ad == 0 && dst == MSP430_R3) {
            snprintf(cmd->instr, sizeof(cmd->instr), "nop");
            cmd->operands[0] = '\0';
        } else {
            snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "clr.b" : "clr");
            remove_first_operand(cmd);
        }
    } else if (opcode == MSP430_MOV && as == 3 && src == MSP430_SP) {
        if (dst == MSP430_PC) {
            snprintf(cmd->instr, sizeof(cmd->instr), "ret");
            cmd->type = MSP430_ONEOP;
            cmd->opcode = MSP430_RETI;
            cmd->operands[0] = '\0';
        } else {
            snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "pop.b" : "pop");
            remove_first_operand(cmd);
        }
    } else if (opcode == MSP430_MOV && ad == 0 && dst == MSP430_PC) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", "br");
        remove_second_operand(cmd);
    } else if (opcode == MSP430_BIC && as == 2 && src == MSP430_SR && dst == MSP430_SR && ad == 0) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", "clrn");
        cmd->operands[0] = '\0';
    } else if (opcode == MSP430_BIC && as == 2 && src == MSP430_R3 && dst == MSP430_SR && ad == 0) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", "clrz");
        cmd->operands[0] = '\0';
    } else if (opcode == MSP430_BIC && as == 3 && src == MSP430_SR && dst == MSP430_SR && ad == 0) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", "dint");
        cmd->operands[0] = '\0';
    } else if (opcode == MSP430_BIS && as == 3 && src == MSP430_SR && dst == MSP430_SR && ad == 0) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", "eint");
        cmd->operands[0] = '\0';
    } else if (opcode == MSP430_DADD && as == 0 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "dadc.b" : "dadc");
        remove_first_operand(cmd);
    } else if (opcode == MSP430_SUB && as == 1 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "dec.b" : "dec");
        remove_first_operand(cmd);
    } else if (opcode == MSP430_SUB && as == 2 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "decd.b" : "decd");
        remove_first_operand(cmd);
    } else if (opcode == MSP430_ADD && as == 1 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "inc.b" : "inc");
        remove_first_operand(cmd);
    } else if (opcode == MSP430_ADD && as == 2 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "incd.b" : "incd");
        remove_first_operand(cmd);
    } else if (opcode == MSP430_XOR && as == 3 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "inv.b" : "inv");
        remove_first_operand(cmd);
    } else if (opcode == MSP430_ADD && src == dst) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "rla.b" : "rla");
        remove_second_operand(cmd);
    } else if (opcode == MSP430_ADDC && src == dst) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "rlc.b" : "rlc");
        remove_second_operand(cmd);
    } else if (opcode == MSP430_SUBC && as == 0 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "sbc.b" : "sbc");
        remove_first_operand(cmd);
    } else if (opcode == MSP430_BIS && as == 1 && src == MSP430_R3 && dst == MSP430_SR && ad == 0) {
        snprintf(cmd->instr, sizeof(cmd->instr), "setc");
        cmd->operands[0] = '\0';
    } else if (opcode == MSP430_BIS && as == 2 && src == MSP430_SR && dst == MSP430_SR && ad == 0) {
        snprintf(cmd->instr, sizeof(cmd->instr), "setn");
        cmd->operands[0] = '\0';
    } else if (opcode == MSP430_BIS && as == 2 && src == MSP430_R3 && dst == MSP430_SR && ad == 0) {
        snprintf(cmd->instr, sizeof(cmd->instr), "setz");
        cmd->operands[0] = '\0';
    } else if (opcode == MSP430_CMP && as == 0 && src == MSP430_R3) {
        snprintf(cmd->instr, sizeof(cmd->instr), "%s", bw ? "tst.b" : "tst");
        remove_first_operand(cmd);
    }
 
    return ret;
}

References cmd, dst, get_ad(), get_as(), get_bw(), get_dst(), get_src(), get_twoop_opcode(), MSP430_ADD, MSP430_ADDC, MSP430_BIC, MSP430_BIS, MSP430_CMP, MSP430_DADD, MSP430_MOV, MSP430_ONEOP, MSP430_PC, MSP430_R3, msp430_register_names, MSP430_RETI, MSP430_SP, MSP430_SR, MSP430_SUB, MSP430_SUBC, MSP430_XOR, remove_first_operand(), remove_second_operand(), snprintf, and src.

Referenced by decode_addressing_mode().

decode_jmp()

static void decode_jmp ( ut16  instr, struct msp430_cmd *  cmd  )

static

Definition at line 329 of file msp430_disas.c.

                                                           {
    ut16 addr;
 
    snprintf(cmd->instr, sizeof(cmd->instr), "%s", jmp_instrs[get_jmp_cond(instr)]);
 
    addr = instr & 0x3FF;
 
    cmd->jmp_addr = addr >= 0x300 ? (st16)((0xFE00 | addr) * 2 + 2) : (addr & 0x1FF) * 2 + 2;
    snprintf(cmd->operands, sizeof(cmd->operands), "$%c0x%04x", addr >= 0x300 ? '-' : '+',
        addr >= 0x300 ? 0x400 - ((addr & 0x1FF) * 2 + 2) : (addr & 0x1FF) * 2 + 2);
 
    cmd->jmp_cond = get_jmp_cond(instr);
    cmd->opcode = get_jmp_opcode(instr);
    cmd->type = MSP430_JUMP;
}

References addr, cmd, get_jmp_cond(), get_jmp_opcode(), jmp_instrs, MSP430_JUMP, snprintf, and st16.

Referenced by msp430_decode_command().

decode_oneop_opcode()

static int decode_oneop_opcode ( ut16  instr, ut16  op, struct msp430_cmd *  cmd  )

static

Definition at line 349 of file msp430_disas.c.

                                                                            {
    int ret = 2;
    ut8 as, opcode;
 
    opcode = get_oneop_opcode(instr);
 
    as = get_as(instr);
 
    snprintf(cmd->instr, sizeof(cmd->instr), "%s", one_op_instrs[opcode]);
 
    cmd->opcode = get_oneop_opcode(instr);
 
    switch (get_oneop_opcode(instr)) {
    case MSP430_RRC:
    case MSP430_SWPB:
    case MSP430_RRA:
    case MSP430_SXT:
    case MSP430_PUSH:
    case MSP430_CALL:
        switch (as) {
        case 0:
            switch (get_dst(instr)) {
            case MSP430_R3:
                snprintf(cmd->operands, sizeof(cmd->operands), "#0");
                break;
            default:
                snprintf(cmd->operands, sizeof(cmd->operands),
                    "%s", msp430_register_names[get_dst(instr)]);
            }
            ret = 2;
            break;
        case 1:
            /* most of these instructions take another word as an immediate */
            ret = 4;
            switch (get_dst(instr)) {
            case MSP430_R3:
                snprintf(cmd->operands, sizeof(cmd->operands), "#1");
                /* this is an unusual encoding in that there's no index word */
                ret = 2;
                break;
            case MSP430_PC:
                snprintf(cmd->operands, sizeof(cmd->operands), "0x%04x", op);
                break;
            case MSP430_SR:
                snprintf(cmd->operands, sizeof(cmd->operands), "&0x%04x", op);
                break;
            default:
                snprintf(cmd->operands, sizeof(cmd->operands),
                    "0x%x(%s)", op, msp430_register_names[get_dst(instr)]);
            }
 
            break;
        case 2:
            switch (get_dst(instr)) {
            case MSP430_SR:
                snprintf(cmd->operands, sizeof(cmd->operands), "#4");
                break;
            case MSP430_R3:
                snprintf(cmd->operands, sizeof(cmd->operands), "#2");
                break;
            default:
                snprintf(cmd->operands, sizeof(cmd->operands),
                    "@%s", msp430_register_names[get_dst(instr)]);
            }
 
            ret = 2;
            break;
        case 3:
            snprintf(cmd->operands, sizeof(cmd->operands), "#0x%04x", op);
            ret = 4;
            break;
        default:
            ret = -1;
        }
        break;
    case MSP430_RETI:
        cmd->operands[0] = '\0';
        break;
    }
 
    cmd->type = MSP430_ONEOP;
 
    return ret;
}

References cmd, get_as(), get_dst(), get_oneop_opcode(), MSP430_CALL, MSP430_ONEOP, MSP430_PC, MSP430_PUSH, MSP430_R3, msp430_register_names, MSP430_RETI, MSP430_RRA, MSP430_RRC, MSP430_SR, MSP430_SWPB, MSP430_SXT, one_op_instrs, and snprintf.

Referenced by msp430_decode_command().

decode_twoop_opcode()

static int decode_twoop_opcode ( ut16  instr, ut16  op1, ut16  op2, struct msp430_cmd *  cmd  )

static

Definition at line 309 of file msp430_disas.c.

                                                                                       {
    ut8 opcode = get_twoop_opcode(instr);
 
    snprintf(cmd->instr, sizeof(cmd->instr), "%s", two_op_instrs[opcode]);
    if (get_bw(instr)) {
        strncat(cmd->instr, ".b", sizeof(cmd->instr) - 1 - strlen(cmd->instr));
    }
 
    cmd->opcode = opcode;
    return decode_addressing_mode(instr, op1, op2, cmd);
}

References cmd, decode_addressing_mode(), get_bw(), get_twoop_opcode(), snprintf, and two_op_instrs.

Referenced by msp430_decode_command().

get_ad()

static ut8 get_ad ( ut16  instr )

static

Definition at line 79 of file msp430_disas.c.

                              {
    return (instr >> 7) & 1;
}

Referenced by decode_addressing_mode(), and decode_emulation().

get_as()

static ut8 get_as ( ut16  instr )

static

Definition at line 71 of file msp430_disas.c.

                              {
    return (instr >> 4) & 3;
}

Referenced by decode_addressing_mode(), decode_emulation(), and decode_oneop_opcode().

get_bw()

static ut8 get_bw ( ut16  instr )

static

Definition at line 75 of file msp430_disas.c.

                              {
    return (instr >> 6) & 1;
}

Referenced by decode_emulation(), and decode_twoop_opcode().

get_dst()

static int get_dst ( ut16  instr )

static

Definition at line 87 of file msp430_disas.c.

                               {
    return instr & 0xF;
}

Referenced by decode_addressing_mode(), decode_emulation(), and decode_oneop_opcode().

get_jmp_cond()

static ut8 get_jmp_cond ( ut16  instr )

static

Definition at line 325 of file msp430_disas.c.

                                    {
    return (instr >> 10) & 7;
}

Referenced by decode_jmp().

get_jmp_opcode()

static ut8 get_jmp_opcode ( ut16  instr )

static

Definition at line 321 of file msp430_disas.c.

                                      {
    return instr >> 13;
}

Referenced by decode_jmp().

get_oneop_opcode()

static int get_oneop_opcode ( ut16  instr )

static

Definition at line 345 of file msp430_disas.c.

                                        {
    return (instr >> 7) & 0x7;
}

Referenced by decode_oneop_opcode().

get_src()

static int get_src ( ut16  instr )

static

Definition at line 83 of file msp430_disas.c.

                               {
    return (instr >> 8) & 0xF;
}

Referenced by decode_addressing_mode(), and decode_emulation().

get_twoop_opcode()

static ut8 get_twoop_opcode ( ut16  instr )

static

Definition at line 67 of file msp430_disas.c.

                                        {
    return instr >> 12;
}

Referenced by decode_emulation(), decode_twoop_opcode(), and msp430_decode_command().

msp430_decode_command()

int msp430_decode_command	(	const ut8 *	in,
		int	len,
		struct msp430_cmd *	cmd
	)

Definition at line 441 of file msp430_disas.c.

                                                                          {
    int ret = -1;
    ut16 operand1 = 0, operand2 = 0;
    if (len < 2) {
        return -1;
    }
    ut16 instr = rz_read_le16(in);
    ut8 opcode = get_twoop_opcode(instr);
 
    switch (opcode) {
    case MSP430_TWOOP_OPCODE_INVALID:
        // Invalid opcode.
        break;
    case MSP430_TWOOP_OPCODE_SINGLEOP:
        // Single operand instructions or invalid opcode.
        if ((instr & 0x0f80) <= 0x0300) {
            // Single operand instructions.
            if (len >= 4) {
                operand1 = rz_read_at_le16(in, 2);
            }
            ret = decode_oneop_opcode(instr, operand1, cmd);
        }
        break;
    case MSP430_TWOOP_OPCODE_JUMP2:
    case MSP430_TWOOP_OPCODE_JUMP3:
        // Jumps.
        decode_jmp(instr, cmd);
        ret = 2;
        break;
    default:
        // Double operand instructions.
        cmd->type = MSP430_TWOOP;
        if (len >= 4) {
            operand1 = rz_read_at_le16(in, 2);
            if (len >= 6) {
                operand2 = rz_read_at_le16(in, 4);
            }
        }
        ret = decode_twoop_opcode(instr, operand1, operand2, cmd);
        break;
    }
 
    /* if ret < 0, it's an invalid opcode.Say so and return 2 since
     * all MSP430 opcodes are of 16 bits,valid or invalid */
    if (ret < 0) {
        cmd->type = MSP430_INV;
        snprintf(cmd->instr, sizeof(cmd->instr), "invalid");
        cmd->operands[0] = '\0';
        ret = 2;
    }
 
    return ret;
}

References cmd, decode_jmp(), decode_oneop_opcode(), decode_twoop_opcode(), get_twoop_opcode(), in, len, MSP430_INV, MSP430_TWOOP, MSP430_TWOOP_OPCODE_INVALID, MSP430_TWOOP_OPCODE_JUMP2, MSP430_TWOOP_OPCODE_JUMP3, MSP430_TWOOP_OPCODE_SINGLEOP, rz_read_at_le16(), rz_read_le16(), and snprintf.

Referenced by disassemble(), and msp430_op().

remove_first_operand()

static void remove_first_operand ( struct msp430_cmd *  cmd )

static

Definition at line 91 of file msp430_disas.c.

                                                         {
    if (strchr(cmd->operands, ',')) {
        memmove(cmd->operands, strchr(cmd->operands, ',') + 2,
            strlen(strchr(cmd->operands, ',') + 2) + 1);
    }
}

References cmd.

Referenced by decode_emulation().

remove_second_operand()

static void remove_second_operand ( struct msp430_cmd *  cmd )

static

Definition at line 98 of file msp430_disas.c.

                                                          {
    if (strchr(cmd->operands, ',')) {
        {
            *strchr(cmd->operands, ',') = '\0';
        }
    }
}

References cmd.

Referenced by decode_emulation().

Variable Documentation

jmp_instrs

const char* jmp_instrs[]

static

Initial value:

= {
    [MSP430_JEQ] = "jeq",
    [MSP430_JNE] = "jnz",
    [MSP430_JC] = "jc",
    [MSP430_JNC] = "jnc",
    [MSP430_JN] = "jn",
    [MSP430_JGE] = "jge",
    [MSP430_JL] = "jl",
    [MSP430_JMP] = "jmp",
}

Definition at line 56 of file msp430_disas.c.

Referenced by decode_jmp().

msp430_register_names

const char* msp430_register_names[]

static

Initial value:

= {
    "pc",
    "sp",
    "sr",
    "cg",
    "r4",
    "r5",
    "r6",
    "r7",
    "r8",
    "r9",
    "r10",
    "r11",
    "r12",
    "r13",
    "r14",
    "r15",
}

Definition at line 12 of file msp430_disas.c.

Referenced by decode_addressing_mode(), decode_emulation(), and decode_oneop_opcode().

one_op_instrs

const char* one_op_instrs[]

static

Initial value:

= {
    [MSP430_RRC] = "rrc",
    [MSP430_SWPB] = "swpb",
    [MSP430_RRA] = "rra",
    [MSP430_SXT] = "sxt",
    [MSP430_PUSH] = "push",
    [MSP430_CALL] = "call",
    [MSP430_RETI] = "reti",
}

Definition at line 46 of file msp430_disas.c.

Referenced by decode_oneop_opcode().

two_op_instrs

const char* two_op_instrs[]

static

Initial value:

= {
    [MSP430_MOV] = "mov",
    [MSP430_ADD] = "add",
    [MSP430_ADDC] = "addc",
    [MSP430_SUBC] = "subc",
    [MSP430_SUB] = "sub",
    [MSP430_CMP] = "cmp",
    [MSP430_DADD] = "dadd",
    [MSP430_BIT] = "bit",
    [MSP430_BIC] = "bic",
    [MSP430_BIS] = "bis",
    [MSP430_XOR] = "xor",
    [MSP430_AND] = "and",
}

Definition at line 31 of file msp430_disas.c.

Referenced by decode_twoop_opcode().