cr16_disas.c File Reference

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

Go to the source code of this file.

Macros
#define	GET_BIT(x, n)   ((((x)) >> ((n))) & 1)

Functions
static ut8	cr16_get_opcode_low (const ut16 instr)
static ut8	cr16_get_opcode_hi (const ut16 instr)
static ut8	cr16_get_opcode_i (const ut16 instr)
static ut8	cr16_get_short_imm (const ut16 instr)
static ut8	cr16_get_dstreg (const ut16 instr)
static ut8	cr16_get_srcreg (const ut16 instr)
static int	cr16_check_instrs_4bit_bndrs (const ut8 opcode)
static ut16	cr16_get_opcode_159_0 (const ut16 opc)
static int	cr16_check_reg_boundaries (const ut8 reg)
static int	cr16_print_ld_sw_opcode (struct cr16_cmd *cmd, ut16 instr)
static int	cr16_print_short_reg (struct cr16_cmd *cmd, ut8 sh, ut8 reg)
static int	cr16_print_reg_short (struct cr16_cmd *cmd, ut8 sh, ut8 reg)
static int	cr16_print_med_reg (struct cr16_cmd *cmd, ut16 med, ut8 reg)
static int	cr16_print_reg_med (struct cr16_cmd *cmd, ut16 med, ut8 reg)
static int	cr16_print_short_abs18 (struct cr16_cmd *cmd, ut8 sh, ut32 abs)
static int	cr16_print_reg_reg_rel (struct cr16_cmd *cmd, ut8 src, ut16 rel, ut8 dst, ut8 swap)
static int	cr16_print_short_reg_rel (struct cr16_cmd *cmd, ut8 sh, ut16 rel, ut8 reg)
static int	cr16_print_reg_rel_reg (struct cr16_cmd *cmd, ut32 rel, ut8 srcreg, ut8 dstreg, ut8 swap)
static int	cr16_print_long_reg (struct cr16_cmd *cmd, ut32 l, ut8 reg, ut8 swap)
static int	cr16_print_longregreg_reg (struct cr16_cmd *cmd, ut32 rel, ut8 src, ut8 dst, ut8 swap)
static int	cr16_print_reg_reg (struct cr16_cmd *cmd, ut8 src, ut8 dst)
static int	cr16_print_4biti_opcode (struct cr16_cmd *cmd, ut16 instr)
static int	cr16_print_4bit_opcode (struct cr16_cmd *cmd, ut16 instr)
static void	cr16_analysis_4bit_opcode (const ut16 in, struct cr16_cmd *cmd)
static int	cr16_decode_i_r (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_ld_st (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_slpr (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_r_r (const ut8 *instr, struct cr16_cmd *cmd, int len)
static ut8	cr16_get_cond (const ut16 c)
static int	cr16_decode_push_pop (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_jmp (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_bcond_br (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_bcond01i (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_misc (const ut8 *instr, struct cr16_cmd *cmd, int len)
static int	cr16_decode_bal (const ut8 *instr, struct cr16_cmd *cmd, int len)
int	cr16_decode_loadm_storm (const ut8 *instr, struct cr16_cmd *cmd, int len)
int	cr16_decode_movz (const ut8 *instr, struct cr16_cmd *cmd, int len)
int	cr16_decode_movd (const ut8 *instr, struct cr16_cmd *cmd, int len)
int	cr16_decode_muls (const ut8 *instr, struct cr16_cmd *cmd, int len)
int	cr16_decode_scond (const ut8 *instr, struct cr16_cmd *cmd, int len)
int	cr16_decode_biti (const ut8 *instr, struct cr16_cmd *cmd, int len)
int	cr16_decode_command (const ut8 *instr, struct cr16_cmd *cmd, int len)

Variables
static const char *	cr16_regs_names []
static const char *	instrs_4bit []
static const char *	cr16_conds []
static const char *	ld_sw []
static const char *	dedicated_regs []
static const char *	ops_biti []

Macro Definition Documentation

GET_BIT

#define GET_BIT	(		x,
			n
	)		((((x)) >> ((n))) & 1)

Definition at line 9 of file cr16_disas.c.

Function Documentation

cr16_analysis_4bit_opcode()

static void cr16_analysis_4bit_opcode ( const ut16  in, struct cr16_cmd *  cmd  )

inlinestatic

Definition at line 329 of file cr16_disas.c.

                                                                                  {
    switch (cr16_get_opcode_low(in)) {
    case CR16_ADDU:
    case CR16_ADD:
        cmd->type = CR16_TYPE_ADD;
        break;
    case CR16_BITI:
        cmd->type = CR16_TYPE_BIT;
        break;
    case CR16_MUL:
        cmd->type = CR16_TYPE_MUL;
        break;
    case CR16_SUBC:
    case CR16_SUB:
        cmd->type = CR16_TYPE_SUB;
        break;
    case CR16_CMP:
        cmd->type = CR16_TYPE_CMP;
        break;
    case CR16_XOR:
        cmd->type = CR16_TYPE_XOR;
        break;
    case CR16_OR:
        cmd->type = CR16_TYPE_OR;
        break;
    case CR16_ASHU:
    case CR16_LSH:
        cmd->type = CR16_TYPE_SHIFT;
        break;
    case CR16_MOV:
        cmd->type = CR16_TYPE_MOV;
        break;
    case CR16_AND:
        cmd->type = CR16_TYPE_AND;
        break;
    }
}

References cmd, CR16_ADD, CR16_ADDU, CR16_AND, CR16_ASHU, CR16_BITI, CR16_CMP, cr16_get_opcode_low(), CR16_LSH, CR16_MOV, CR16_MUL, CR16_OR, CR16_SUB, CR16_SUBC, CR16_TYPE_ADD, CR16_TYPE_AND, CR16_TYPE_BIT, CR16_TYPE_CMP, CR16_TYPE_MOV, CR16_TYPE_MUL, CR16_TYPE_OR, CR16_TYPE_SHIFT, CR16_TYPE_SUB, CR16_TYPE_XOR, CR16_XOR, and in.

Referenced by cr16_decode_i_r(), and cr16_decode_r_r().

cr16_check_instrs_4bit_bndrs()

static int cr16_check_instrs_4bit_bndrs ( const ut8  opcode )

inlinestatic

Definition at line 120 of file cr16_disas.c.

                                                                 {
    if (opcode >= sizeof(instrs_4bit) / sizeof(void *) || !instrs_4bit[opcode]) {
        return -1;
    }
    return 0;
}

References instrs_4bit.

Referenced by cr16_print_4bit_opcode(), and cr16_print_4biti_opcode().

cr16_check_reg_boundaries()

static int cr16_check_reg_boundaries ( const ut8  reg )

inlinestatic

Definition at line 131 of file cr16_disas.c.

                                                           {
    if (reg >= sizeof(cr16_regs_names) / sizeof(void *) || !cr16_regs_names[reg]) {
        return -1;
    }
    return 0;
}

References cr16_regs_names, and reg.

Referenced by cr16_decode_i_r(), cr16_print_long_reg(), cr16_print_longregreg_reg(), cr16_print_med_reg(), cr16_print_reg_med(), cr16_print_reg_reg(), cr16_print_reg_reg_rel(), cr16_print_reg_rel_reg(), cr16_print_reg_short(), cr16_print_short_reg(), and cr16_print_short_reg_rel().

cr16_decode_bal()

static int cr16_decode_bal ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 945 of file cr16_disas.c.

                                                                            {
    int ret = 4;
    ut16 c, disp16;
    ut32 disp32;
 
    if (len < 4) {
        return -1;
    }
    c = rz_read_le16(instr);
    disp16 = rz_read_at_le16(instr, 2);
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "bal");
 
    switch (c >> 9) {
    case CR16_BAL:
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,0x%x",
            cr16_regs_names[cr16_get_dstreg(c)], disp16);
        break;
    case CR16_TBIT_R_R:
        disp32 = disp16 | (((c >> 1) & 0xF) << 16);
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "(%s,%s),0x%08x",
            cr16_regs_names[cr16_get_dstreg(c) + 1],
            cr16_regs_names[cr16_get_dstreg(c)], disp32);
        break;
    default:
        return -1;
    }
 
    return ret;
}

References c, cmd, CR16_BAL, cr16_get_dstreg(), CR16_INSTR_MAXLEN, cr16_regs_names, CR16_TBIT_R_R, len, rz_read_at_le16(), rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_bcond01i()

static int cr16_decode_bcond01i ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 849 of file cr16_disas.c.

                                                                                 {
    ut16 c;
    int ret = 2;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if (!(c & 1)) {
        return -1;
    }
 
    if (c >> 14) {
        return -1;
    }
 
    switch ((c >> 6) & 0x3) {
    case 0x0:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s%c",
            "beq0", cr16_get_opcode_i(c) ? 'w' : 'b');
        break;
    case 0x1:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s%c",
            "beq1", cr16_get_opcode_i(c) ? 'w' : 'b');
        break;
    case 0x2:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s%c",
            "bne0", cr16_get_opcode_i(c) ? 'w' : 'b');
        break;
    case 0x3:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s%c",
            "bne1", cr16_get_opcode_i(c) ? 'w' : 'b');
        break;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,0x%x",
        cr16_regs_names[cr16_get_dstreg(c)],
        (c >> 1) & 0xF);
 
    cmd->type = CR16_TYPE_BCOND;
 
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_opcode_i(), CR16_INSTR_MAXLEN, cr16_regs_names, CR16_TYPE_BCOND, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_bcond_br()

