propeller_disas.c File Reference

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

Go to the source code of this file.

Functions
static ut16	get_opcode (ut32 instr)
static ut16	get_opcode_ext (ut32 instr)
static ut16	get_src (ut32 instr)
static ut16	get_dst (ut32 instr)
static int	is_immediate (ut32 instr)
static int	decode_ext_cmd (struct propeller_cmd *cmd, ut32 instr)
static ut8	get_zcri (ut32 instr)
static ut8	get_con (ut32 instr)
static void	decode_prefix (struct propeller_cmd *cmd, ut32 instr)
static int	decode_jmp (struct propeller_cmd *cmd, ut32 instr)
int	propeller_decode_command (const ut8 *instr, struct propeller_cmd *cmd)

Variables
static const char *	instrs []
static const char *	ext_instrs []
static const char *	conditions []

Function Documentation

decode_ext_cmd()

static int decode_ext_cmd ( struct propeller_cmd *  cmd, ut32  instr  )

static

Definition at line 119 of file propeller_disas.c.

                                                                 {
    ut16 opcode;
 
    opcode = get_opcode_ext(instr);
 
    switch (opcode) {
    case PROP_CLKSET:
    case PROP_COGID:
    case PROP_COGINIT:
    case PROP_COGSTOP:
    case PROP_LOCKCLR:
    case PROP_LOCKNEW:
    case PROP_LOCKRET:
    case PROP_LOCKSET:
        snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1,
            "%s", ext_instrs[PROP_CLKSET]);
        snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
            "%d", get_dst(instr));
        return 4;
        break;
    }
 
    return -1;
}

References cmd, ext_instrs, get_dst(), get_opcode_ext(), PROP_CLKSET, PROP_COGID, PROP_COGINIT, PROP_COGSTOP, PROP_INSTR_MAXLEN, PROP_LOCKCLR, PROP_LOCKNEW, PROP_LOCKRET, PROP_LOCKSET, and snprintf.

Referenced by propeller_decode_command().

decode_jmp()

static int decode_jmp ( struct propeller_cmd *  cmd, ut32  instr  )

static

Definition at line 159 of file propeller_disas.c.

                                                             {
    ut16 opcode;
    ut8 zcri;
    int ret = 1;
    opcode = get_opcode(instr);
    switch (opcode) {
    case PROP_JMP:
        zcri = get_zcri(instr);
        if (zcri & 0x2) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1,
                "%s", "jmpret");
            if (zcri & 1) {
                cmd->dst = get_dst(instr) << 2;
                cmd->src = get_src(instr) << 2;
 
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "0x%x, #0x%x", get_dst(instr), get_src(instr) << 2);
            } else {
                cmd->src = get_src(instr) << 2;
                cmd->dst = get_dst(instr) << 2;
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "0x%x, 0x%x", get_dst(instr), get_src(instr) << 2);
            }
        } else {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1,
                "%s", "jmp");
            if (zcri & 1) {
                cmd->src = get_src(instr) << 2;
                cmd->immed = 1;
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "#0x%x", get_src(instr) << 2);
            } else {
                cmd->immed = 0;
                cmd->src = get_src(instr) << 2;
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1,
                    "0x%x", get_src(instr) << 2);
            }
        }
 
        ret = 4;
        break;
    }
 
    return ret;
}

References cmd, get_dst(), get_opcode(), get_src(), get_zcri(), PROP_INSTR_MAXLEN, PROP_JMP, and snprintf.

Referenced by propeller_decode_command().

decode_prefix()

static void decode_prefix ( struct propeller_cmd *  cmd, ut32  instr  )

static

Definition at line 152 of file propeller_disas.c.

                                                                 {
    ut8 prefix = (instr >> 18) & 0xF;
 
    snprintf(cmd->prefix, 15, "%s", conditions[prefix]);
    cmd->prefix[15] = '\0';
}

References cmd, conditions, prefix, and snprintf.

Referenced by propeller_decode_command().

get_con()

static ut8 get_con ( ut32  instr )

static

Definition at line 148 of file propeller_disas.c.

                               {
    return (instr >> 18) & 0xf;
}

Referenced by propeller_decode_command().

get_dst()

static ut16 get_dst ( ut32  instr )

static

Definition at line 111 of file propeller_disas.c.

                                {
    return ((instr >> 9) & 0x1FF) << 2;
}

Referenced by decode_ext_cmd(), decode_jmp(), and propeller_decode_command().

get_opcode()

static ut16 get_opcode ( ut32  instr )

static

Definition at line 99 of file propeller_disas.c.

                                   {
    return instr >> 26;
}

