disassembler.c File Reference

#include "disassembler.h"
#include "common.h"
#include "regs.h"

Go to the source code of this file.

Functions
static SHParam	sh_op_get_param (ut16 opcode, SHParamBuilder shb)
	Get SHParam from opcode Make sure the opcode is passed in little-endian form. More...
static SHParam	sh_op_get_param_movl (ut16 opcode, bool m)
	Get params for mov.l instruction (0001NMD) A special function is required because the nibbles for the second param (@(disp:Rn)) (i.e. N and D) are separated by the nibble for the first param (Rm) (i.e. M), so sh_op_get_param cannot be used. More...
RZ_IPI RZ_OWN SHOp *	sh_disassembler (ut16 opcode)
	Disassemble opcode and return a SHOp. More...
RZ_IPI RZ_OWN char *	sh_op_param_to_str (SHParam param, SHScaling scaling, ut64 pc)
	Return string representation of disassembled param. More...
RZ_IPI RZ_OWN char *	sh_op_to_str (RZ_NONNULL const SHOp *op, ut64 pc)
	Return string representation of disassembled op. More...

Variables
const SHOpRaw	sh_op_lookup []
const ut32	OPCODE_NUM

Function Documentation

sh_disassembler()

RZ_IPI RZ_OWN SHOp* sh_disassembler

(

ut16

opcode

)

Disassemble opcode and return a SHOp.

Parameters

opcode

16 bit wide opcode

Returns

SHOp object corresponding to the opcode

Definition at line 130 of file disassembler.c.

                                                 {
    for (ut16 i = 0; i < OPCODE_NUM; i++) {
        if ((opcode | sh_op_lookup[i].mask) != sh_op_lookup[i].opcode) {
            continue;
        }
 
        SHOpRaw raw = sh_op_lookup[i];
        SHOp *op = RZ_NEW(SHOp);
        op->opcode = opcode;
        op->mnemonic = raw.mnemonic;
        op->scaling = raw.scaling;
        op->str_mnem = raw.str_mnem;
        // check for "weird" mov.l
        if (raw.opcode == MOVL) {
            op->param[0] = sh_op_get_param_movl(opcode, true);
            op->param[1] = sh_op_get_param_movl(opcode, false);
            return op;
        }
        op->param[0] = sh_op_get_param(opcode, raw.param_builder[0]);
        op->param[1] = sh_op_get_param(opcode, raw.param_builder[1]);
        return op;
    }
 
    RZ_LOG_DEBUG("SuperH: Invalid opcode encountered by disassembler: 0x%06x\n", opcode);
    return NULL;
}

References i, mask, sh_op_raw_t::mnemonic, MOVL, NULL, op, sh_op_raw_t::opcode, OPCODE_NUM, sh_op_raw_t::param_builder, RZ_LOG_DEBUG, RZ_NEW, sh_op_raw_t::scaling, sh_op_get_param(), sh_op_get_param_movl(), sh_op_lookup, and sh_op_raw_t::str_mnem.

Referenced by disassemble(), and sh_op().

sh_op_get_param()

static SHParam sh_op_get_param ( ut16  opcode, SHParamBuilder  shb  )

static

Get SHParam from opcode Make sure the opcode is passed in little-endian form.

Parameters

opcode	instruction opcode (assumed to be in little-endian)
shb	SHParamBuilder instance which contains the necessary info to find the param