static int cr16_decode_bcond_br ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 742 of file cr16_disas.c.

                                                                                 {
    int ret = 2;
 
    ut16 c, disp;
    ut32 disp32;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if (c & 0x1) {
        return -1;
    }
 
    if (!(c >> 14) && cr16_get_opcode_low(c) != 0xA) {
        return -1;
    }
 
    if (((c >> 5) & 0xF) == 0xE) {
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "br");
        if (((c >> 1) & 0x7) == 0x7) {
            if (len < 4) {
                return -1;
            }
            disp = rz_read_at_le16(instr, 2);
 
            disp32 = disp | (((c >> 4) & 0x1) << 16);
            ret = 4;
            snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
                "0x%08x", disp32);
 
            if (disp32 & 0x10000) {
                disp32 |= 0xFFFE0000;
                cmd->reladdr = (st32)disp32;
            } else {
                cmd->reladdr = disp32;
            }
        } else {
            if (cr16_get_opcode_i(c)) {
                ret = 4;
                if (len < 4) {
                    return -1;
                }
                disp = rz_read_at_le16(instr, 2);
                disp32 = disp | (((c >> 1) & 0x7) << 17) | (((c >> 4) & 1) << 16);
                if (disp32 & 0x80000) {
                    disp32 |= 0xFFF00000;
                    cmd->reladdr = (st32)disp32;
                } else {
                    cmd->reladdr = disp32;
                }
                snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "0x%08x", disp32);
            } else {
                disp = (c & 0x1F) | ((c >> 4) & 0x1E0);
 
                if (disp & 0x0100) {
                    disp |= 0xFE00;
                    cmd->reladdr = (st16)disp;
                } else {
                    cmd->reladdr = disp;
                }
 
                snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "0x%04x", disp);
            }
        }
        cmd->type = CR16_TYPE_JUMP;
    } else {
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "b%s",
            cr16_conds[cr16_get_cond(c)]);
        if (c & 0x1) {
            return -1;
        }
 
        if ((c >> 8) == CR16_BCOND_2) {
            if (len < 4) {
                return -1;
            }
            disp = rz_read_at_le16(instr, 2);
            disp32 = disp | (GET_BIT(c, 4) << 16);
            if (disp32 & 0x80000) {
                disp32 |= 0xFFF00000;
                cmd->reladdr = (st32)disp32;
            } else {
                cmd->reladdr = disp32;
            }
            ret = 4;
        } else {
            disp = (c & 0x1F) | ((c >> 4) & 0x1E0);
 
            if (disp & 0x0100) {
                disp |= 0xFE00;
                cmd->reladdr = (st16)disp;
            } else {
                cmd->reladdr = disp;
            }
 
            disp32 = disp;
        }
 
        cmd->type = CR16_TYPE_BCOND;
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "0x%04x", disp32);
    }
 
    return ret;
}

References c, cmd, CR16_BCOND_2, cr16_get_cond(), cr16_get_opcode_i(), cr16_get_opcode_low(), CR16_INSTR_MAXLEN, CR16_TYPE_BCOND, CR16_TYPE_JUMP, GET_BIT, len, rz_read_at_le16(), rz_read_le16(), snprintf, st16, and st32.

Referenced by cr16_decode_command().

cr16_decode_biti()

int cr16_decode_biti	(	const ut8 *	instr,
		struct cr16_cmd *	cmd,
		int	len
	)

Definition at line 1118 of file cr16_disas.c.

                                                                      {
    int ret = 2;
    ut32 abs18;
    ut16 c, disp16;
    ut8 reg, position;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if (((c >> 6) & 0x3) == 0x3) {
        return -1;
    }
 
    reg = cr16_get_dstreg(c);
    position = cr16_get_srcreg(c);
 
    if (!(reg & 0x6)) {
        return -1;
    }
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s%c",
        ops_biti[(c >> 6) & 0x3],
        cr16_get_opcode_i(c) ? 'w' : 'b');
 
    switch (((c >> 13) & 0x2) | (c & 0x1)) {
    case 0x0:
        ret = 4;
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
 
        abs18 = disp16 | ((reg & 0x1) << 16) | ((reg >> 3) << 17);
 
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "$0x%02x,0x%08x", position, abs18);
 
        break;
    case 0x1:
        ret = 4;
 
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
 
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "$0x%02x,0x%04x(%s)", position,
            disp16, cr16_regs_names[reg & 0x9]);
 
        break;
    case 0x3:
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "$0x%02x,0(%s)", position,
            cr16_regs_names[reg & 0x9]);
        break;
    default:
        ret = -1;
    }
 
    cmd->type = CR16_TYPE_BIT;
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_opcode_i(), cr16_get_srcreg(), CR16_INSTR_MAXLEN, cr16_regs_names, CR16_TYPE_BIT, len, ops_biti, reg, rz_read_at_le16(), rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_command()

