mcore.c File Reference

#include "mcore.h"
#include <rz_analysis.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

Go to the source code of this file.

Classes
struct	mcore_mask
struct	mcore_ops

Macros
#define	MCORE_INSTR_ALIGN   (2)
#define	INVALID_FIELD   (0)
#define	MCORE_INSTRS   265

Typedefs
typedef struct mcore_mask	mcore_mask_t
typedef struct mcore_ops	mcore_ops_t

Functions
static mcore_t *	find_instruction (const ut8 *buffer)
int	mcore_init (mcore_handle *handle, const ut8 *buffer, const ut32 size)
mcore_t *	mcore_next (mcore_handle *handle)
void	mcore_free (mcore_t *instr)
void	print_loop (char *str, int size, ut64 addr, mcore_t *instr)
void	mcore_snprint (char *str, int size, ut64 addr, mcore_t *instr)

Variables
static const char *	mcore_ctrl_registers []
ut16	load_shift [4] = { 2, 0, 1, 0 }
mcore_ops_t	mcore_instructions [MCORE_INSTRS]

Macro Definition Documentation

INVALID_FIELD

#define INVALID_FIELD   (0)

Definition at line 76 of file mcore.c.

MCORE_INSTR_ALIGN

#define MCORE_INSTR_ALIGN   (2)

Definition at line 14 of file mcore.c.

MCORE_INSTRS

#define MCORE_INSTRS   265

Definition at line 95 of file mcore.c.

Typedef Documentation

mcore_mask_t

typedef struct mcore_mask mcore_mask_t

mcore_ops_t

typedef struct mcore_ops mcore_ops_t

Function Documentation

find_instruction()

static mcore_t* find_instruction ( const ut8 *  buffer )

static

Definition at line 363 of file mcore.c.

                                                    {
    ut32 i = 0;
    mcore_ops_t *op_ptr = NULL;
    mcore_t *op = NULL;
    if (!buffer || !(op = malloc(sizeof(mcore_t)))) {
        return NULL;
    }
    memset(op, 0, sizeof(mcore_t));
    ut32 count = sizeof(mcore_instructions) / sizeof(mcore_ops_t);
    ut16 data = buffer[1] << 8;
    data |= buffer[0];
    op->bytes = data;
    op->size = MCORE_INSTR_ALIGN;
    if (data == 0) {
        op_ptr = &mcore_instructions[0];
    } else {
        for (i = 1; i < count; i++) {
            op_ptr = &mcore_instructions[i];
            ut16 masked = data & op_ptr->mask;
            // always masking with zero returns 0
            if (masked == data) {
                break;
            }
        }
        if (i >= count) {
            op->name = "illegal";
            return op;
        }
    }
 
    if (!strncmp(op_ptr->name, "lrw", 3) && (data & 0xf00) == 0xf00) {
        // is jump
        if (i > 0 && i < MCORE_INSTRS) {
            op_ptr = &mcore_instructions[i + 1];
        }
    }
    op->type = op_ptr->type;
    op->name = op_ptr->name;
    op->n_args = op_ptr->n_args;
    for (i = 0; i < op_ptr->n_args; i++) {
        op->args[i].value = (data & op_ptr->args[i].mask) >> op_ptr->args[i].shift;
        op->args[i].type = op_ptr->args[i].type;
    }
    return op;
}

References mcore_ops::args, count, i, malloc(), mcore_mask::mask, mcore_ops::mask, MCORE_INSTR_ALIGN, MCORE_INSTRS, mcore_instructions, memset(), mcore_ops::n_args, mcore_ops::name, NULL, op, mcore_mask::shift, mcore_mask::type, and mcore_ops::type.

Referenced by mcore_next().

mcore_free()

void mcore_free

(

mcore_t *

instr

)

Definition at line 432 of file mcore.c.

                                {
    free(instr);
}

References free().

Referenced by disassemble(), and mcore_analysis().

mcore_init()

int mcore_init	(	mcore_handle *	handle,
		const ut8 *	buffer,
		const ut32	size
	)

Definition at line 409 of file mcore.c.

                                                                         {
    if (!handle || !buffer || size < 2) {
        return 1;
    }
    handle->pos = buffer;
    handle->end = buffer + size;
    return 0;
}

References mcore_handle::end, handle, and mcore_handle::pos.

Referenced by disassemble(), and mcore_analysis().

