analysis_sysz.c File Reference

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

Go to the source code of this file.

Macros
#define	INSOP(n)   insn->detail->sysz.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)
static char *	get_reg_profile (RzAnalysis *analysis)
static int	archinfo (RzAnalysis *analysis, int q)

Variables
RzAnalysisPlugin	rz_analysis_plugin_sysz
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

INSOP

#define INSOP

(

n

)

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

Definition at line 14 of file analysis_sysz.c.

Function Documentation

analop()

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

static

Definition at line 58 of file analysis_sysz.c.

                                                                                                              {
    csh handle;
    cs_insn *insn;
    int mode = CS_MODE_BIG_ENDIAN;
    int ret = cs_open(CS_ARCH_SYSZ, mode, &handle);
    if (ret == CS_ERR_OK) {
        cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON);
        // capstone-next
        int 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;
            switch (insn->id) {
            case SYSZ_INS_BRCL:
            case SYSZ_INS_BRASL:
                op->type = RZ_ANALYSIS_OP_TYPE_CALL;
                break;
            case SYSZ_INS_BR:
                op->type = RZ_ANALYSIS_OP_TYPE_JMP;
                break;
            case SYSZ_INS_BRC:
            case SYSZ_INS_BER:
            case SYSZ_INS_BHR:
            case SYSZ_INS_BHER:
            case SYSZ_INS_BLR:
            case SYSZ_INS_BLER:
            case SYSZ_INS_BLHR:
            case SYSZ_INS_BNER:
            case SYSZ_INS_BNHR:
            case SYSZ_INS_BNHER:
            case SYSZ_INS_BNLR:
            case SYSZ_INS_BNLER:
            case SYSZ_INS_BNLHR:
            case SYSZ_INS_BNOR:
            case SYSZ_INS_BOR:
            case SYSZ_INS_BASR:
            case SYSZ_INS_BRAS:
            case SYSZ_INS_BRCT:
            case SYSZ_INS_BRCTG:
                op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
                break;
            case SYSZ_INS_JE:
            case SYSZ_INS_JGE:
            case SYSZ_INS_JHE:
            case SYSZ_INS_JGHE:
            case SYSZ_INS_JH:
            case SYSZ_INS_JGH:
            case SYSZ_INS_JLE:
            case SYSZ_INS_JGLE:
            case SYSZ_INS_JLH:
            case SYSZ_INS_JGLH:
            case SYSZ_INS_JL:
            case SYSZ_INS_JGL:
            case SYSZ_INS_JNE:
            case SYSZ_INS_JGNE:
            case SYSZ_INS_JNHE:
            case SYSZ_INS_JGNHE:
            case SYSZ_INS_JNH:
            case SYSZ_INS_JGNH:
            case SYSZ_INS_JNLE:
            case SYSZ_INS_JGNLE:
            case SYSZ_INS_JNLH:
            case SYSZ_INS_JGNLH:
            case SYSZ_INS_JNL:
            case SYSZ_INS_JGNL:
            case SYSZ_INS_JNO:
            case SYSZ_INS_JGNO:
            case SYSZ_INS_JO:
            case SYSZ_INS_JGO:
            case SYSZ_INS_JG:
                op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
                op->jump = INSOP(0).imm;
                op->fail = addr + op->size;
                break;
            case SYSZ_INS_J:
                op->type = RZ_ANALYSIS_OP_TYPE_JMP;
                op->jump = INSOP(0).imm;
                op->fail = UT64_MAX;
                break;
            }
        }
        cs_free(insn, n);
        cs_close(&handle);
    }
    return op->size;
}

References addr, CS_ARCH_SYSZ, cs_close(), cs_disasm(), capstone::CS_ERR_OK, cs_free(), CS_MODE_BIG_ENDIAN, 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_CALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_JMP, SYSZ_INS_BASR, SYSZ_INS_BER, SYSZ_INS_BHER, SYSZ_INS_BHR, SYSZ_INS_BLER, SYSZ_INS_BLHR, SYSZ_INS_BLR, SYSZ_INS_BNER, SYSZ_INS_BNHER, SYSZ_INS_BNHR, SYSZ_INS_BNLER, SYSZ_INS_BNLHR, SYSZ_INS_BNLR, SYSZ_INS_BNOR, SYSZ_INS_BOR, SYSZ_INS_BR, SYSZ_INS_BRAS, SYSZ_INS_BRASL, SYSZ_INS_BRC, SYSZ_INS_BRCL, SYSZ_INS_BRCT, SYSZ_INS_BRCTG, SYSZ_INS_J, SYSZ_INS_JE, SYSZ_INS_JG, SYSZ_INS_JGE, SYSZ_INS_JGH, SYSZ_INS_JGHE, SYSZ_INS_JGL, SYSZ_INS_JGLE, SYSZ_INS_JGLH, SYSZ_INS_JGNE, SYSZ_INS_JGNH, SYSZ_INS_JGNHE, SYSZ_INS_JGNL, SYSZ_INS_JGNLE, SYSZ_INS_JGNLH, SYSZ_INS_JGNO, SYSZ_INS_JGO, SYSZ_INS_JH, SYSZ_INS_JHE, SYSZ_INS_JL, SYSZ_INS_JLE, SYSZ_INS_JLH, SYSZ_INS_JNE, SYSZ_INS_JNH, SYSZ_INS_JNHE, SYSZ_INS_JNL, SYSZ_INS_JNLE, SYSZ_INS_JNLH, SYSZ_INS_JNO, SYSZ_INS_JO, and UT64_MAX.