int cr16_decode_command	(	const ut8 *	instr,
		struct cr16_cmd *	cmd,
		int	len
	)

Definition at line 1184 of file cr16_disas.c.

                                                                         {
    int ret;
    ut16 in;
    if (len < 2) {
        return -1;
    }
    in = rz_read_le16(instr);
 
    switch (cr16_get_opcode_low(in)) {
    case CR16_MOV:
    case CR16_ADD:
    case CR16_ADDU:
    case CR16_ADDC:
    case CR16_MUL:
    case CR16_SUB:
    case CR16_SUBC:
    case CR16_CMP:
    case CR16_AND:
    case CR16_OR:
    case CR16_XOR:
    case CR16_ASHU:
    case CR16_LSH:
        switch (cr16_get_opcode_hi(in)) {
        case CR16_I_R:
            ret = cr16_decode_i_r(instr, cmd, len);
            break;
        case CR16_R_R:
            ret = cr16_decode_r_r(instr, cmd, len);
            break;
        default:
            ret = -1;
        }
        if (ret == -1 && cr16_get_opcode_low(in) == CR16_CMP) {
            ret = cr16_decode_scond(instr, cmd, len);
        }
        break;
    case CR16_BCOND01:
        ret = cr16_decode_bcond01i(instr, cmd, len);
        break;
    case CR16_BITI:
        ret = cr16_decode_biti(instr, cmd, len);
        break;
    default:
        ret = -1;
    }
 
    if (ret != -1) {
        return ret;
    }
 
    switch ((in >> 13)) {
    case 0x2:
    case 0x0:
        ret = cr16_decode_bcond_br(instr, cmd, len);
        break;
    }
 
    if (ret != -1) {
        return ret;
    }
 
    switch (in >> 9) {
    case CR16_LPR:
    case CR16_SPR:
        ret = cr16_decode_slpr(instr, cmd, len);
        break;
    case CR16_TBIT_R_R:
        ret = cr16_decode_r_r(instr, cmd, len);
        if (ret == -1) {
            ret = cr16_decode_bal(instr, cmd, len);
        }
        break;
    case CR16_TBIT_I_R:
        ret = cr16_decode_i_r(instr, cmd, len);
        break;
    case CR16_BAL:
        ret = cr16_decode_bal(instr, cmd, len);
        break;
    case CR16_JUMP:
    case CR16_JAL:
    case 0x0B:
        ret = cr16_decode_jmp(instr, cmd, len);
        if (ret == -1) {
            ret = cr16_decode_bcond_br(instr, cmd, len);
        }
        break;
    case CR16_MOVXB:
    case CR16_MOVZB:
        ret = cr16_decode_movz(instr, cmd, len);
        break;
    case CR16_MULSB:
    case CR16_MULSW:
    case CR16_MULUW:
        ret = cr16_decode_muls(instr, cmd, len);
        break;
    }
 
    if (ret != -1) {
        return ret;
    }
 
    switch (in >> 7) {
    case CR16_PUSH:
    case CR16_POP:
    case CR16_POPRET_1:
    case CR16_POPRET_2:
        ret = cr16_decode_push_pop(instr, cmd, len);
        break;
    case CR16_LOADM:
    case CR16_STORM:
        ret = cr16_decode_loadm_storm(instr, cmd, len);
        break;
    }
 
    if (ret != -1) {
        return ret;
    }
 
    switch (in >> 10) {
    case CR16_MOVD:
        ret = cr16_decode_movd(instr, cmd, len);
        break;
    }
 
    if (ret != -1) {
        return ret;
    }
 
    ret = cr16_decode_misc(instr, cmd, len);
 
    if (ret != -1) {
        return ret;
    }
 
    switch (cr16_get_opcode_hi(in)) {
    case 0x2:
    case 0x3:
    case 0x1:
    case 0x0:
        ret = cr16_decode_ld_st(instr, cmd, len);
        break;
    }
 
    if (ret != -1) {
        return ret;
    }
    return ret;
}

References cmd, CR16_ADD, CR16_ADDC, CR16_ADDU, CR16_AND, CR16_ASHU, CR16_BAL, CR16_BCOND01, CR16_BITI, CR16_CMP, cr16_decode_bal(), cr16_decode_bcond01i(), cr16_decode_bcond_br(), cr16_decode_biti(), cr16_decode_i_r(), cr16_decode_jmp(), cr16_decode_ld_st(), cr16_decode_loadm_storm(), cr16_decode_misc(), cr16_decode_movd(), cr16_decode_movz(), cr16_decode_muls(), cr16_decode_push_pop(), cr16_decode_r_r(), cr16_decode_scond(), cr16_decode_slpr(), cr16_get_opcode_hi(), cr16_get_opcode_low(), CR16_I_R, CR16_JAL, CR16_JUMP, CR16_LOADM, CR16_LPR, CR16_LSH, CR16_MOV, CR16_MOVD, CR16_MOVXB, CR16_MOVZB, CR16_MUL, CR16_MULSB, CR16_MULSW, CR16_MULUW, CR16_OR, CR16_POP, CR16_POPRET_1, CR16_POPRET_2, CR16_PUSH, CR16_R_R, CR16_SPR, CR16_STORM, CR16_SUB, CR16_SUBC, CR16_TBIT_I_R, CR16_TBIT_R_R, CR16_XOR, in, len, and rz_read_le16().

Referenced by cr16_op(), and disassemble().

cr16_decode_i_r()

static int cr16_decode_i_r ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

inlinestatic