Definition at line 18 of file disassembler.c.

                                                                {
    if (shb.is_param) {
        return shb.param;
    }
    if (shb.addr.mode == SH_ADDR_INVALID) {
        SHParam invalid;
        invalid.mode = SH_ADDR_INVALID;
        return invalid;
    }
 
    ut16 nibble = opcode >> shb.addr.start;
    ut8 len = 0;
 
    if (shb.addr.bits != -1) {
        // do not infer the bit length from mode
        len = shb.addr.bits;
        goto extract;
    }
 
    switch (shb.addr.mode) {
    case SH_REG_DIRECT:
    case SH_REG_INDIRECT:
    case SH_REG_INDIRECT_I:
    case SH_REG_INDIRECT_D:
    case SH_REG_INDIRECT_INDEXED:
    case SH_PC_RELATIVE_REG:
        len = 4;
        break;
    case SH_REG_INDIRECT_DISP:
    case SH_GBR_INDIRECT_DISP:
    case SH_PC_RELATIVE_DISP:
    case SH_PC_RELATIVE8:
    case SH_IMM_S:
    case SH_IMM_U:
        len = 8;
        break;
    case SH_PC_RELATIVE12:
        len = 12;
        break;
    default:
        break;
    }
 
extract:
 
    nibble &= 0xffff >> (16 - len);
 
    SHParam ret_param;
    ret_param.mode = shb.addr.mode;
    switch (shb.addr.mode) {
    case SH_REG_DIRECT:
    case SH_REG_INDIRECT:
    case SH_REG_INDIRECT_I:
    case SH_REG_INDIRECT_D:
    case SH_REG_INDIRECT_INDEXED:
    case SH_GBR_INDIRECT_DISP:
    case SH_PC_RELATIVE_DISP:
    case SH_PC_RELATIVE8:
    case SH_PC_RELATIVE12:
    case SH_PC_RELATIVE_REG:
    case SH_IMM_S:
    case SH_IMM_U:
        ret_param.param[0] = nibble;
        break;
    case SH_REG_INDIRECT_DISP:
        ret_param.param[0] = nibble >> 4;
        ret_param.param[1] = nibble & 0xf;
        break;
    case SH_GBR_INDIRECT_INDEXED:
        break;
    default:
        break;
    }
 
    /* For the special case of banked registers in `LDC` and `STC`, the bit length is 3
    In such case, we can modify the param found to correspond to its banked counterpart */
    if (len == 3) {
        ret_param.param[0] += SH_REG_IND_R0B;
    }
 
    return ret_param;
}

References sh_param_builder_t::addr, sh_param_builder_addr_t::bits, extract, sh_param_builder_t::is_param, len, sh_param_builder_addr_t::mode, sh_param_t::mode, sh_param_builder_t::param, sh_param_t::param, SH_ADDR_INVALID, SH_GBR_INDIRECT_DISP, SH_GBR_INDIRECT_INDEXED, SH_IMM_S, SH_IMM_U, SH_PC_RELATIVE12, SH_PC_RELATIVE8, SH_PC_RELATIVE_DISP, SH_PC_RELATIVE_REG, SH_REG_DIRECT, SH_REG_IND_R0B, SH_REG_INDIRECT, SH_REG_INDIRECT_D, SH_REG_INDIRECT_DISP, SH_REG_INDIRECT_I, SH_REG_INDIRECT_INDEXED, and sh_param_builder_addr_t::start.

Referenced by sh_disassembler().

sh_op_get_param_movl()

static SHParam sh_op_get_param_movl ( ut16  opcode, bool  m  )

static

Get params for mov.l instruction (0001NMD) A special function is required because the nibbles for the second param (@(disp:Rn)) (i.e. N and D) are separated by the nibble for the first param (Rm) (i.e. M), so sh_op_get_param cannot be used.

Parameters

opcode	opcode
m	if true, get Rm ; otherwise get @(disp:Rn)

Returns

SHParam return appropriate param

Definition at line 110 of file disassembler.c.

                                                         {
    if (m) {
        ut16 reg = (opcode >> 4) & 0xf;
        return (SHParam){ .param = {
                      reg,
                  },
            .mode = SH_REG_DIRECT };
    } else {
        ut16 d = opcode & 0xf;
        ut16 n = (opcode >> 8) & 0xf;
        return (SHParam){ .param = { n, d }, .mode = SH_REG_INDIRECT_DISP };
    }
}

References d, regress::m, n, reg, SH_REG_DIRECT, and SH_REG_INDIRECT_DISP.

Referenced by sh_disassembler().

sh_op_param_to_str()

RZ_IPI RZ_OWN char* sh_op_param_to_str	(	SHParam	param,
		SHScaling	scaling,
		ut64	pc
	)

Return string representation of disassembled param.

Parameters

SHParam	to be disassembled
SHScaling	of the instruction associated with the param

Returns

char *, owned by the caller