archinfo()

static int archinfo ( RzAnalysis *  analysis, int  q  )

static

Definition at line 187 of file analysis_sysz.c.

                                                 {
    switch (q) {
    case RZ_ANALYSIS_ARCHINFO_ALIGN:
        return 2;
    case RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE:
        return 4;
    case RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE:
        return 2;
    }
    return 2;
}

References RZ_ANALYSIS_ARCHINFO_ALIGN, RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE, and RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE.

get_reg_profile()

static char* get_reg_profile ( RzAnalysis *  analysis )

static

Definition at line 149 of file analysis_sysz.c.

                                                   {
    const char *p =
        "=PC    r15\n"
        "=LR    r14\n"
        "=SP    r13\n"
        "=BP    r12\n"
        "=A0    r0\n"
        "=A1    r1\n"
        "=A2    r2\n"
        "=A3    r3\n"
        "=SN    r0\n"
        "gpr    sb  .32 36  0\n" // r9
        "gpr    sl  .32 40  0\n" // rl0
        "gpr    fp  .32 44  0\n" // r11
        "gpr    ip  .32 48  0\n" // r12
        "gpr    sp  .32 52  0\n" // r13
        "gpr    lr  .32 56  0\n" // r14
        "gpr    pc  .32 60  0\n" // r15
 
        "gpr    r0  .32 0   0\n"
        "gpr    r1  .32 4   0\n"
        "gpr    r2  .32 8   0\n"
        "gpr    r3  .32 12  0\n"
        "gpr    r4  .32 16  0\n"
        "gpr    r5  .32 20  0\n"
        "gpr    r6  .32 24  0\n"
        "gpr    r7  .32 28  0\n"
        "gpr    r8  .32 32  0\n"
        "gpr    r9  .32 36  0\n"
        "gpr    r10 .32 40  0\n"
        "gpr    r11 .32 44  0\n"
        "gpr    r12 .32 48  0\n"
        "gpr    r13 .32 52  0\n"
        "gpr    r14 .32 56  0\n"
        "gpr    r15 .32 60  0\n";
    return strdup(p);
}

References p, and strdup().

opex()

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

static

Definition at line 16 of file analysis_sysz.c.

                                                           {
    int i;
    PJ *pj = pj_new();
    if (!pj) {
        return;
    }
    pj_o(pj);
    pj_ka(pj, "operands");
    cs_sysz *x = &insn->detail->sysz;
    for (i = 0; i < x->op_count; i++) {
        cs_sysz_op *op = x->operands + i;
        pj_o(pj);
        switch (op->type) {
        case SYSZ_OP_REG:
            pj_ks(pj, "type", "reg");
            pj_ks(pj, "value", cs_reg_name(handle, op->reg));
            break;
        case SYSZ_OP_IMM:
            pj_ks(pj, "type", "imm");
            pj_kN(pj, "value", op->imm);
            break;
        case SYSZ_OP_MEM:
            pj_ks(pj, "type", "mem");
            if (op->mem.base != SYSZ_REG_INVALID) {
                pj_ks(pj, "base", cs_reg_name(handle, op->mem.base));
            }
            pj_kN(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_kN(), pj_ks(), pj_new(), pj_o(), pj_string(), rz_strbuf_append(), rz_strbuf_init(), SYSZ_OP_IMM, SYSZ_OP_MEM, SYSZ_OP_REG, SYSZ_REG_INVALID, and x.

Referenced by analop().

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 212 of file analysis_sysz.c.

rz_analysis_plugin_sysz

RzAnalysisPlugin rz_analysis_plugin_sysz

Initial value:

= {
    .name = "sysz",
    .desc = "Capstone SystemZ microanalysis",
    .esil = false,
    .license = "BSD",
    .arch = "sysz",
    .bits = 32 | 64,
    .op = &analop,
    .archinfo = archinfo,
    .get_reg_profile = &get_reg_profile,
}

Definition at line 199 of file analysis_sysz.c.