Definition at line 367 of file cr16_disas.c.

                                                                                   {
    int ret = 2;
    ut16 in, immed, dstreg;
 
    if (len < 2) {
        return -1;
    }
    in = rz_read_le16(instr);
 
    if (in == 0x0200) {
        return -1;
    }
 
    if (((in >> 9) != CR16_TBIT_I_R) && ((in >> 9) != CR16_TBIT_R_R)) {
        if (cr16_print_4biti_opcode(cmd, in)) {
            return -1;
        }
        cr16_analysis_4bit_opcode(in, cmd);
    } else {
        if (cr16_print_4bit_opcode(cmd, in)) {
            return -1;
        }
    }
 
    switch ((in & 0x1F) ^ 0x11) {
    case 0:
        if ((in & 0x1) == 0x1) {
            if (len < 4) {
                return -1;
            }
            immed = rz_read_at_le16(instr, 2);
            ret = 4;
        } else {
            immed = cr16_get_short_imm(in);
        }
        if (((in >> 9) != CR16_TBIT_I_R) && ((in >> 9) != CR16_TBIT_R_R)) {
            if (cr16_print_med_reg(cmd, immed, cr16_get_dstreg(in))) {
                return -1;
            }
        } else {
            if (cr16_print_reg_med(cmd, immed, cr16_get_dstreg(in))) {
                return -1;
            }
        }
        break;
    default:
        dstreg = cr16_get_dstreg(in);
 
        if (cr16_check_reg_boundaries(dstreg)) {
            ret = -1;
            break;
        }
 
        if (((in >> 9) != CR16_TBIT_I_R) && ((in >> 9) != CR16_TBIT_R_R)) {
            if (cr16_print_short_reg(cmd, cr16_get_short_imm(in),
                    cr16_get_dstreg(in))) {
                return -1;
            }
        } else {
            if (cr16_print_reg_short(cmd, cr16_get_short_imm(in),
                    cr16_get_dstreg(in))) {
                return -1;
            }
        }
        break;
    }
 
    return ret;
}

References cmd, cr16_analysis_4bit_opcode(), cr16_check_reg_boundaries(), cr16_get_dstreg(), cr16_get_short_imm(), cr16_print_4bit_opcode(), cr16_print_4biti_opcode(), cr16_print_med_reg(), cr16_print_reg_med(), cr16_print_reg_short(), cr16_print_short_reg(), CR16_TBIT_I_R, CR16_TBIT_R_R, in, len, rz_read_at_le16(), and rz_read_le16().

Referenced by cr16_decode_command().

cr16_decode_jmp()

static int cr16_decode_jmp ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 684 of file cr16_disas.c.

                                                                            {
    ut16 c;
    int ret = 2;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    switch (c >> 9) {
    case CR16_JUMP:
        if (((c >> 5) & 0xf) == 0xE) {
            snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "jump");
        } else {
            snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "j%s",
                cr16_conds[cr16_get_dstreg(c)]);
        }
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s",
            cr16_regs_names[cr16_get_srcreg(c)]);
        break;
    case CR16_JAL:
        if (!(c & 1)) {
            ret = -1;
            break;
        }
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "jal");
        cr16_print_reg_reg(cmd, cr16_get_dstreg(c), cr16_get_srcreg(c));
        cmd->type = CR16_TYPE_JUMP_UNK;
        break;
    case 0x0B:
        if (!(c & 1)) {
            strncpy(cmd->instr, "jal", CR16_INSTR_MAXLEN - 1);
            snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "(%s,%s),(%s,%s)",
                cr16_regs_names[cr16_get_dstreg(c) + 1],
                cr16_regs_names[cr16_get_dstreg(c)],
                cr16_regs_names[cr16_get_srcreg(c) + 1],
                cr16_regs_names[cr16_get_srcreg(c)]);
        } else if (cr16_get_dstreg(c) != 0xE) {
            snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "j%s",
                cr16_conds[cr16_get_dstreg(c)]);
            snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "(%s,%s)",
                cr16_regs_names[cr16_get_srcreg(c) + 1],
                cr16_regs_names[cr16_get_srcreg(c)]);
        } else {
            strncpy(cmd->instr, "jump", CR16_INSTR_MAXLEN - 1);
            snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "(%s,%s)",
                cr16_regs_names[cr16_get_srcreg(c) + 1],
                cr16_regs_names[cr16_get_srcreg(c)]);
        }
        break;
    default:
        return -1;
    }
 
    cmd->type = CR16_TYPE_JUMP_UNK;
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_srcreg(), CR16_INSTR_MAXLEN, CR16_JAL, CR16_JUMP, cr16_print_reg_reg(), cr16_regs_names, CR16_TYPE_JUMP_UNK, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_ld_st()

static int cr16_decode_ld_st ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

inlinestatic

Definition at line 437 of file cr16_disas.c.

                                                                                     {
    int ret = 2;
    ut32 disp32;
    ut16 disp16;
 
    if (len < 2) {
        return -1;
    }
    ut16 c = rz_read_le16(instr);
 
    if (cr16_print_ld_sw_opcode(cmd, c)) {
        return -1;
    }
 
    switch (cr16_get_opcode_159_0(c) & (~0x20)) {
    case 0x04:
        ret = 4;
        if ((c & 0xC0) != 0xC0) {
            ret = -1;
            break;
        }
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
 
        disp32 = disp16 | ((c & 0x0100) << 9) | ((c & 0x0020) << 11);
 
        cr16_print_short_abs18(cmd, cr16_get_srcreg(c), disp32);
        break;
    case 0x05:
        ret = 4;
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
 
        if (cr16_print_short_reg_rel(cmd, cr16_get_srcreg(c),
                disp16, cr16_get_dstreg(c) & 0x9)) {
            return -1;
        }
        break;
    case 0x45:
        if (!(c & 0x1) || ((c >> 6) & 0x3) != 0x3) {
            ret = -1;
            break;
        }
        if (cr16_print_short_reg_rel(cmd, cr16_get_srcreg(c), 0,
                cr16_get_dstreg(c) & 0x9)) {
            return -1;
        }
        break;
    default:
        ret = -1;
    }
 
    if (ret != -1) {
        return ret;
    }
 
    switch ((c >> 11) & (~0x4)) {
    case 0x12:
        ret = 4;
        if (!(c & 1)) {
            ret = -1;
            break;
        }
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
        disp32 = disp16 | (((c >> 9) & 0x3) << 16);
 
        cr16_print_reg_rel_reg(cmd, disp32, cr16_get_srcreg(c),
            cr16_get_dstreg(c), 0);
        break;
 
    case 0x13:
        ret = 4;
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
        disp32 = disp16 | (((c >> 9) & 0x3) << 16);
 
        if (cr16_get_srcreg(c) == 0xF) {
            cr16_print_long_reg(cmd, disp32, cr16_get_dstreg(c), 0);
        } else {
            cr16_print_longregreg_reg(cmd, disp32, cr16_get_srcreg(c),
                cr16_get_dstreg(c), 0);
        }
        break;
    case 0x1B:
        ret = 4;
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
        disp32 = disp16 | (((c >> 9) & 0x3) << 16);
 
        if (cr16_get_srcreg(c) == 0xF) {
            cr16_print_long_reg(cmd, disp32, cr16_get_dstreg(c), 1);
        } else {
            cr16_print_longregreg_reg(cmd, disp32, cr16_get_dstreg(c),
                cr16_get_srcreg(c), 1);
        }
        break;
    case 0x1A:
        ret = 4;
        if (len < 4) {
            return -1;
        }
        disp16 = rz_read_at_le16(instr, 2);
        disp32 = disp16 | (((c >> 9) & 0x3) << 16);
 
        cr16_print_reg_rel_reg(cmd, disp32, cr16_get_srcreg(c),
            cr16_get_dstreg(c), 1);
 
        break;
    default:
        ret = -1;
    }
 
    if (ret != -1) {
        return ret;
    }
 
    switch (c >> 14) {
    case 0x3:
        ret = 2;
        disp16 = (c & 0x1) | ((c >> 8) & 0x1E);
        cr16_print_reg_reg_rel(cmd, cr16_get_srcreg(c),
            disp16, cr16_get_dstreg(c), 1);
        break;
    case 0x2:
        ret = 2;
        disp16 = (c & 0x1) | ((c >> 8) & 0x1E);
        cr16_print_reg_reg_rel(cmd, cr16_get_srcreg(c),
            disp16, cr16_get_dstreg(c), 0);
        break;
    default:
        ret = -1;
    }
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_opcode_159_0(), cr16_get_srcreg(), cr16_print_ld_sw_opcode(), cr16_print_long_reg(), cr16_print_longregreg_reg(), cr16_print_reg_reg_rel(), cr16_print_reg_rel_reg(), cr16_print_short_abs18(), cr16_print_short_reg_rel(), len, rz_read_at_le16(), and rz_read_le16().

Referenced by cr16_decode_command().

cr16_decode_loadm_storm()

int cr16_decode_loadm_storm	(	const ut8 *	instr,
		struct cr16_cmd *	cmd,
		int	len
	)

Definition at line 976 of file cr16_disas.c.

                                                                             {
    int ret = 2;
    ut16 c;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if ((c & 0x1F) != 4) {
        return -1;
    }
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s",
        instrs_4bit[c >> 7]);
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "$0x%x",
        ((c >> 5) & 0x3) + 1);
 
    cmd->type = CR16_TYPE_MOV;
 
    return ret;
}