mcore_next()

mcore_t* mcore_next

(

mcore_handle *

handle

)

Definition at line 418 of file mcore.c.

                                          {
    mcore_t *op = NULL;
    if (!handle || handle->pos + MCORE_INSTR_ALIGN > handle->end) {
        return NULL;
    }
 
    if (!op && handle->pos + 2 <= handle->end) {
        op = find_instruction(handle->pos);
    }
    handle->pos += MCORE_INSTR_ALIGN;
 
    return op;
}

References mcore_handle::end, find_instruction(), handle, MCORE_INSTR_ALIGN, NULL, op, and mcore_handle::pos.

Referenced by disassemble(), and mcore_analysis().

mcore_snprint()

void mcore_snprint	(	char *	str,
		int	size,
		ut64	addr,
		mcore_t *	instr
	)

Definition at line 469 of file mcore.c.

                                                                   {
    ut32 imm;
    if (!instr || !str) {
        return;
    }
    switch (instr->type) {
    case RZ_ANALYSIS_OP_TYPE_LOAD:
    case RZ_ANALYSIS_OP_TYPE_STORE:
        imm = instr->args[1].value << load_shift[instr->args[3].value];
        snprintf(str, size, "%s r%u, (r%u, 0x%x)",
            instr->name, instr->args[2].value, instr->args[0].value, imm);
        break;
    default:
        print_loop(str, size, addr, instr);
        break;
    }
}

References addr, mcore_t::args, imm, load_shift, mcore_t::name, print_loop(), RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_STORE, snprintf, cmd_descs_generate::str, mcore_t::type, and mcore_field_t::value.

Referenced by disassemble().

print_loop()

void print_loop	(	char *	str,
		int	size,
		ut64	addr,
		mcore_t *	instr
	)

Definition at line 436 of file mcore.c.

                                                                {
    ut32 i;
    int bufsize = size;
    int add = snprintf(str, bufsize, "%s", instr->name);
    for (i = 0; add > 0 && i < instr->n_args && add < bufsize; i++) {
        if (instr->args[i].type == TYPE_REG) {
            add += snprintf(str + add, bufsize - add, " r%u,", instr->args[i].value);
        } else if (instr->args[i].type == TYPE_IMM) {
            add += snprintf(str + add, bufsize - add, " 0x%x,", instr->args[i].value);
        } else if (instr->args[i].type == TYPE_MEM) {
            add += snprintf(str + add, bufsize - add, " 0x%x(r%d),",
                instr->args[i + 1].value, instr->args[i].value);
            i++;
        } else if (instr->args[i].type == TYPE_JMPI) {
            ut64 jump = addr + ((instr->args[i].value << 2) & 0xfffffffc);
            add += snprintf(str + add, bufsize - add, " [0x%" PFMT64x "],", jump);
        } else if (instr->args[i].type == TYPE_JMP) {
            ut64 jump = addr + instr->args[i].value + 1;
            add += snprintf(str + add, bufsize - add, " 0x%" PFMT64x ",", jump);
        } else if (instr->args[i].type == TYPE_CTRL) {
            ut32 pos = instr->args[i].value;
            if (pos >= 32) {
                pos = 32;
            }
            add += snprintf(str + add, bufsize - add, " %s,", mcore_ctrl_registers[pos]);
        }
    }
    if (instr->n_args) {
        // removing a comma
        *(str + add - 1) = 0;
    }
}

References add(), addr, mcore_t::args, i, jump(), mcore_ctrl_registers, mcore_t::n_args, mcore_t::name, PFMT64x, pos, snprintf, cmd_descs_generate::str, mcore_field_t::type, TYPE_CTRL, TYPE_IMM, TYPE_JMP, TYPE_JMPI, TYPE_MEM, TYPE_REG, ut64(), and mcore_field_t::value.

Referenced by mcore_snprint().

Variable Documentation

load_shift

ut16 load_shift[4] = { 2, 0, 1, 0 }

Definition at line 93 of file mcore.c.

Referenced by mcore_snprint().

mcore_ctrl_registers

const char* mcore_ctrl_registers[]

static

Definition at line 17 of file mcore.c.

Referenced by print_loop().

mcore_instructions

mcore_ops_t mcore_instructions[MCORE_INSTRS]

Definition at line 96 of file mcore.c.

Referenced by find_instruction().