ebc_disas.c File Reference

#include "ebc_disas.h"
#include <rz_types.h>

Go to the source code of this file.

Classes
struct	ebc_index

Macros
#define	CHK_SNPRINTF(dst, sz, fmt, ...)

Typedefs
typedef int(*	decode) (const ut8 *, ebc_command_t *cmd)
typedef struct ebc_index	ebc_index_t

Functions
static int	decode_index16 (const ut8 *data, ebc_index_t *index)
static int	decode_index32 (const ut8 *data, ebc_index_t *index)
static int	decode_index64 (const ut8 *data, ebc_index_t *index)
static int	decode_break (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_jmp (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_jmp8 (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_call (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_ret (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_cmp (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_cmpeq (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_cmplte (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_cmpgte (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_cmpulte (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_cmpugte (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_not (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_neg (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_add (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_sub (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_mul (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_mulu (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_div (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_divu (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_arith (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_mov_args (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_mov (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_movsn_args (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_movsn (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_loadsp (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_storesp (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_push_pop (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_cmpi (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_movn (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_movi (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_movin (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_movrel (const ut8 *bytes, ebc_command_t *cmd)
static int	decode_invalid (const ut8 *bytes, ebc_command_t *cmd)
int	ebc_decode_command (const ut8 *instr, ebc_command_t *cmd)

Variables
static const char *	instr_names []
static const char *	dedic_regs []
static decode	decodes [EBC_COMMAND_NUM]

Macro Definition Documentation

CHK_SNPRINTF

#define CHK_SNPRINTF	(		dst,
			sz,
			fmt,
			...
	)

Value:

    do { \
        int len_chk_snprintf_ = snprintf(dst, sz, fmt, __VA_ARGS__); \
        if (len_chk_snprintf_ >= sz) { \
            return -1; \
        } \
    } while (0)

Definition at line 7 of file ebc_disas.c.

Typedef Documentation

decode

typedef int(* decode) (const ut8 *, ebc_command_t *cmd)

Definition at line 88 of file ebc_disas.c.

ebc_index_t

typedef struct ebc_index ebc_index_t

Function Documentation

decode_add()

static int decode_add ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 365 of file ebc_disas.c.

                                                            {
    char sign;
    int ret = 2;
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    unsigned op1, op2;
    char index[32] = { 0 };
    ut16 immed;
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u", instr_names[EBC_ADD],
        bits);
 
    op1 = bytes[1] & 0x07;
    op2 = (bytes[1] >> 4) & 0x07;
 
    if (TEST_BIT(bytes[0], 7)) {
        ret = 4;
        if (TEST_BIT(bytes[1], 7)) {
            ebc_index_t idx;
            decode_index16(bytes + 2, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(index, sizeof(index),
                " (%c%d, %c%d)", sign, idx.n, sign, idx.c);
        } else {
            immed = *(ut16 *)&bytes[2];
            snprintf(index, sizeof(index), "(%u)", immed);
        }
    }
 
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%sr%d, %sr%d%s",
        TEST_BIT(bytes[1], 3) ? "@" : "", op1,
        TEST_BIT(bytes[1], 7) ? "@" : "", op2, index);
    return ret;
}

References bits(), bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_ADD, EBC_INSTR_MAXLEN, EBC_OPERANDS_MAXLEN, setup::idx, instr_names, snprintf, and TEST_BIT.

Referenced by decode_arith(), decode_div(), decode_divu(), decode_mul(), decode_mulu(), and decode_sub().

decode_arith()

static int decode_arith ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 440 of file ebc_disas.c.

                                                              {
    int ret = decode_add(bytes, cmd);
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u",
        instr_names[bytes[0] & EBC_OPCODE_MASK], bits);
    return ret;
}

References bits(), bytes, cmd, decode_add(), EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, instr_names, snprintf, and TEST_BIT.

decode_break()

static int decode_break ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 131 of file ebc_disas.c.

                                                              {
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s", instr_names[EBC_BREAK]);
    snprintf(cmd->operands, EBC_OPERANDS_MAXLEN, "%d", bytes[1]);
    return 2;
}

References bytes, cmd, EBC_BREAK, EBC_INSTR_MAXLEN, EBC_OPERANDS_MAXLEN, instr_names, and snprintf.

decode_call()

static int decode_call ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 196 of file ebc_disas.c.

                                                             {
    int ret;
    short bits = 32;
    ut8 op1 = bytes[1] & 0x7;
    ut32 i1;
    unsigned long i2;
    ebc_index_t idx32;
    char sign;
 
    if (!TEST_BIT(bytes[0], 6)) {
        // CALL32
        bits = 32;
        ret = 2;
        if (TEST_BIT(bytes[1], 3)) {
            // operand 1 indirect
            if (TEST_BIT(bytes[0], 7)) {
                // immediate data is present
                decode_index32(bytes + 2, &idx32);
                sign = idx32.sign ? '+' : '-';
 
                CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
                    "@r%d(%c%u, %c%u)",
                    op1, sign, idx32.n, sign, idx32.c);
                ret = 6;
            } else {
                snprintf(cmd->operands, EBC_OPERANDS_MAXLEN,
                    "@r%d", op1);
            }
        } else {
            // operand 1 direct
            if (TEST_BIT(bytes[0], 7)) {
                // immediate data present
                i1 = *(ut32 *)(bytes + 2);
                CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
                    "r%d(0x%x)", op1, i1);
                ret = 6;
            } else {
                // no immediate data present
                CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
                    "r%d", op1);
            }
        }
    } else {
        bits = 64;
        ret = 10;
        i2 = *(ut64 *)&bytes[2];
        CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "0x%lx", i2);
    }
    CHK_SNPRINTF(cmd->instr, EBC_INSTR_MAXLEN, "%s%d%s%s",
        instr_names[EBC_CALL], bits,
        TEST_BIT(bytes[1], 5) ? "ex" : "",
        TEST_BIT(bytes[1], 4) ? "" : "a");
    return ret;
}

References bits(), bytes, ebc_index::c, CHK_SNPRINTF, cmd, decode_index32(), EBC_CALL, EBC_INSTR_MAXLEN, EBC_OPERANDS_MAXLEN, i2, instr_names, ebc_index::n, ebc_index::sign, snprintf, TEST_BIT, and ut64().

decode_cmp()

static int decode_cmp ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 258 of file ebc_disas.c.

                                                            {
    int ret = 2;
    int op1, op2;
    char sign;
    ut16 immed;
    ebc_index_t idx;
 
    op1 = bytes[1] & 0x07;
    op2 = (bytes[1] >> 4) & 0x07;
 
    if (TEST_BIT(bytes[0], 7)) {
        ret += 2;
        if (TEST_BIT(bytes[1], 7)) {
            decode_index16(bytes + 2, &idx);
            sign = idx.sign ? '+' : '-';
            CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
                "r%d, @r%d (%c%d, %c%d)",
                op1, op2, sign, idx.n, sign, idx.c);
        } else {
            immed = *(ut16 *)&bytes[2];
            CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
                "r%d, r%d %d", op1, op2, immed);
        }
    } else {
        CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
            "r%d, r%d", op1, op2);
    }
 
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_OPERANDS_MAXLEN, setup::idx, and TEST_BIT.

Referenced by decode_cmpeq(), decode_cmpgte(), decode_cmplte(), decode_cmpugte(), and decode_cmpulte().

decode_cmpeq()

static int decode_cmpeq ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 289 of file ebc_disas.c.

                                                              {
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%deq",
        instr_names[EBC_CMPLTE], bits);
    return decode_cmp(bytes, cmd);
}

References bits(), bytes, cmd, decode_cmp(), EBC_CMPLTE, EBC_INSTR_MAXLEN, instr_names, snprintf, and TEST_BIT.

decode_cmpgte()

static int decode_cmpgte ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 303 of file ebc_disas.c.

                                                               {
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%dgte",
        instr_names[EBC_CMPGTE], bits);
    return decode_cmp(bytes, cmd);
}

References bits(), bytes, cmd, decode_cmp(), EBC_CMPGTE, EBC_INSTR_MAXLEN, instr_names, snprintf, and TEST_BIT.

decode_cmpi()

static int decode_cmpi ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 633 of file ebc_disas.c.

                                                             {
    int ret = 2;
    unsigned op1 = bytes[1] & 0x07;
    char op1c[32];
    char indx[32] = { 0 };
    char immed[32] = { 0 };
    char *suff[] = { "eq", "lte", "gte", "ulte", "ugte" };
 
    snprintf(op1c, sizeof(op1c) - 1, "%sr%u",
        TEST_BIT(bytes[1], 3) ? "@" : "", op1);
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u%c%s",
        instr_names[bytes[0] & EBC_OPCODE_MASK],
        TEST_BIT(bytes[0], 6) ? 64 : 32,
        TEST_BIT(bytes[0], 7) ? 'd' : 'w',
        suff[(bytes[0] & EBC_OPCODE_MASK) - EBC_CMPIEQ]);
 
    if (TEST_BIT(bytes[1], 4)) {
        char sign;
        ebc_index_t idx;
 
        decode_index16(bytes + 2, &idx);
 
        sign = idx.sign ? '+' : '-';
 
        snprintf(indx, sizeof(indx), " (%c%u, %c%u)", sign, idx.n, sign, idx.c);
 
        ret += 2;
    }
 
    if (TEST_BIT(bytes[0], 7)) {
        ut32 im = *(ut32 *)(bytes + ret);
        snprintf(immed, sizeof(immed), "%u", im);
        ret += 4;
    } else {
        ut16 im = *(ut16 *)(bytes + ret);
        snprintf(immed, sizeof(immed), "%u", im);
        ret += 2;
    }
 
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s%s, %s", op1c, indx, immed);
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_CMPIEQ, EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, setup::idx, indx(), instr_names, snprintf, and TEST_BIT.

decode_cmplte()

static int decode_cmplte ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 296 of file ebc_disas.c.

                                                               {
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%dlte",
        instr_names[EBC_CMPLTE], bits);
    return decode_cmp(bytes, cmd);
}

References bits(), bytes, cmd, decode_cmp(), EBC_CMPLTE, EBC_INSTR_MAXLEN, instr_names, snprintf, and TEST_BIT.

decode_cmpugte()

static int decode_cmpugte ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 317 of file ebc_disas.c.

                                                                {
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%dugte",
        instr_names[EBC_CMPUGTE], bits);
    return decode_cmp(bytes, cmd);
}

References bits(), bytes, cmd, decode_cmp(), EBC_CMPUGTE, EBC_INSTR_MAXLEN, instr_names, snprintf, and TEST_BIT.

decode_cmpulte()

static int decode_cmpulte ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 310 of file ebc_disas.c.

                                                                {
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%dulte",
        instr_names[EBC_CMPULTE], bits);
    return decode_cmp(bytes, cmd);
}

References bits(), bytes, cmd, decode_cmp(), EBC_CMPULTE, EBC_INSTR_MAXLEN, instr_names, snprintf, and TEST_BIT.

decode_div()

static int decode_div ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 424 of file ebc_disas.c.

                                                            {
    int ret = decode_add(bytes, cmd);
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u",
        instr_names[EBC_DIV], bits);
    return ret;
}

References bits(), bytes, cmd, decode_add(), EBC_DIV, EBC_INSTR_MAXLEN, instr_names, snprintf, and TEST_BIT.

decode_divu()

static int decode_divu ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 432 of file ebc_disas.c.

                                                             {
    int ret = decode_add(bytes, cmd);
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u",
        instr_names[EBC_DIVU], bits);
    return ret;
}

References bits(), bytes, cmd, decode_add(), EBC_DIVU, EBC_INSTR_MAXLEN, instr_names, snprintf, and TEST_BIT.

decode_index16()

static int decode_index16 ( const ut8 *  data, ebc_index_t *  index  )

static

Definition at line 101 of file ebc_disas.c.

                                                               {
    ut16 tmp = *(ut16 *)data;
    index->type = EBC_INDEX16;
    index->sign = tmp & 0x8000 ? EBC_INDEX_PLUS : EBC_INDEX_MINUS;
    index->a_width = ((tmp >> 12) & EBC_N_BIT_MASK(2)) * 2;
    index->n = tmp & EBC_N_BIT_MASK(index->a_width);
    index->c = (tmp >> index->a_width) & EBC_N_BIT_MASK(12 - index->a_width);
    return 0;
}

References ebc_index::a_width, ebc_index::c, EBC_N_BIT_MASK, ebc_index::n, ebc_index::sign, autogen_x86imm::tmp, and ebc_index::type.

Referenced by decode_add(), decode_cmp(), decode_cmpi(), decode_mov_args(), decode_movi(), decode_movin(), decode_movn(), decode_movrel(), decode_movsn_args(), decode_not(), and decode_push_pop().

decode_index32()

static int decode_index32 ( const ut8 *  data, ebc_index_t *  index  )

static

Definition at line 111 of file ebc_disas.c.

                                                               {
    ut32 tmp = *(ut32 *)data;
    index->type = EBC_INDEX32;
    index->sign = tmp & EBC_NTH_BIT(31) ? EBC_INDEX_PLUS : EBC_INDEX_MINUS;
    index->a_width = ((tmp >> 28) & EBC_N_BIT_MASK(2)) * 4;
    index->n = tmp & EBC_N_BIT_MASK(index->a_width);
    index->c = (tmp >> index->a_width) & EBC_N_BIT_MASK(28 - index->a_width);
    return 0;
}

References ebc_index::a_width, ebc_index::c, EBC_N_BIT_MASK, EBC_NTH_BIT, ebc_index::n, ebc_index::sign, autogen_x86imm::tmp, and ebc_index::type.

Referenced by decode_call(), decode_jmp(), decode_mov_args(), decode_movin(), and decode_movn().

decode_index64()

static int decode_index64 ( const ut8 *  data, ebc_index_t *  index  )

static

Definition at line 121 of file ebc_disas.c.

                                                               {
    ut64 tmp = *(ut64 *)data;
    index->type = EBC_INDEX64;
    index->sign = tmp & EBC_NTH_BIT(63) ? EBC_INDEX_PLUS : EBC_INDEX_MINUS;
    index->a_width = ((tmp >> 60) & EBC_N_BIT_MASK(2)) * 8;
    index->n = tmp & EBC_N_BIT_MASK(index->a_width);
    index->c = (tmp >> index->a_width) & EBC_N_BIT_MASK(60 - index->a_width);
    return 0;
}

References ebc_index::a_width, ebc_index::c, EBC_N_BIT_MASK, EBC_NTH_BIT, ebc_index::n, ebc_index::sign, autogen_x86imm::tmp, ebc_index::type, and ut64().

Referenced by decode_mov_args(), and decode_movin().

decode_invalid()

static int decode_invalid ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 921 of file ebc_disas.c.

                                                                {
    return -1;
}

decode_jmp()

static int decode_jmp ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 138 of file ebc_disas.c.

                                                            {
    int ret;
    int bits = 32;
    char op1[32] = { 0 };
    int32_t immed32;
    ebc_index_t idx32;
    char sign;
    unsigned long immed;
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%d%s", instr_names[EBC_JMP], bits,
        TEST_BIT(bytes[1], 7) ? TEST_BIT(bytes[1], 6) ? "cs" : "cc" : "");
 
    if (TEST_BIT(bytes[0], 6)) {
        immed = *(ut64 *)(bytes + 2);
        ret = 10;
        snprintf(cmd->operands, EBC_OPERANDS_MAXLEN, "0x%lx", immed);
    } else {
        if ((bytes[1] & 0x7) != 0) {
            {
                snprintf(op1, sizeof(op1), "%sr%u ",
                    TEST_BIT(bytes[1], 3) ? "@" : "", bytes[1] & 0x7);
            }
        }
        if (TEST_BIT(bytes[0], 7)) {
            if (TEST_BIT(bytes[1], 3)) {
                decode_index32(bytes + 2, &idx32);
                sign = idx32.sign ? '+' : '-';
 
                CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
                    "%s(%c%u, %c%u)",
                    op1, sign, idx32.n, sign, idx32.c);
            } else {
                immed32 = *(int32_t *)(bytes + 2);
                CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN,
                    "%s0x%x", op1, immed32);
            }
            ret = 6;
        } else {
            snprintf(cmd->operands, EBC_OPERANDS_MAXLEN, "%s", op1);
            ret = 2;
        }
    }
 
    return ret;
}

References bits(), bytes, ebc_index::c, CHK_SNPRINTF, cmd, decode_index32(), EBC_INSTR_MAXLEN, EBC_JMP, EBC_OPERANDS_MAXLEN, instr_names, ebc_index::n, ebc_index::sign, snprintf, TEST_BIT, and ut64().

decode_jmp8()

static int decode_jmp8 ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 184 of file ebc_disas.c.

                                                             {
    char suff[3] = { 0 };
    if (TEST_BIT(bytes[0], 7)) {
        const char *str = (TEST_BIT(bytes[0], 6)) ? "cs" : "cc";
        snprintf(suff, 3, "%s", str);
    }
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%s",
        instr_names[bytes[0] & EBC_OPCODE_MASK], suff);
    snprintf(cmd->operands, EBC_OPERANDS_MAXLEN, "0x%x", bytes[1]);
    return 2;
}

References bytes, cmd, EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, instr_names, snprintf, cmd_descs_generate::str, and TEST_BIT.

decode_loadsp()

static int decode_loadsp ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 576 of file ebc_disas.c.

                                                               {
    int ret = 2;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s",
        instr_names[bytes[0] & EBC_OPCODE_MASK]);
    snprintf(cmd->operands, EBC_OPERANDS_MAXLEN, "%s, r%u",
        dedic_regs[bytes[1] & 0x7],
        (bytes[1] >> 4) & 0x7);
    return ret;
}

References bytes, cmd, dedic_regs, EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, instr_names, and snprintf.

decode_mov()

static int decode_mov ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 525 of file ebc_disas.c.

                                                            {
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s",
        instr_names[bytes[0] & EBC_OPCODE_MASK]);
    return decode_mov_args(bytes, cmd);
}

References bytes, cmd, decode_mov_args(), EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, instr_names, and snprintf.

decode_mov_args()

static int decode_mov_args ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 448 of file ebc_disas.c.

                                                                 {
    int ret = 2;
    unsigned op1, op2;
    char op1c[32], op2c[32];
    char ind1[32] = { 0 }, ind2[32] = { 0 };
    ebc_index_t idx;
    char sign;
 
    op1 = bytes[1] & 0x07;
    op2 = (bytes[1] >> 4) & 0x07;
 
    snprintf(op1c, 32, "%sr%u", TEST_BIT(bytes[1], 3) ? "@" : "", op1);
    snprintf(op2c, 32, "%sr%u", TEST_BIT(bytes[1], 7) ? "@" : "", op2);
 
    switch (bytes[0] & EBC_OPCODE_MASK) {
    case EBC_MOVBW:
    case EBC_MOVWW:
    case EBC_MOVDW:
    case EBC_MOVQW:
        if (TEST_BIT(bytes[0], 7)) {
            decode_index16(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind1, 32, "(%c%u, %c%u)", sign,
                idx.n, sign, idx.c);
            ret += 2;
        }
        if (TEST_BIT(bytes[0], 6)) {
            decode_index16(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind2, 32, "(%c%u, %c%u)", sign,
                idx.n, sign, idx.c);
            ret += 2;
        }
        break;
    case EBC_MOVBD:
    case EBC_MOVWD:
    case EBC_MOVDD:
    case EBC_MOVQD:
        if (TEST_BIT(bytes[0], 7)) {
            decode_index32(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind1, 32, "(%c%u, %c%u)", sign,
                idx.n, sign, idx.c);
            ret += 4;
        }
        if (TEST_BIT(bytes[0], 6)) {
            decode_index32(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind2, 32, "(%c%u, %c%u)", sign,
                idx.n, sign, idx.c);
            ret += 4;
        }
        break;
    case EBC_MOVQQ:
        if (TEST_BIT(bytes[0], 7)) {
            decode_index64(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind1, 32, "(%c%u, %c%u)", sign,
                idx.n, sign, idx.c);
            ret += 8;
        }
        if (TEST_BIT(bytes[0], 6)) {
            decode_index64(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind1, 32, "(%c%u, %c%u)", sign,
                idx.n, sign, idx.c);
            ret += 8;
        }
        break;
    }
 
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s%s, %s%s",
        op1c, ind1, op2c, ind2);
 
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), decode_index32(), decode_index64(), EBC_MOVBD, EBC_MOVBW, EBC_MOVDD, EBC_MOVDW, EBC_MOVQD, EBC_MOVQQ, EBC_MOVQW, EBC_MOVWD, EBC_MOVWW, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, setup::idx, snprintf, and TEST_BIT.

Referenced by decode_mov().

decode_movi()

static int decode_movi ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 725 of file ebc_disas.c.

                                                             {
    int ret = 2;
    char p1 = 0, p2 = 0;
    char indx[32] = { 0 };
    char op1[32];
    unsigned long immed = 0;
 
    switch (bytes[0] >> 6) {
    case 0: ret = -1; break;
    case 1: p2 = 'w'; break;
    case 2: p2 = 'd'; break;
    case 3: p2 = 'q'; break;
    }
 
    if (ret < 0) {
        return ret;
    }
 
    switch ((bytes[1] >> 4) & 0x3) {
    case 0: p1 = 'b'; break;
    case 1: p1 = 'w'; break;
    case 2: p1 = 'd'; break;
    case 3: p1 = 'q'; break;
    }
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%c%c",
        instr_names[bytes[0] & EBC_OPCODE_MASK], p1, p2);
 
    if (TEST_BIT(bytes[1], 6)) {
        char sign;
        ebc_index_t idx;
 
        decode_index16(bytes + 2, &idx);
        sign = idx.sign ? '+' : '-';
 
        snprintf(indx, 32, "(%c%u, %c%u)", sign, idx.n, sign, idx.c);
 
        ret += 2;
    }
 
    switch (p2) {
        ut16 i1;
        ut32 i2;
        ut64 i3;
    case 'w':
        i1 = *(ut16 *)(bytes + ret);
        immed = (unsigned long)i1;
        ret += 2;
        break;
    case 'd':
        i2 = *(ut32 *)(bytes + ret);
        immed = (unsigned long)i2;
        ret += 4;
        break;
    case 'q':
        i3 = *(ut64 *)(bytes + ret);
        immed = i3;
        ret += 8;
        break;
    }
 
    snprintf(op1, 32, "%sr%u", TEST_BIT(bytes[1], 3) ? "@" : "", bytes[1] & 0x7);
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s%s, %lu", op1, indx, immed);
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, i2, setup::idx, indx(), instr_names, long, snprintf, TEST_BIT, and ut64().

decode_movin()

static int decode_movin ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 791 of file ebc_disas.c.

                                                              {
    int ret = 2;
    char p1 = 0;
    char indx1[32] = { 0 };
    char indx2[32] = { 0 };
    char op1[32];
    char sign;
    ebc_index_t idx = { 0 };
 
    switch (bytes[0] >> 6) {
    case 0: ret = -1; break;
    case 1: p1 = 'w'; break;
    case 2: p1 = 'd'; break;
    case 3: p1 = 'q'; break;
    }
 
    if (ret < 0) {
        return ret;
    }
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%c",
        instr_names[bytes[0] & EBC_OPCODE_MASK], p1);
 
    if (TEST_BIT(bytes[1], 6)) {
        decode_index16(bytes + 2, &idx);
 
        sign = idx.sign ? '+' : '-';
 
        snprintf(indx1, 32, "(%c%u, %c%u)", sign,
            idx.n, sign, idx.c);
 
        ret += 2;
    }
 
    switch (p1) {
    case 'w':
        decode_index16(bytes + ret, &idx);
        ret += 2;
        break;
    case 'd':
        decode_index32(bytes + ret, &idx);
        ret += 4;
        break;
    case 'q':
        decode_index64(bytes + ret, &idx);
        ret += 8;
        break;
    }
 
    sign = idx.sign ? '+' : '-';
 
    snprintf(indx2, 32, "(%c%u, %c%u)", sign, idx.n, sign, idx.c);
 
    snprintf(op1, 32, "%sr%u", TEST_BIT(bytes[1], 3) ? "@" : "", bytes[1] & 0x7);
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s%s, %s", op1, indx1, indx2);
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), decode_index32(), decode_index64(), EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, setup::idx, instr_names, snprintf, and TEST_BIT.

decode_movn()

static int decode_movn ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 677 of file ebc_disas.c.

                                                             {
    int ret = 2;
    unsigned op1 = bytes[1] & 0x07;
    unsigned op2 = (bytes[1] >> 4) & 0x07;
    char op1c[32], op2c[32];
    char indx1[32] = { 0 };
    char indx2[32] = { 0 };
    char sign;
    ebc_index_t idx;
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s",
        instr_names[bytes[0] & EBC_OPCODE_MASK]);
 
    snprintf(op1c, 32, "%sr%u", TEST_BIT(bytes[1], 3) ? "@" : "", op1);
    snprintf(op2c, 32, "%sr%u", TEST_BIT(bytes[1], 7) ? "@" : "", op2);
 
    if ((bytes[0] & EBC_OPCODE_MASK) == EBC_MOVNW) {
        if (TEST_BIT(bytes[0], 7)) {
            decode_index16(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(indx1, 32, "(%c%u, %c%u)", sign, idx.n, sign, idx.c);
            ret += 2;
        }
        if (TEST_BIT(bytes[0], 6)) {
            decode_index16(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(indx2, 32, "(%c%u, %c%u)", sign, idx.n, sign, idx.c);
            ret += 2;
        }
    } else {
        if (TEST_BIT(bytes[0], 7)) {
            decode_index32(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(indx1, 32, "(%c%u, %c%u)", sign, idx.n, sign, idx.c);
            ret += 4;
        }
        if (TEST_BIT(bytes[0], 6)) {
            decode_index32(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(indx2, 32, "(%c%u, %c%u)", sign, idx.n, sign, idx.c);
            ret += 4;
        }
    }
 
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s%s, %s%s", op1c, indx1, op2c, indx2);
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), decode_index32(), EBC_INSTR_MAXLEN, EBC_MOVNW, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, setup::idx, instr_names, snprintf, and TEST_BIT.

decode_movrel()

static int decode_movrel ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 849 of file ebc_disas.c.

                                                               {
    int ret = 2;
    char p1 = 0;
    char op1[32];
    char indx[32] = { 0 };
    unsigned long immed = 0;
    unsigned formathex = 0;
 
    switch (bytes[0] >> 6) {
    case 0:
        ret = -1;
        break;
    case 1:
        p1 = 'w';
        formathex = 4;
        break;
    case 2:
        p1 = 'd';
        formathex = 8;
        break;
    case 3:
        p1 = 'q';
        formathex = 16;
        break;
    }
 
    if (ret < 0) {
        return ret;
    }
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%c",
        instr_names[bytes[0] & EBC_OPCODE_MASK], p1);
    snprintf(op1, 32, "%sr%u", TEST_BIT(bytes[1], 3) ? "@" : "", bytes[1] & 0x7);
 
    if (TEST_BIT(bytes[1], 6)) {
        ebc_index_t idx;
        char sign;
 
        decode_index16(bytes + 2, &idx);
        sign = idx.sign ? '+' : '-';
 
        snprintf(indx, 32, "(%c%u, %c%u)", sign, idx.n, sign, idx.c);
 
        ret += 2;
    }
 
    ut16 v16;
    ut32 v32;
    ut64 v64;
    switch (p1) {
    case 'w':
        v16 = *(ut16 *)(bytes + 2);
        immed = v16;
        ret += 2;
        break;
    case 'd':
        v32 = *(ut32 *)(bytes + 2);
        immed = v32;
        ret += 4;
        break;
    case 'q':
        v64 = *(ut64 *)(bytes + 2);
        immed = v64;
        ret += 8;
        break;
    }
 
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s%s, 0x%0*lx",
        op1, indx, formathex, immed);
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, setup::idx, indx(), instr_names, snprintf, TEST_BIT, and ut64().

decode_movsn()

static int decode_movsn ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 570 of file ebc_disas.c.

                                                              {
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s",
        instr_names[bytes[0] & EBC_OPCODE_MASK]);
    return decode_movsn_args(bytes, cmd);
}

References bytes, cmd, decode_movsn_args(), EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, instr_names, and snprintf.

decode_movsn_args()

static int decode_movsn_args ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 531 of file ebc_disas.c.

                                                                   {
    int ret = 2;
    unsigned op1, op2;
    char op1c[32], op2c[32], sign;
    char ind1[32] = { 0 }, ind2[32] = { 0 };
 
    op1 = bytes[1] & 0x07;
    op2 = (bytes[1] >> 4) & 0x07;
 
    snprintf(op1c, 32, "%sr%u", TEST_BIT(bytes[1], 3) ? "@" : "", op1);
    snprintf(op2c, 32, "%sr%u", TEST_BIT(bytes[1], 7) ? "@" : "", op2);
 
    switch (bytes[0] & EBC_OPCODE_MASK) {
    case EBC_MOVSNW:
        if (TEST_BIT(bytes[0], 7)) {
            ebc_index_t idx;
            ret += 2;
            decode_index16(bytes + 2, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind1, 32, "(%c%u, %c%u)",
                sign, idx.n, sign, idx.c);
        }
        if (TEST_BIT(bytes[0], 6)) {
            ebc_index_t idx;
            decode_index16(bytes + ret, &idx);
            sign = idx.sign ? '+' : '-';
            snprintf(ind2, 32, "(%c%u, %c%u)",
                sign, idx.n, sign, idx.c);
            ret += 2;
        }
        break;
    case EBC_MOVSND:
        break;
    }
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s%s, %s%s",
        op1c, ind1, op2c, ind2);
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_MOVSND, EBC_MOVSNW, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, setup::idx, snprintf, and TEST_BIT.

Referenced by decode_movsn().

decode_mul()

static int decode_mul ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 407 of file ebc_disas.c.

                                                            {
    int ret = decode_add(bytes, cmd);
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u",
        instr_names[EBC_MUL], bits);
    return ret;
}

References bits(), bytes, cmd, decode_add(), EBC_INSTR_MAXLEN, EBC_MUL, instr_names, snprintf, and TEST_BIT.

decode_mulu()

static int decode_mulu ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 415 of file ebc_disas.c.

                                                             {
    int ret = decode_add(bytes, cmd);
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u",
        instr_names[EBC_MULU], bits);
    return ret;
}

References bits(), bytes, cmd, decode_add(), EBC_INSTR_MAXLEN, EBC_MULU, instr_names, snprintf, and TEST_BIT.

decode_neg()

static int decode_neg ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 358 of file ebc_disas.c.

                                                            {
    int ret = decode_not(bytes, cmd);
    cmd->instr[1] = 'e';
    cmd->instr[2] = 'g';
    return ret;
}

References bytes, cmd, and decode_not().

decode_not()

static int decode_not ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 324 of file ebc_disas.c.

                                                            {
    int ret = 2;
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    unsigned op1, op2;
    char index[32] = { 0 };
    ut16 immed;
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u", instr_names[EBC_NOT],
        bits);
 
    op1 = bytes[1] & 0x07;
    op2 = (bytes[1] >> 4) & 0x07;
 
    if (TEST_BIT(bytes[0], 7)) {
        // immediate/index present
        ret = 4;
        if (TEST_BIT(bytes[1], 7)) {
            ebc_index_t idx;
            decode_index16(bytes + 2, &idx);
            snprintf(index, 32, " (%c%d, %c%d)",
                idx.sign ? '+' : '-', idx.n,
                idx.sign ? '+' : '-', idx.c);
        } else {
            immed = *(ut16 *)&bytes[2];
            snprintf(index, 32, "(%u)", immed);
        }
    }
 
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%sr%d, %sr%d%s",
        TEST_BIT(bytes[1], 3) ? "@" : "", op1,
        TEST_BIT(bytes[1], 7) ? "@" : "", op2, index);
    return ret;
}

References bits(), bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_INSTR_MAXLEN, EBC_NOT, EBC_OPERANDS_MAXLEN, setup::idx, instr_names, snprintf, and TEST_BIT.

Referenced by decode_neg().

decode_push_pop()

static int decode_push_pop ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 597 of file ebc_disas.c.

                                                                 {
    int ret = 2;
    unsigned op1 = bytes[1] & 0x07;
    char op1c[32];
 
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u",
        instr_names[bytes[0] & EBC_OPCODE_MASK],
        TEST_BIT(bytes[0], 6) ? 64 : 32);
 
    snprintf(op1c, sizeof(op1c), "%sr%d",
        TEST_BIT(bytes[1], 3) ? "@" : "", op1);
 
    if (TEST_BIT(bytes[0], 7)) {
        ret += 2;
        if (TEST_BIT(bytes[1], 3)) {
            ebc_index_t idx;
            char sign;
            decode_index16(bytes + 2, &idx);
 
            sign = idx.sign ? '+' : '-';
 
            CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s (%c%d, %c%d)",
                op1c, sign, idx.n, sign, idx.c);
        } else {
            ut16 immed = *(ut16 *)(bytes + 2);
 
            CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s %u",
                op1c, immed);
        }
    } else {
        CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "%s", op1c);
    }
 
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, decode_index16(), EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, setup::idx, instr_names, snprintf, and TEST_BIT.

decode_ret()

static int decode_ret ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 251 of file ebc_disas.c.

                                                            {
    int ret = 2;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s", instr_names[EBC_RET]);
    cmd->operands[0] = '\0';
    return ret;
}

References cmd, EBC_INSTR_MAXLEN, EBC_RET, instr_names, and snprintf.

decode_storesp()

static int decode_storesp ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 586 of file ebc_disas.c.

                                                                {
    int ret = 2;
    unsigned op2 = (bytes[1] >> 4) & 0x07;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s",
        instr_names[bytes[0] & EBC_OPCODE_MASK]);
    CHK_SNPRINTF(cmd->operands, EBC_OPERANDS_MAXLEN, "r%u, %s",
        bytes[1] & 0x7,
        op2 < 2 ? dedic_regs[op2] : "RESERVED_DEDICATED_REG");
    return ret;
}