References c, cmd, CR16_INSTR_MAXLEN, CR16_TYPE_MOV, instrs_4bit, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_misc()

static int cr16_decode_misc ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 894 of file cr16_disas.c.

                                                                             {
    ut16 c;
    int ret = 2;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    cmd->operands[0] = '\0';
    switch (c) {
    case CR16_RETX:
        strncpy(cmd->instr, "retx", CR16_INSTR_MAXLEN - 1);
        cmd->type = CR16_TYPE_RETX;
        break;
    case CR16_DI:
        strncpy(cmd->instr, "di", CR16_INSTR_MAXLEN - 1);
        cmd->type = CR16_TYPE_DI;
        break;
    case CR16_EI:
        strncpy(cmd->instr, "ei", CR16_INSTR_MAXLEN - 1);
        cmd->type = CR16_TYPE_EI;
        break;
    case CR16_NOP:
        strncpy(cmd->instr, "nop", CR16_INSTR_MAXLEN - 1);
        cmd->type = CR16_TYPE_NOP;
        break;
    case CR16_WAIT:
        strncpy(cmd->instr, "wait", CR16_INSTR_MAXLEN - 1);
        cmd->type = CR16_TYPE_WAIT;
        break;
    case CR16_EWAIT:
        strncpy(cmd->instr, "eiwait", CR16_INSTR_MAXLEN - 1);
        cmd->type = CR16_TYPE_EWAIT;
        break;
    default:
        switch (c >> 5) {
        case 0x3DF:
            strncpy(cmd->instr, "excp", CR16_INSTR_MAXLEN - 1);
            snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
                "0x%x", (c >> 1) & 0xF);
            cmd->type = CR16_TYPE_EXCP;
            break;
        default:
            ret = -1;
        }
    }
 
    return ret;
}

References c, cmd, CR16_DI, CR16_EI, CR16_EWAIT, CR16_INSTR_MAXLEN, CR16_NOP, CR16_RETX, CR16_TYPE_DI, CR16_TYPE_EI, CR16_TYPE_EWAIT, CR16_TYPE_EXCP, CR16_TYPE_NOP, CR16_TYPE_RETX, CR16_TYPE_WAIT, CR16_WAIT, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_movd()

int cr16_decode_movd	(	const ut8 *	instr,
		struct cr16_cmd *	cmd,
		int	len
	)

Definition at line 1030 of file cr16_disas.c.

                                                                      {
    int ret = 4;
    ut16 c;
    ut16 imm;
    ut32 imm32;
 
    if (len < 4) {
        return -1;
    }
    c = rz_read_le16(instr);
    imm = rz_read_at_le16(instr, 2);
 
    if (c & 1) {
        return -1;
    }
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "movd");
 
    imm32 = imm | (((c >> 4) & 1) << 16) | (((c >> 9) & 1) << 20) | (((c >> 1) & 0x7) << 17);
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "$0x%08x,(%s,%s)", imm32,
        cr16_regs_names[((c >> 5) & 0xF) + 1],
        cr16_regs_names[(c >> 5) & 0xF]);
 
    return ret;
}

References c, cmd, CR16_INSTR_MAXLEN, cr16_regs_names, imm, len, rz_read_at_le16(), rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_movz()

int cr16_decode_movz	(	const ut8 *	instr,
		struct cr16_cmd *	cmd,
		int	len
	)

Definition at line 999 of file cr16_disas.c.

                                                                      {
    int ret = 2;
    ut16 c;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if (c & 1) {
        return -1;
    }
 
    switch (c >> 9) {
    case CR16_MOVXB:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "movxb");
        break;
    case CR16_MOVZB:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "movzb");
        break;
    default:
        return -1;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,%s",
        cr16_regs_names[cr16_get_srcreg(c)],
        cr16_regs_names[cr16_get_dstreg(c)]);
 
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_srcreg(), CR16_INSTR_MAXLEN, CR16_MOVXB, CR16_MOVZB, cr16_regs_names, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_muls()

int cr16_decode_muls	(	const ut8 *	instr,
		struct cr16_cmd *	cmd,
		int	len
	)

Definition at line 1056 of file cr16_disas.c.

                                                                      {
    int ret = 2;
    ut16 c;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    switch (c >> 9) {
    case CR16_MULSB:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "mulsb");
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,%s",
            cr16_regs_names[cr16_get_srcreg(c)],
            cr16_regs_names[cr16_get_dstreg(c)]);
        break;
    case CR16_MULSW:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "mulsw");
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,(%s,%s)",
            cr16_regs_names[cr16_get_srcreg(c)],
            cr16_regs_names[cr16_get_dstreg(c) + 1],
            cr16_regs_names[cr16_get_dstreg(c)]);
        break;
    case CR16_MULUW:
        if (c & 0x000C) {
            return -1;
        }
 
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "muluw");
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,(%s,%s)",
            cr16_regs_names[cr16_get_srcreg(c)],
            cr16_regs_names[cr16_get_dstreg(c) + 1],
            cr16_regs_names[cr16_get_dstreg(c)]);
        break;
    }
 
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_srcreg(), CR16_INSTR_MAXLEN, CR16_MULSB, CR16_MULSW, CR16_MULUW, cr16_regs_names, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_push_pop()

