analysis_xcore_cs.c File Reference

#include <rz_analysis.h>
#include <rz_lib.h>
#include <capstone/capstone.h>
#include <capstone/xcore.h>

Go to the source code of this file.

Macros
#define	INSOP(n)   insn->detail->xcore.operands[n]

Functions
static void	opex (RzStrBuf *buf, csh handle, cs_insn *insn)
static int	analop (RzAnalysis *a, RzAnalysisOp *op, ut64 addr, const ut8 *buf, int len, RzAnalysisOpMask mask)

Variables
RzAnalysisPlugin	rz_analysis_plugin_xcore_cs
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

INSOP

#define INSOP

(

n

)

insn->detail->xcore.operands[n]

Definition at line 13 of file analysis_xcore_cs.c.

Function Documentation

analop()

static int analop ( RzAnalysis *  a, RzAnalysisOp *  op, ut64  addr, const ut8 *  buf, int  len, RzAnalysisOpMask  mask  )

static

Definition at line 57 of file analysis_xcore_cs.c.

                                                                                                              {
    static csh handle = 0;
    static int omode = 0;
    cs_insn *insn;
    int mode, n, ret;
    mode = CS_MODE_BIG_ENDIAN;
    if (!strcmp(a->cpu, "v9")) {
        mode |= CS_MODE_V9;
    }
    if (mode != omode) {
        if (handle) {
            cs_close(&handle);
            handle = 0;
        }
        omode = mode;
    }
    if (handle == 0) {
        ret = cs_open(CS_ARCH_XCORE, mode, &handle);
        if (ret != CS_ERR_OK) {
            return -1;
        }
        cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON);
    }
    // capstone-next
    n = cs_disasm(handle, (const ut8 *)buf, len, addr, 1, &insn);
    if (n < 1) {
        op->type = RZ_ANALYSIS_OP_TYPE_ILL;
    } else {
        if (mask & RZ_ANALYSIS_OP_MASK_OPEX) {
            opex(&op->opex, handle, insn);
        }
        op->size = insn->size;
        op->id = insn->id;
        switch (insn->id) {
        case XCORE_INS_DRET:
        case XCORE_INS_KRET:
        case XCORE_INS_RETSP:
            op->type = RZ_ANALYSIS_OP_TYPE_RET;
            break;
        case XCORE_INS_DCALL:
        case XCORE_INS_KCALL:
        case XCORE_INS_ECALLF:
        case XCORE_INS_ECALLT:
            op->type = RZ_ANALYSIS_OP_TYPE_CALL;
            op->jump = INSOP(0).imm;
            break;
        /* ??? */
        case XCORE_INS_BL:
        case XCORE_INS_BLA:
        case XCORE_INS_BLAT:
        case XCORE_INS_BT:
        case XCORE_INS_BF:
        case XCORE_INS_BU:
        case XCORE_INS_BRU:
            op->type = RZ_ANALYSIS_OP_TYPE_CALL;
            op->jump = INSOP(0).imm;
            break;
        case XCORE_INS_SUB:
        case XCORE_INS_LSUB:
            op->type = RZ_ANALYSIS_OP_TYPE_SUB;
            break;
        case XCORE_INS_ADD:
        case XCORE_INS_LADD:
            op->type = RZ_ANALYSIS_OP_TYPE_ADD;
            break;
        }
        cs_free(insn, n);
    }
    //  cs_close (&handle);
    return op->size;
}

References a, addr, CS_ARCH_XCORE, cs_close(), cs_disasm(), capstone::CS_ERR_OK, cs_free(), CS_MODE_BIG_ENDIAN, CS_MODE_V9, cs_open(), CS_OPT_DETAIL, CS_OPT_ON, cs_option(), handle, INSOP, len, mask, n, opex(), RZ_ANALYSIS_OP_MASK_OPEX, RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_SUB, XCORE_INS_ADD, XCORE_INS_BF, XCORE_INS_BL, XCORE_INS_BLA, XCORE_INS_BLAT, XCORE_INS_BRU, XCORE_INS_BT, XCORE_INS_BU, XCORE_INS_DCALL, XCORE_INS_DRET, XCORE_INS_ECALLF, XCORE_INS_ECALLT, XCORE_INS_KCALL, XCORE_INS_KRET, XCORE_INS_LADD, XCORE_INS_LSUB, XCORE_INS_RETSP, and XCORE_INS_SUB.

opex()

static void opex ( RzStrBuf *  buf, csh  handle, cs_insn *  insn  )

static

Definition at line 15 of file analysis_xcore_cs.c.

                                                           {
    int i;
    PJ *pj = pj_new();
    if (!pj) {
        return;
    }
    pj_o(pj);
    pj_ka(pj, "operands");
    cs_xcore *x = &insn->detail->xcore;
    for (i = 0; i < x->op_count; i++) {
        cs_xcore_op *op = x->operands + i;
        pj_o(pj);
        switch (op->type) {
        case XCORE_OP_REG:
            pj_ks(pj, "type", "reg");
            pj_ks(pj, "value", cs_reg_name(handle, op->reg));
            break;
        case XCORE_OP_IMM:
            pj_ks(pj, "type", "imm");
            pj_ki(pj, "value", op->imm);
            break;
        case XCORE_OP_MEM:
            pj_ks(pj, "type", "mem");
            if (op->mem.base != XCORE_REG_INVALID) {
                pj_ks(pj, "base", cs_reg_name(handle, op->mem.base));
            }
            pj_ki(pj, "disp", op->mem.disp);
            break;
        default:
            pj_ks(pj, "type", "invalid");
            break;
        }
        pj_end(pj); /* o operand */
    }
    pj_end(pj); /* a operands */
    pj_end(pj);
 
    rz_strbuf_init(buf);
    rz_strbuf_append(buf, pj_string(pj));
    pj_free(pj);
}

References cs_reg_name(), handle, i, pj_end(), pj_free(), pj_ka(), pj_ki(), pj_ks(), pj_new(), pj_o(), pj_string(), rz_strbuf_append(), rz_strbuf_init(), x, XCORE_OP_IMM, XCORE_OP_MEM, XCORE_OP_REG, and XCORE_REG_INVALID.

Referenced by analop().

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_ANALYSIS,
    .data = &rz_analysis_plugin_xcore_cs,
    .version = RZ_VERSION
}

Definition at line 141 of file analysis_xcore_cs.c.

rz_analysis_plugin_xcore_cs

RzAnalysisPlugin rz_analysis_plugin_xcore_cs

Initial value:

= {
    .name = "xcore",
    .desc = "Capstone XCORE analysis",
    .license = "BSD",
    .esil = false,
    .arch = "xcore",
    .bits = 32,
    .op = &analop,
    
}

Definition at line 129 of file analysis_xcore_cs.c.