References bytes, CHK_SNPRINTF, cmd, dedic_regs, EBC_INSTR_MAXLEN, EBC_OPCODE_MASK, EBC_OPERANDS_MAXLEN, instr_names, and snprintf.

decode_sub()

static int decode_sub ( const ut8 *  bytes, ebc_command_t *  cmd  )

static

Definition at line 399 of file ebc_disas.c.

                                                            {
    int ret = decode_add(bytes, cmd);
    unsigned bits = TEST_BIT(bytes[0], 6) ? 64 : 32;
    snprintf(cmd->instr, EBC_INSTR_MAXLEN, "%s%u",
        instr_names[EBC_SUB], bits);
    return ret;
}

References bits(), bytes, cmd, decode_add(), EBC_INSTR_MAXLEN, EBC_SUB, instr_names, snprintf, and TEST_BIT.

ebc_decode_command()

int ebc_decode_command	(	const ut8 *	instr,
		ebc_command_t *	cmd
	)

Definition at line 986 of file ebc_disas.c.

                                                             {
    if ((instr[0] & EBC_OPCODE_MASK) > 0x39) {
        {
            return -1;
        }
    }
    return decodes[instr[0] & EBC_OPCODE_MASK](instr, cmd);
}

References cmd, decodes, and EBC_OPCODE_MASK.