Referenced by decode_jmp(), and propeller_decode_command().

get_opcode_ext()

static ut16 get_opcode_ext ( ut32  instr )

static

Definition at line 103 of file propeller_disas.c.

                                       {
    return (instr & 0x7) | (instr >> 23);
}

Referenced by decode_ext_cmd().

get_src()

static ut16 get_src ( ut32  instr )

static

Definition at line 107 of file propeller_disas.c.

                                {
    return instr & 0x1FF;
}

Referenced by decode_jmp(), and propeller_decode_command().

get_zcri()

static ut8 get_zcri ( ut32  instr )

static

Definition at line 144 of file propeller_disas.c.

                                {
    return (instr >> 22) & 0xf;
}

Referenced by decode_jmp(), and propeller_decode_command().

is_immediate()

static int is_immediate ( ut32  instr )

static

Definition at line 115 of file propeller_disas.c.

                                    {
    return instr & 0x00400000;
}

Referenced by _6502_op(), msr(), propeller_decode_command(), query_step__new(), and ts_query__parse_pattern().

propeller_decode_command()

int propeller_decode_command	(	const ut8 *	instr,
		struct propeller_cmd *	cmd
	)

Definition at line 205 of file propeller_disas.c.

                                                                          {
    int ret = -1;
    ut32 in;
    ut16 opcode;
 
    in = rz_read_be32(instr);
 
    opcode = get_opcode(in);
 
    if (!get_con(in)) {
        snprintf(cmd->instr, PROP_INSTR_MAXLEN, "nop");
        cmd->operands[0] = '\0';
        return 4;
    }
 
    switch (opcode) {
    case PROP_ABS:
    case PROP_ABSNEG:
    case PROP_ADD:
    case PROP_ADDABS:
    case PROP_ADDS:
    case PROP_ADDSX:
    case PROP_ADDX:
    case PROP_AND:
    case PROP_ANDN:
    case PROP_CMP:
    case PROP_CMPS:
    case PROP_CMPSUB:
    case PROP_CMPSX:
    case PROP_CMPX:
    case PROP_DJNZ:
    case PROP_MAX:
    case PROP_MAXS:
    case PROP_MIN:
    case PROP_MINS:
    case PROP_MOV:
    case PROP_MOVD:
    case PROP_MOVI:
    case PROP_MOVS:
    case PROP_MUXC:
    case PROP_MUXNC:
    case PROP_MUXNZ:
    case PROP_MUXZ:
    case PROP_NEG:
    case PROP_NEGC:
    case PROP_NEGNC:
    case PROP_NEGNZ:
    case PROP_NEGZ:
    case PROP_OR:
    case PROP_RCL:
    case PROP_RCR:
    case PROP_RDBYTE:
    case PROP_RDLONG:
    case PROP_RDWORD:
        // case PROP_RET:
    case PROP_REV:
    case PROP_ROL:
    case PROP_ROR:
    case PROP_SAR:
    case PROP_SHL:
    case PROP_SHR:
    case PROP_SUBABS:
    case PROP_SUBS:
    case PROP_SUBSX:
        // case PROP_SUBX:
    case PROP_SUMC:
    case PROP_SUMNC:
    case PROP_SUMNZ:
    case PROP_SUMZ:
        // case PROP_TEST:
    case PROP_TJZ:
    case PROP_WAITCNT:
    case PROP_WAITPEQ:
    case PROP_WAITPNE:
    case PROP_WAITVID:
    case PROP_XOR:
        snprintf(cmd->instr, sizeof cmd->instr, "%s", instrs[opcode]);
 
        if ((opcode == PROP_RDBYTE || opcode == PROP_RDLONG ||
                opcode == PROP_RDWORD) &&
            (!(get_zcri(in) & 0x2))) {
            cmd->instr[0] = 'w';
            cmd->instr[1] = 'r';
        }
 
        if (opcode == PROP_SUB && in & 0x08000000) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1, "sub");
        } else if (opcode == PROP_SUBX && in & 0x08000000) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1, "subx");
        }
 
        if (is_immediate(in)) {
            cmd->src = get_src(in);
            cmd->dst = get_dst(in);
            snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, #%d",
                get_dst(in), get_src(in));
        } else {
            cmd->src = get_src(in) << 2;
            cmd->dst = get_dst(in);
            snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, 0x%x",
                get_dst(in), get_src(in) << 2);
        }
 
        ret = 4;
        break;
    case PROP_HUBOP:
        ret = decode_ext_cmd(cmd, in);
        if (ret == -1) {
            snprintf(cmd->instr, PROP_INSTR_MAXLEN - 1, "%s",
                instrs[opcode]);
 
            if (is_immediate(in)) {
                cmd->src = get_src(in);
                cmd->dst = get_dst(in);
 
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, #%d",
                    get_dst(in) << 2, get_src(in));
            } else {
                cmd->src = get_src(in);
                cmd->dst = get_dst(in);
 
                snprintf(cmd->operands, PROP_INSTR_MAXLEN - 1, "0x%x, 0x%x",
                    get_dst(in), get_src(in));
            }
 
            ret = 4;
        }
        break;
    case PROP_JMP:
        ret = decode_jmp(cmd, in);
        break;
    }
 
    cmd->opcode = opcode;
 
    if (ret > 0) {
        decode_prefix(cmd, in);
    }
 
    return ret;
}