static int cr16_decode_push_pop ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 651 of file cr16_disas.c.

                                                                                 {
    int ret = 2;
    ut16 c;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if ((c & 1)) {
        return -1;
    }
 
    switch (c >> 7) {
    case CR16_PUSH:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "push");
        break;
    case CR16_POP:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "pop");
        break;
    case CR16_POPRET_1:
    case CR16_POPRET_2:
        snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "popret");
        break;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "$0x%x,%s",
        ((c >> 5) & 0x3) + 1,
        cr16_regs_names[(c >> 1) & 0xF]);
 
    return ret;
}

References c, cmd, CR16_INSTR_MAXLEN, CR16_POP, CR16_POPRET_1, CR16_POPRET_2, CR16_PUSH, cr16_regs_names, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_r_r()

static int cr16_decode_r_r ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 616 of file cr16_disas.c.

                                                                            {
    int ret = 2;
    ut16 c;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if (!(c & 0x1)) {
        return -1;
    }
 
    if (((c >> 9) != CR16_TBIT_I_R) && ((c >> 9) != CR16_TBIT_R_R)) {
        if (cr16_print_4biti_opcode(cmd, c)) {
            return -1;
        }
        cr16_analysis_4bit_opcode(c, cmd);
    } else {
        if (cr16_print_4bit_opcode(cmd, c)) {
            return -1;
        }
    }
 
    if (cr16_print_reg_reg(cmd, cr16_get_srcreg(c), cr16_get_dstreg(c))) {
        return -1;
    }
 
    return ret;
}

References c, cmd, cr16_analysis_4bit_opcode(), cr16_get_dstreg(), cr16_get_srcreg(), cr16_print_4bit_opcode(), cr16_print_4biti_opcode(), cr16_print_reg_reg(), CR16_TBIT_I_R, CR16_TBIT_R_R, len, and rz_read_le16().

Referenced by cr16_decode_command().

cr16_decode_scond()

int cr16_decode_scond	(	const ut8 *	instr,
		struct cr16_cmd *	cmd,
		int	len
	)

Definition at line 1095 of file cr16_disas.c.

                                                                       {
    int ret = 2;
    ut16 c;
 
    if (len < 2) {
        return -1;
    }
    c = rz_read_le16(instr);
 
    if (c & 1) {
        return -1;
    }
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "s%s",
        cr16_conds[cr16_get_dstreg(c)]);
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s",
        cr16_regs_names[cr16_get_srcreg(c)]);
 
    cmd->type = CR16_TYPE_SCOND;
 
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_srcreg(), CR16_INSTR_MAXLEN, cr16_regs_names, CR16_TYPE_SCOND, len, rz_read_le16(), and snprintf.

Referenced by cr16_decode_command().

cr16_decode_slpr()

static int cr16_decode_slpr ( const ut8 *  instr, struct cr16_cmd *  cmd, int  len  )

static

Definition at line 583 of file cr16_disas.c.

                                                                             {
    int ret = 2;
 
    if (len < 2) {
        return -1;
    }
    ut16 c = rz_read_le16(instr);
 
    const char *ins = instrs_4bit[c >> 9];
    if (ins) {
        rz_str_ncpy(cmd->instr, ins, sizeof(cmd->instr) - 1);
    } else {
        *cmd->instr = 0;
    }
 
    switch (c >> 9) {
    case CR16_LPR:
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "%s,%s", cr16_regs_names[cr16_get_srcreg(c)],
            dedicated_regs[cr16_get_dstreg(c)]);
        break;
    case CR16_SPR:
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "%s,%s", dedicated_regs[cr16_get_dstreg(c)],
            cr16_regs_names[cr16_get_srcreg(c)]);
        break;
    }
 
    cmd->type = CR16_TYPE_SLPR;
 
    return ret;
}

References c, cmd, cr16_get_dstreg(), cr16_get_srcreg(), CR16_INSTR_MAXLEN, CR16_LPR, cr16_regs_names, CR16_SPR, CR16_TYPE_SLPR, dedicated_regs, instrs_4bit, len, rz_read_le16(), rz_str_ncpy(), and snprintf.

Referenced by cr16_decode_command().

cr16_get_cond()

static ut8 cr16_get_cond ( const ut16  c )

inlinestatic

Definition at line 647 of file cr16_disas.c.

                                              {
    return ((c >> 5) & 0xF);
}

References c.

Referenced by cr16_decode_bcond_br().

cr16_get_dstreg()

static ut8 cr16_get_dstreg ( const ut16  instr )

inlinestatic

Definition at line 112 of file cr16_disas.c.

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

Referenced by cr16_decode_bal(), cr16_decode_bcond01i(), cr16_decode_biti(), cr16_decode_i_r(), cr16_decode_jmp(), cr16_decode_ld_st(), cr16_decode_movz(), cr16_decode_muls(), cr16_decode_r_r(), cr16_decode_scond(), and cr16_decode_slpr().

cr16_get_opcode_159_0()

static ut16 cr16_get_opcode_159_0 ( const ut16  opc )

inlinestatic

Definition at line 127 of file cr16_disas.c.

                                                         {
    return (opc & 1) | ((opc >> 8) & 0xFE);
}

References opc.

Referenced by cr16_decode_ld_st().

cr16_get_opcode_hi()

static ut8 cr16_get_opcode_hi ( const ut16  instr )

inlinestatic

Definition at line 100 of file cr16_disas.c.

                                                       {
    return instr >> 14;
}

Referenced by cr16_decode_command().

cr16_get_opcode_i()

static ut8 cr16_get_opcode_i ( const ut16  instr )

inlinestatic

Definition at line 104 of file cr16_disas.c.

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

Referenced by cr16_decode_bcond01i(), cr16_decode_bcond_br(), cr16_decode_biti(), cr16_print_4biti_opcode(), and cr16_print_ld_sw_opcode().

cr16_get_opcode_low()

static ut8 cr16_get_opcode_low ( const ut16  instr )

inlinestatic

Definition at line 96 of file cr16_disas.c.

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

Referenced by cr16_analysis_4bit_opcode(), cr16_decode_bcond_br(), cr16_decode_command(), cr16_print_4bit_opcode(), and cr16_print_4biti_opcode().

cr16_get_short_imm()

static ut8 cr16_get_short_imm ( const ut16  instr )

inlinestatic

Definition at line 108 of file cr16_disas.c.

                                                       {
    return instr & 0x1F;
}

Referenced by cr16_decode_i_r().

cr16_get_srcreg()

static ut8 cr16_get_srcreg ( const ut16  instr )

inlinestatic

Definition at line 116 of file cr16_disas.c.

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