Referenced by disassemble(), and ebc_op().

Variable Documentation

decodes

decode decodes[EBC_COMMAND_NUM]

static

Definition at line 925 of file ebc_disas.c.

Referenced by ebc_decode_command().

dedic_regs

const char* dedic_regs[]

static

Initial value:

= {
    "FLAGS",
    "IP",
    "DR_RESERVED1",
    "DR_RESERVED2",
    "DR_RESERVED3",
    "DR_RESERVED4",
    "DR_RESERVED5",
    "DR_RESERVED6"
}

Definition at line 77 of file ebc_disas.c.

Referenced by decode_loadsp(), and decode_storesp().

instr_names

const char* instr_names[]

static

Definition at line 15 of file ebc_disas.c.

Referenced by decode_add(), decode_arith(), decode_break(), decode_call(), decode_cmpeq(), decode_cmpgte(), decode_cmpi(), decode_cmplte(), decode_cmpugte(), decode_cmpulte(), decode_div(), decode_divu(), decode_jmp(), decode_jmp8(), decode_loadsp(), decode_mov(), decode_movi(), decode_movin(), decode_movn(), decode_movrel(), decode_movsn(), decode_mul(), decode_mulu(), decode_not(), decode_push_pop(), decode_ret(), decode_storesp(), and decode_sub().