/* MSPDebug - debugging tool for the eZ430
* Copyright (C) 2009, 2010 Daniel Beer
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef DIS_H_
#include <stdint.h>
#include "util.h"
/* Addressing modes.
*
* Addressing modes are not determined solely by the address mode bits
* in an instruction. Rather, those bits specify one of four possible
* modes (REGISTER, INDEXED, INDIRECT and INDIRECT_INC). Using some of
* these modes in conjunction with special registers like PC or the
* constant generator registers results in extra modes. For example, the
* following code, written using INDIRECT_INC on PC:
*
* MOV @PC+, R5
* .word 0x5729
*
* can also be written as an instruction using IMMEDIATE addressing:
*
* MOV #0x5729, R5
*/
typedef enum {
MSP430_AMODE_REGISTER = 0x0,
MSP430_AMODE_INDEXED = 0x1,
MSP430_AMODE_SYMBOLIC = 0x81,
MSP430_AMODE_ABSOLUTE = 0x82,
MSP430_AMODE_INDIRECT = 0x2,
MSP430_AMODE_INDIRECT_INC = 0x3,
MSP430_AMODE_IMMEDIATE = 0x83
} msp430_amode_t;
/* MSP430 registers.
*
* These are divided into:
*
* PC/R0: program counter
* SP/R1: stack pointer
* SR/R2: status register/constant generator 1
* R3: constant generator 2
* R4-R15: general purpose registers
*/
typedef enum {
MSP430_REG_PC = 0,
MSP430_REG_SP = 1,
MSP430_REG_SR = 2,
MSP430_REG_R3 = 3,
MSP430_REG_R4 = 4,
MSP430_REG_R5 = 5,
MSP430_REG_R6 = 6,
MSP430_REG_R7 = 7,
MSP430_REG_R8 = 8,
MSP430_REG_R9 = 9,
MSP430_REG_R10 = 10,
MSP430_REG_R11 = 11,
MSP430_REG_R12 = 12,
MSP430_REG_R13 = 13,
MSP430_REG_R14 = 14,
MSP430_REG_R15 = 15,
} msp430_reg_t;
/* Status register bits. */
#define MSP430_SR_V 0x0100
#define MSP430_SR_SCG1 0x0080
#define MSP430_SR_SCG0 0x0040
#define MSP430_SR_OSCOFF 0x0020
#define MSP430_SR_CPUOFF 0x0010
#define MSP430_SR_GIE 0x0008
#define MSP430_SR_N 0x0004
#define MSP430_SR_Z 0x0002
#define MSP430_SR_C 0x0001
/* MSP430 instruction formats.
*
* NOARG is not an actual instruction format recognised by the CPU.
* It is used only for emulated instructions.
*/
typedef enum {
MSP430_ITYPE_NOARG,
MSP430_ITYPE_JUMP,
MSP430_ITYPE_DOUBLE,
MSP430_ITYPE_SINGLE
} msp430_itype_t;
/* MSP430(X) data sizes.
*
* An address-word is a 20-bit value. When stored in memory, they are
* stored as two 16-bit words in the following order:
*
* data[15:0], {12'b0, data[19:16]}
*/
typedef enum {
MSP430_DSIZE_WORD = 0,
MSP430_DSIZE_BYTE = 1,
MSP430_DSIZE_UNKNOWN = 2,
MSP430_DSIZE_AWORD = 3,
} msp430_dsize_t;
/* MSP430 operations.
*
* Some of these are emulated instructions. Emulated instructions are
* alternate mnemonics for combinations of some real opcodes with
* common operand values. For example, the following real instruction:
*
* MOV #0, R8
*
* can be written as the following emulated instruction:
*
* CLR R8
*/
typedef enum {
/* Single operand */
MSP430_OP_RRC = 0x1000,
MSP430_OP_SWPB = 0x1080,
MSP430_OP_RRA = 0x1100,
MSP430_OP_SXT = 0x1180,
MSP430_OP_PUSH = 0x1200,
MSP430_OP_CALL = 0x1280,
MSP430_OP_RETI = 0x1300,
/* Jump */
MSP430_OP_JNZ = 0x2000,
MSP430_OP_JZ = 0x2400,
MSP430_OP_JNC = 0x2800,
MSP430_OP_JC = 0x2C00,
MSP430_OP_JN = 0x3000,
MSP430_OP_JGE = 0x3400,
MSP430_OP_JL = 0x3800,
MSP430_OP_JMP = 0x3C00,
/* Double operand */
MSP430_OP_MOV = 0x4000,
MSP430_OP_ADD = 0x5000,
MSP430_OP_ADDC = 0x6000,
MSP430_OP_SUBC = 0x7000,
MSP430_OP_SUB = 0x8000,
MSP430_OP_CMP = 0x9000,
MSP430_OP_DADD = 0xA000,
MSP430_OP_BIT = 0xB000,
MSP430_OP_BIC = 0xC000,
MSP430_OP_BIS = 0xD000,
MSP430_OP_XOR = 0xE000,
MSP430_OP_AND = 0xF000,
/* Emulated instructions */
MSP430_OP_ADC = 0x10000,
MSP430_OP_BR = 0x10001,
MSP430_OP_CLR = 0x10002,
MSP430_OP_CLRC = 0x10003,
MSP430_OP_CLRN = 0x10004,
MSP430_OP_CLRZ = 0x10005,
MSP430_OP_DADC = 0x10006,
MSP430_OP_DEC = 0x10007,
MSP430_OP_DECD = 0x10008,
MSP430_OP_DINT = 0x10009,
MSP430_OP_EINT = 0x1000A,
MSP430_OP_INC = 0x1000B,
MSP430_OP_INCD = 0x1000C,
MSP430_OP_INV = 0x1000D,
MSP430_OP_NOP = 0x1000E,
MSP430_OP_POP = 0x1000F,
MSP430_OP_RET = 0x10010,
MSP430_OP_RLA = 0x10011,
MSP430_OP_RLC = 0x10012,
MSP430_OP_SBC = 0x10013,
MSP430_OP_SETC = 0x10014,
MSP430_OP_SETN = 0x10015,
MSP430_OP_SETZ = 0x10016,
MSP430_OP_TST = 0x10017,
/* MSP430X single operand (extension word) */
MSP430_OP_RRCX = 0x21000,
MSP430_OP_RRUX = 0x21001, /* note: ZC = 1 */
MSP430_OP_SWPBX = 0x21080,
MSP430_OP_RRAX = 0x21100,
MSP430_OP_SXTX = 0x21180,
MSP430_OP_PUSHX = 0x21200,
/* MSP430X double operand (extension word) */
MSP430_OP_MOVX = 0x24000,
MSP430_OP_ADDX = 0x25000,
MSP430_OP_ADDCX = 0x26000,
MSP430_OP_SUBCX = 0x27000,
MSP430_OP_SUBX = 0x28000,
MSP430_OP_CMPX = 0x29000,
MSP430_OP_DADDX = 0x2A000,
MSP430_OP_BITX = 0x2B000,
MSP430_OP_BICX = 0x2C000,
MSP430_OP_BISX = 0x2D000,
MSP430_OP_XORX = 0x2E000,
MSP430_OP_ANDX = 0x2F000,
/* MSP430X group 13xx */
MSP430_OP_CALLA = 0x21300,
/* MSP430X group 14xx */
MSP430_OP_PUSHM = 0x1400,
MSP430_OP_POPM = 0x1600,
/* MSP430X address instructions */
MSP430_OP_MOVA = 0x0000,
MSP430_OP_CMPA = 0x0090,
MSP430_OP_ADDA = 0x00A0,
MSP430_OP_SUBA = 0x00B0,
/* MSP430X group 00xx, non-address */
MSP430_OP_RRCM = 0x0040,
MSP430_OP_RRAM = 0x0140,
MSP430_OP_RLAM = 0x0240,
MSP430_OP_RRUM = 0x0340,
/* MSP430X emulated instructions */
MSP430_OP_ADCX = 0x40000,
MSP430_OP_BRA = 0x40001,
MSP430_OP_RETA = 0x40002,
MSP430_OP_CLRX = 0x40003,
MSP430_OP_DADCX = 0x40004,
MSP430_OP_DECX = 0x40005,
MSP430_OP_DECDA = 0x40006,
MSP430_OP_DECDX = 0x40007,
MSP430_OP_INCX = 0x40008,
MSP430_OP_INCDA = 0x40009,
MSP430_OP_INVX = 0x4000A,
MSP430_OP_RLAX = 0x4000B,
MSP430_OP_RLCX = 0x4000C,
MSP430_OP_SECX = 0x4000D,
MSP430_OP_TSTA = 0x4000E,
MSP430_OP_TSTX = 0x4000F,
MSP430_OP_POPX = 0x40010,
MSP430_OP_INCDX = 0x40011,
} msp430_op_t;
/* This represents a decoded instruction. All decoded addresses are
* absolute or register-indexed, depending on the addressing mode.
*
* For jump instructions, the target address is stored in dst_operand.
*/
struct msp430_instruction {
address_t offset;
int len;
msp430_op_t op;
msp430_itype_t itype;
msp430_dsize_t dsize;
msp430_amode_t src_mode;
address_t src_addr;
msp430_reg_t src_reg;
msp430_amode_t dst_mode;
address_t dst_addr;
msp430_reg_t dst_reg;
int rep_index;
int rep_register;
};
/* Decode a single instruction.
*
* Returns the number of bytes consumed, or -1 if an error occured.
*
* The caller needs to pass a pointer to the bytes to be decoded, the
* virtual offset of those bytes, and the maximum number available. If
* successful, the decoded instruction is written into the structure
* pointed to by insn.
*/
int dis_decode(const uint8_t *code,
address_t offset, address_t len,
struct msp430_instruction *insn);
/* Look up names for registers and opcodes */
int dis_opcode_from_name(const char *name);
const char *dis_opcode_name(msp430_op_t op);
int dis_reg_from_name(const char *name);
const char *dis_reg_name(msp430_reg_t reg);
#endif