Referenced by cr16_decode_biti(), cr16_decode_jmp(), cr16_decode_ld_st(), cr16_decode_movz(), cr16_decode_muls(), cr16_decode_r_r(), cr16_decode_scond(), and cr16_decode_slpr().

cr16_print_4bit_opcode()

static int cr16_print_4bit_opcode ( struct cr16_cmd *  cmd, ut16  instr  )

inlinestatic

Definition at line 318 of file cr16_disas.c.

                                                                           {
    if (cr16_check_instrs_4bit_bndrs(cr16_get_opcode_low(instr))) {
        return -1;
    }
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s",
        instrs_4bit[cr16_get_opcode_low(instr)]);
 
    return 0;
}

References cmd, cr16_check_instrs_4bit_bndrs(), cr16_get_opcode_low(), CR16_INSTR_MAXLEN, instrs_4bit, and snprintf.

Referenced by cr16_decode_i_r(), and cr16_decode_r_r().

cr16_print_4biti_opcode()

static int cr16_print_4biti_opcode ( struct cr16_cmd *  cmd, ut16  instr  )

inlinestatic

Definition at line 307 of file cr16_disas.c.

                                                                            {
    if (cr16_check_instrs_4bit_bndrs(cr16_get_opcode_low(instr))) {
        return -1;
    }
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s%c",
        instrs_4bit[cr16_get_opcode_low(instr)],
        cr16_get_opcode_i(instr) ? 'w' : 'b');
    return 0;
}

References cmd, cr16_check_instrs_4bit_bndrs(), cr16_get_opcode_i(), cr16_get_opcode_low(), CR16_INSTR_MAXLEN, instrs_4bit, and snprintf.

Referenced by cr16_decode_i_r(), and cr16_decode_r_r().

cr16_print_ld_sw_opcode()

static int cr16_print_ld_sw_opcode ( struct cr16_cmd *  cmd, ut16  instr  )

inlinestatic

Definition at line 138 of file cr16_disas.c.

                                                                            {
    ut8 opcode = instr >> 14;
 
    if (opcode >= sizeof(ld_sw) / sizeof(void *) || !ld_sw[opcode]) {
        return -1;
    }
 
    snprintf(cmd->instr, CR16_INSTR_MAXLEN - 1, "%s%c", ld_sw[opcode],
        cr16_get_opcode_i(instr) ? 'w' : 'b');
 
    cmd->type = CR16_TYPE_MOV;
 
    cmd->instr[CR16_INSTR_MAXLEN - 1] = '\0';
 
    return 0;
}

References cmd, cr16_get_opcode_i(), CR16_INSTR_MAXLEN, CR16_TYPE_MOV, ld_sw, and snprintf.

Referenced by cr16_decode_ld_st().

cr16_print_long_reg()

static int cr16_print_long_reg ( struct cr16_cmd *  cmd, ut32  l, ut8  reg, ut8  swap  )

inlinestatic

Definition at line 261 of file cr16_disas.c.

                                                                                       {
    if (cr16_check_reg_boundaries(reg)) {
        return -1;
    }
 
    if (swap) {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "%s,0x%08x", cr16_regs_names[reg], l);
    } else {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "0x%08x,%s", l, cr16_regs_names[reg]);
    }
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, reg, snprintf, and swap.

Referenced by cr16_decode_ld_st().

cr16_print_longregreg_reg()

static int cr16_print_longregreg_reg ( struct cr16_cmd *  cmd, ut32  rel, ut8  src, ut8  dst, ut8  swap  )

inlinestatic

Definition at line 277 of file cr16_disas.c.

                                          {
    if (cr16_check_reg_boundaries(src) || cr16_check_reg_boundaries(src + 1) || cr16_check_reg_boundaries(dst)) {
        return -1;
    }
 
    if (swap) {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "%s,0x%08x(%s,%s)", cr16_regs_names[src], rel,
            cr16_regs_names[dst + 1],
            cr16_regs_names[dst]);
    } else {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "0x%08x(%s,%s),%s", rel, cr16_regs_names[src + 1],
            cr16_regs_names[src], cr16_regs_names[dst]);
    }
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, dst, snprintf, src, and swap.

Referenced by cr16_decode_ld_st().

cr16_print_med_reg()

static int cr16_print_med_reg ( struct cr16_cmd *  cmd, ut16  med, ut8  reg  )

inlinestatic

Definition at line 177 of file cr16_disas.c.

                                                                              {
    if (cr16_check_reg_boundaries(reg)) {
        return -1;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
        "$0x%04x,%s", med, cr16_regs_names[reg]);
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, reg, and snprintf.

Referenced by cr16_decode_i_r().

cr16_print_reg_med()

static int cr16_print_reg_med ( struct cr16_cmd *  cmd, ut16  med, ut8  reg  )

inlinestatic

Definition at line 188 of file cr16_disas.c.

                                                                              {
    if (cr16_check_reg_boundaries(reg)) {
        return -1;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
        "%s,$0x%04x", cr16_regs_names[reg], med);
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, reg, and snprintf.

Referenced by cr16_decode_i_r().

cr16_print_reg_reg()

static int cr16_print_reg_reg ( struct cr16_cmd *  cmd, ut8  src, ut8  dst  )

inlinestatic

Definition at line 296 of file cr16_disas.c.

                                                                             {
    if (cr16_check_reg_boundaries(src) || cr16_check_reg_boundaries(dst)) {
        return -1;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,%s",
        cr16_regs_names[src], cr16_regs_names[dst]);
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, dst, snprintf, and src.

Referenced by cr16_decode_jmp(), and cr16_decode_r_r().

cr16_print_reg_reg_rel()

static int cr16_print_reg_reg_rel ( struct cr16_cmd *  cmd, ut8  src, ut16  rel, ut8  dst, ut8  swap  )

inlinestatic

Definition at line 206 of file cr16_disas.c.

                                          {
    if (cr16_check_reg_boundaries(dst) || cr16_check_reg_boundaries(src)) {
        return -1;
    }
 
    if (swap) {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,0x%04x(%s)",
            cr16_regs_names[dst], rel, cr16_regs_names[src]);
    } else {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "0x%04x(%s),%s",
            rel, cr16_regs_names[src], cr16_regs_names[dst]);
    }
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, dst, snprintf, src, and swap.

Referenced by cr16_decode_ld_st().

cr16_print_reg_rel_reg()

static int cr16_print_reg_rel_reg ( struct cr16_cmd *  cmd, ut32  rel, ut8  srcreg, ut8  dstreg, ut8  swap  )

inlinestatic

Definition at line 240 of file cr16_disas.c.

                                                {
    if (cr16_check_reg_boundaries(srcreg)) {
        return -1;
    }
 
    if (cr16_check_reg_boundaries(dstreg)) {
        return -1;
    }
 
    if (swap) {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "%s,0x%08x(%s)",
            cr16_regs_names[dstreg], rel, cr16_regs_names[srcreg]);
    } else {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1, "0x%08x(%s),%s",
            rel, cr16_regs_names[srcreg], cr16_regs_names[dstreg]);
    }
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, snprintf, and swap.

Referenced by cr16_decode_ld_st().

cr16_print_reg_short()

static int cr16_print_reg_short ( struct cr16_cmd *  cmd, ut8  sh, ut8  reg  )

inlinestatic

Definition at line 166 of file cr16_disas.c.

                                                                              {
    if (cr16_check_reg_boundaries(reg)) {
        return -1;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
        "%s,$0x%02x", cr16_regs_names[reg], sh);
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, reg, and snprintf.

Referenced by cr16_decode_i_r().

cr16_print_short_abs18()

static int cr16_print_short_abs18 ( struct cr16_cmd *  cmd, ut8  sh, ut32  abs  )

inlinestatic

Definition at line 199 of file cr16_disas.c.

                      {
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
        "$0x%02x,0x%08x", sh, abs);
    return 0;
}

References cmd, CR16_INSTR_MAXLEN, and snprintf.

Referenced by cr16_decode_ld_st().

cr16_print_short_reg()

static int cr16_print_short_reg ( struct cr16_cmd *  cmd, ut8  sh, ut8  reg  )

inlinestatic

Definition at line 155 of file cr16_disas.c.

                                                                              {
    if (cr16_check_reg_boundaries(reg)) {
        return -1;
    }
 
    snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
        "$0x%02x,%s", sh, cr16_regs_names[reg]);
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, reg, and snprintf.

Referenced by cr16_decode_i_r().

cr16_print_short_reg_rel()

static int cr16_print_short_reg_rel ( struct cr16_cmd *  cmd, ut8  sh, ut16  rel, ut8  reg  )

inlinestatic

Definition at line 223 of file cr16_disas.c.

                               {
    if (cr16_check_reg_boundaries(reg)) {
        return -1;
    }
 
    if (rel) {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "$0x%02x,0x%04x(%s)", sh, rel, cr16_regs_names[reg]);
    } else {
        snprintf(cmd->operands, CR16_INSTR_MAXLEN - 1,
            "$0x%02x,0(%s)", sh, cr16_regs_names[reg]);
    }
 
    return 0;
}