Definition at line 166 of file disassembler.c.

                                                                                  {
    if (param.mode == SH_ADDR_INVALID) {
        return NULL;
    }
 
    RzStrBuf *buf = rz_strbuf_new(NULL);
    switch (param.mode) {
    case SH_REG_DIRECT:
        rz_strbuf_appendf(buf, "%s", sh_registers[param.param[0]]);
        break;
    case SH_REG_INDIRECT:
        rz_strbuf_appendf(buf, "@%s", sh_registers[param.param[0]]);
        break;
    case SH_REG_INDIRECT_I:
        rz_strbuf_appendf(buf, "@%s+", sh_registers[param.param[0]]);
        break;
    case SH_REG_INDIRECT_D:
        rz_strbuf_appendf(buf, "@-%s", sh_registers[param.param[0]]);
        break;
    case SH_REG_INDIRECT_DISP:
        rz_strbuf_appendf(buf, "@(0x%02x,%s)", param.param[1] * sh_scaling_size[scaling], sh_registers[param.param[0]]);
        break;
    case SH_REG_INDIRECT_INDEXED:
        rz_strbuf_appendf(buf, "@(r0,%s)", sh_registers[param.param[0]]);
        break;
    case SH_GBR_INDIRECT_DISP:
        rz_strbuf_appendf(buf, "@(0x%03x,gbr)", param.param[0] * sh_scaling_size[scaling]);
        break;
    case SH_GBR_INDIRECT_INDEXED:
        rz_strbuf_append(buf, "@(r0,gbr)");
        break;
    case SH_PC_RELATIVE_DISP:
        rz_strbuf_appendf(buf, "@(0x%03x,pc)", param.param[0] * sh_scaling_size[scaling]);
        break;
    case SH_PC_RELATIVE8:
    case SH_PC_RELATIVE12:
        rz_strbuf_appendf(buf, "0x%08x", (ut32)pc + 4 + (st32)((st8)param.param[0]) * 2);
        break;
    case SH_PC_RELATIVE_REG:
        rz_strbuf_appendf(buf, "%s", sh_registers[param.param[0]]);
        break;
    case SH_IMM_U:
    case SH_IMM_S:
        rz_strbuf_appendf(buf, "0x%02x", param.param[0]);
        break;
    default:
        rz_warn_if_reached();
    }
 
    return rz_strbuf_drain(buf);
}

References sh_param_t::mode, NULL, sh_param_t::param, pc, rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), rz_warn_if_reached, SH_ADDR_INVALID, SH_GBR_INDIRECT_DISP, SH_GBR_INDIRECT_INDEXED, SH_IMM_S, SH_IMM_U, SH_PC_RELATIVE12, SH_PC_RELATIVE8, SH_PC_RELATIVE_DISP, SH_PC_RELATIVE_REG, SH_REG_DIRECT, SH_REG_INDIRECT, SH_REG_INDIRECT_D, SH_REG_INDIRECT_DISP, SH_REG_INDIRECT_I, SH_REG_INDIRECT_INDEXED, sh_registers, sh_scaling_size, st32, and st8.

Referenced by sh_op_to_str().

sh_op_to_str()

RZ_IPI RZ_OWN char* sh_op_to_str	(	RZ_NONNULL const SHOp *	op,
		ut64	pc
	)

Return string representation of disassembled op.

Parameters

SHOp	to be disassembled

Returns

char *, owned by the caller

Definition at line 224 of file disassembler.c.

                                                                     {
    rz_return_val_if_fail(op, NULL);
    if (!op->str_mnem) {
        return NULL;
    }
    RzStrBuf *buf = rz_strbuf_new(op->str_mnem);
 
    char *param = NULL;
    if ((param = sh_op_param_to_str(op->param[0], op->scaling, pc))) {
        rz_strbuf_appendf(buf, " %s", param);
        free(param);
        if ((param = sh_op_param_to_str(op->param[1], op->scaling, pc))) {
            rz_strbuf_appendf(buf, ", %s", param);
            free(param);
        }
    }
 
    return rz_strbuf_drain(buf);
}

References free(), NULL, pc, rz_return_val_if_fail, rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), and sh_op_param_to_str().

Referenced by disassemble().

Variable Documentation

OPCODE_NUM

const ut32 OPCODE_NUM

extern

Definition at line 195 of file lookup.c.

Referenced by sh_disassembler().

sh_op_lookup

const SHOpRaw sh_op_lookup[]

extern

Definition at line 7 of file lookup.c.

Referenced by sh_disassembler().