References cmd, decode_ext_cmd(), decode_jmp(), decode_prefix(), get_con(), get_dst(), get_opcode(), get_src(), get_zcri(), in, instrs, is_immediate(), PROP_ABS, PROP_ABSNEG, PROP_ADD, PROP_ADDABS, PROP_ADDS, PROP_ADDSX, PROP_ADDX, PROP_AND, PROP_ANDN, PROP_CMP, PROP_CMPS, PROP_CMPSUB, PROP_CMPSX, PROP_CMPX, PROP_DJNZ, PROP_HUBOP, PROP_INSTR_MAXLEN, PROP_JMP, PROP_MAX, PROP_MAXS, PROP_MIN, PROP_MINS, PROP_MOV, PROP_MOVD, PROP_MOVI, PROP_MOVS, PROP_MUXC, PROP_MUXNC, PROP_MUXNZ, PROP_MUXZ, PROP_NEG, PROP_NEGC, PROP_NEGNC, PROP_NEGNZ, PROP_NEGZ, PROP_OR, PROP_RCL, PROP_RCR, PROP_RDBYTE, PROP_RDLONG, PROP_RDWORD, PROP_REV, PROP_ROL, PROP_ROR, PROP_SAR, PROP_SHL, PROP_SHR, PROP_SUB, PROP_SUBABS, PROP_SUBS, PROP_SUBSX, PROP_SUBX, PROP_SUMC, PROP_SUMNC, PROP_SUMNZ, PROP_SUMZ, PROP_TJZ, PROP_WAITCNT, PROP_WAITPEQ, PROP_WAITPNE, PROP_WAITVID, PROP_XOR, rz_read_be32(), and snprintf.

Referenced by disassemble(), and propeller_op().

Variable Documentation

conditions

const char* conditions[]

static

Initial value:

= {
    [PROP_IF_ALWAYS] = "",
    [PROP_IF_NEVER] = "",
    [PROP_IF_E] = "if_e",
    [PROP_IF_NE] = "if_ne",
    [PROP_IF_A] = "if_a",
    [PROP_IF_B] = "if_b",
    [PROP_IF_AE] = "if_ae",
    [PROP_IF_BE] = "if_be",
    [PROP_IF_C_EQ_Z] = "if_c_eq_z",
    [PROP_IF_C_NE_Z] = "if_c_ne_z",
    [PROP_IF_C_AND_Z] = "if_c_and_z",
    [PROP_IF_C_AND_NZ] = "if_c_and_nz",
    [PROP_IF_NC_AND_Z] = "if_nc_and_z",
    [PROP_IF_NZ_OR_NC] = "if_nc_or_nz",
    [PROP_IF_NZ_OR_C] = "if_nz_or_c",
    [PROP_IF_Z_OR_NC] = "if_z_or_c",
}

Definition at line 80 of file propeller_disas.c.

Referenced by decode_prefix(), gdbr_set_bp(), gdbr_set_hwa(), gdbr_set_hwbp(), gdbr_set_hwr(), gdbr_set_hww(), qnxr_set_bp(), and qnxr_set_hwbp().

ext_instrs

const char* ext_instrs[]

static

Initial value:

= {
    [PROP_CLKSET] = "clkset",
    [PROP_COGID] = "cogid",
    [PROP_COGINIT] = "coginit",
    [PROP_COGSTOP] = "cogstop",
    [PROP_LOCKCLR] = "lockclr",
    [PROP_LOCKNEW] = "locknew",
    [PROP_LOCKRET] = "lockret",
    [PROP_LOCKSET] = "lockset",
}

Definition at line 69 of file propeller_disas.c.

Referenced by decode_ext_cmd().

instrs

const char* instrs[]

static

Definition at line 9 of file propeller_disas.c.

Referenced by propeller_decode_command().