References cmd, cr16_check_reg_boundaries(), CR16_INSTR_MAXLEN, cr16_regs_names, reg, and snprintf.

Referenced by cr16_decode_ld_st().

Variable Documentation

cr16_conds

const char* cr16_conds[]

static

Initial value:

= {
    [CR16_COND_EQ] = "eq",
    [CR16_COND_NE] = "ne",
    [CR16_COND_GE] = "ge",
    [CR16_COND_CS] = "cs",
    [CR16_COND_CC] = "cc",
    [CR16_COND_HI] = "hi",
    [CR16_COND_LS] = "ls",
    [CR16_COND_LO] = "lo",
    [CR16_COND_HS] = "hs",
    [CR16_COND_GT] = "gt",
    [CR16_COND_LE] = "le",
    [CR16_COND_FS] = "fs",
    [CR16_COND_FC] = "fc",
    [CR16_COND_LT] = "lt",
}

Definition at line 54 of file cr16_disas.c.

cr16_regs_names

const char* cr16_regs_names[]

static

Initial value:

= {
    [CR16_R0] = "r0",
    [CR16_R1] = "r1",
    [CR16_R2] = "r2",
    [CR16_R3] = "r3",
    [CR16_R4] = "r4",
    [CR16_R5] = "r5",
    [CR16_R6] = "r6",
    [CR16_R7] = "r7",
    [CR16_R8] = "r8",
    [CR16_R9] = "r9",
    [CR16_R10] = "r10",
    [CR16_R11] = "r11",
    [CR16_R12] = "r12",
    [CR16_R13] = "r13",
    [CR16_RA] = "ra",
    [CR16_SP] = "sp",
    [CR16_LAST] = "XX",
}

Definition at line 11 of file cr16_disas.c.

Referenced by cr16_check_reg_boundaries(), cr16_decode_bal(), cr16_decode_bcond01i(), cr16_decode_biti(), cr16_decode_jmp(), cr16_decode_movd(), cr16_decode_movz(), cr16_decode_muls(), cr16_decode_push_pop(), cr16_decode_scond(), cr16_decode_slpr(), cr16_print_long_reg(), cr16_print_longregreg_reg(), cr16_print_med_reg(), cr16_print_reg_med(), cr16_print_reg_reg(), cr16_print_reg_reg_rel(), cr16_print_reg_rel_reg(), cr16_print_reg_short(), cr16_print_short_reg(), and cr16_print_short_reg_rel().

dedicated_regs

const char* dedicated_regs[]

static

Initial value:

= {
    [0x1] = "psr",
    [0x3] = "intbaseh",
    [0x4] = "intbasel",
    [0x5] = "cfg",
    [0x7] = "dsr",
    [0x9] = "dcr",
    [0xB] = "isp",
    [0xD] = "carl",
    [0xE] = "carh",
}

Definition at line 78 of file cr16_disas.c.

Referenced by cr16_decode_slpr().

instrs_4bit

const char* instrs_4bit[]

static

Initial value:

= {
    [CR16_ADD] = "add",
    [CR16_ADDU] = "addu",
    [CR16_MUL] = "mul",
    [CR16_ASHU] = "ashu",
    [CR16_LSH] = "lsh",
    [CR16_XOR] = "xor",
    [CR16_CMP] = "cmp",
    [CR16_AND] = "and",
    [CR16_ADDC] = "addc",
    [CR16_TBIT] = "tbit",
    [CR16_TBIT_R_R] = "tbit",
    [CR16_TBIT_I_R] = "tbit",
    [CR16_MOV] = "mov",
    [CR16_SUB] = "sub",
    [CR16_SUBC] = "subc",
    [CR16_OR] = "or",
    [CR16_LPR] = "lpr",
    [CR16_SPR] = "spr",
    [CR16_LOADM] = "loadm",
    [CR16_STORM] = "storm",
}

Definition at line 31 of file cr16_disas.c.

Referenced by cr16_check_instrs_4bit_bndrs(), cr16_decode_loadm_storm(), cr16_decode_slpr(), cr16_print_4bit_opcode(), and cr16_print_4biti_opcode().

ld_sw

const char* ld_sw[]

static

Initial value:

= {
    [0x0] = "stor",
    [0x1] = "stor",
    [0x2] = "load",
    [0x3] = "stor",
}

Definition at line 71 of file cr16_disas.c.

Referenced by cr16_print_ld_sw_opcode().

ops_biti

const char* ops_biti[]

static

Initial value:

= {
    [0x0] = "cbit",
    [0x1] = "sbit",
    [0x2] = "tbit",
}

Definition at line 90 of file cr16_disas.c.

Referenced by cr16_decode_biti().