analysis_ppc_cs.c File Reference

#include <rz_analysis.h>
#include <rz_lib.h>
#include <capstone/capstone.h>
#include <capstone/ppc.h>
#include "../../asm/arch/ppc/libvle/vle.h"

Go to the source code of this file.

Classes
struct	Getarg

Macros
#define	SPR_HID0   0x3f0 /* Hardware Implementation Register 0 */
#define	SPR_HID1   0x3f1 /* Hardware Implementation Register 1 */
#define	SPR_HID2   0x3f3 /* Hardware Implementation Register 2 */
#define	SPR_HID4   0x3f4 /* Hardware Implementation Register 4 */
#define	SPR_HID5   0x3f6 /* Hardware Implementation Register 5 */
#define	SPR_HID6   0x3f9 /* Hardware Implementation Register 6 */
#define	INSOPS   insn->detail->ppc.op_count
#define	INSOP(n)   insn->detail->ppc.operands[n]
#define	IMM(x)   (ut64)(insn->detail->ppc.operands[x].imm)
#define	PFMT32x   "lx"
#define	PPCSPR(n)   getspr(&gop, n)
#define	ARG(n)   getarg2(&gop, n, "")
#define	ARG2(n, m)   getarg2(&gop, n, m)
#define	KW(d, ds, m, ms)   rz_list_append(l, rz_search_keyword_new((const ut8 *)d, ds, (const ut8 *)m, ms, NULL))

Functions
static ut64	mask64 (ut64 mb, ut64 me)
static ut32	mask32 (ut32 mb, ut32 me)
static const char *	cmask64 (const char *mb_c, const char *me_c)
static const char *	cmask32 (const char *mb_c, const char *me_c)
static char *	getarg2 (struct Getarg *gop, int n, const char *setstr)
static ut64	getarg (struct Getarg *gop, int n)
static const char *	getspr (struct Getarg *gop, int n)
static void	opex (RzStrBuf *buf, csh handle, cs_insn *insn)
static char *	get_reg_profile (RzAnalysis *analysis)
static int	analop_vle (RzAnalysis *a, RzAnalysisOp *op, ut64 addr, const ut8 *buf, int len, RzAnalysisOpMask mask)
static int	parse_reg_name (RzRegItem *reg, csh handle, cs_insn *insn, int reg_num)
static void	create_src_dst (RzAnalysisOp *op)
static void	set_src_dst (RzAnalysisValue *val, csh *handle, cs_insn *insn, int x)
static void	op_fillval (RzAnalysisOp *op, csh handle, cs_insn *insn)
static char *	shrink (char *op)
static int	analop (RzAnalysis *a, RzAnalysisOp *op, ut64 addr, const ut8 *buf, int len, RzAnalysisOpMask mask)
static int	archinfo (RzAnalysis *a, int q)
static RzList *	analysis_preludes (RzAnalysis *analysis)

Variables
static RzRegItem	base_regs [4]
RzAnalysisPlugin	rz_analysis_plugin_ppc_cs
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

ARG

#define ARG

(

n

)

getarg2(&gop, n, "")

Definition at line 207 of file analysis_ppc_cs.c.

ARG2

#define ARG2	(		n,
			m
	)		getarg2(&gop, n, m)

Definition at line 208 of file analysis_ppc_cs.c.

IMM

#define IMM

(

x

)

(ut64)(insn->detail->ppc.operands[x].imm)

Definition at line 25 of file analysis_ppc_cs.c.

INSOP

#define INSOP

(

n

)

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

Definition at line 24 of file analysis_ppc_cs.c.

INSOPS

#define INSOPS   insn->detail->ppc.op_count

Definition at line 23 of file analysis_ppc_cs.c.

KW

#define KW	(		d,
			ds,
			m,
			ms
	)		rz_list_append(l, rz_search_keyword_new((const ut8 *)d, ds, (const ut8 *)m, ms, NULL))

PFMT32x

#define PFMT32x   "lx"

Definition at line 28 of file analysis_ppc_cs.c.

PPCSPR

#define PPCSPR

(

n

)

getspr(&gop, n)

Definition at line 206 of file analysis_ppc_cs.c.

SPR_HID0

#define SPR_HID0   0x3f0 /* Hardware Implementation Register 0 */

Definition at line 10 of file analysis_ppc_cs.c.

SPR_HID1

#define SPR_HID1   0x3f1 /* Hardware Implementation Register 1 */

Definition at line 11 of file analysis_ppc_cs.c.

SPR_HID2

#define SPR_HID2   0x3f3 /* Hardware Implementation Register 2 */

Definition at line 12 of file analysis_ppc_cs.c.

SPR_HID4

#define SPR_HID4   0x3f4 /* Hardware Implementation Register 4 */

Definition at line 13 of file analysis_ppc_cs.c.

SPR_HID5

#define SPR_HID5   0x3f6 /* Hardware Implementation Register 5 */

Definition at line 14 of file analysis_ppc_cs.c.

SPR_HID6

#define SPR_HID6   0x3f9 /* Hardware Implementation Register 6 */

Definition at line 15 of file analysis_ppc_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 601 of file analysis_ppc_cs.c.

                                                                                                              {
    static csh handle = 0;
    static int omode = -1, obits = -1;
    int n, ret;
    cs_insn *insn;
    char *op1;
    int mode = (a->bits == 64) ? CS_MODE_64 : (a->bits == 32) ? CS_MODE_32
                                  : 0;
    mode |= a->big_endian ? CS_MODE_BIG_ENDIAN : CS_MODE_LITTLE_ENDIAN;
 
    if (a->cpu && strncmp(a->cpu, "vle", 3) == 0) {
        // vle is big-endian only
        if (!a->big_endian) {
            return -1;
        }
        ret = analop_vle(a, op, addr, buf, len, mask);
        if (ret >= 0) {
            return op->size;
        }
    }
 
    if (mode != omode || a->bits != obits) {
        cs_close(&handle);
        handle = 0;
        omode = mode;
        obits = a->bits;
    }
    if (handle == 0) {
        ret = cs_open(CS_ARCH_PPC, mode, &handle);
        if (ret != CS_ERR_OK) {
            return -1;
        }
        cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON);
    }
    op->size = 4;
 
    // 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_DISASM) {
            op->mnemonic = strdup(insn->mnemonic);
        }
        if (mask & RZ_ANALYSIS_OP_MASK_OPEX) {
            opex(&op->opex, handle, insn);
        }
        struct Getarg gop = {
            .handle = handle,
            .insn = insn,
            .bits = a->bits
        };
        op->size = insn->size;
        op->id = insn->id;
        switch (insn->id) {
#if CS_API_MAJOR >= 4
        case PPC_INS_CMPB:
#endif
        case PPC_INS_CMPD:
        case PPC_INS_CMPDI:
        case PPC_INS_CMPLD:
        case PPC_INS_CMPLDI:
        case PPC_INS_CMPLW:
        case PPC_INS_CMPLWI:
        case PPC_INS_CMPW:
        case PPC_INS_CMPWI:
#if CS_API_MAJOR > 4
        case PPC_INS_CMP:
        case PPC_INS_CMPI:
#endif
            op->type = RZ_ANALYSIS_OP_TYPE_CMP;
            op->sign = true;
            if (ARG(2)[0] == '\0') {
                esilprintf(op, "%s,%s,-,0xff,&,cr0,=", ARG(1), ARG(0));
            } else {
                esilprintf(op, "%s,%s,-,0xff,&,%s,=", ARG(2), ARG(1), ARG(0));
            }
            break;
        case PPC_INS_MFLR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "lr,%s,=", ARG(0));
            break;
        case PPC_INS_MTLR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,lr,=", ARG(0));
            break;
        case PPC_INS_MR:
        case PPC_INS_LI:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            op->val = IMM(1);
            esilprintf(op, "%s,%s,=", ARG(1), ARG(0));
            break;
        case PPC_INS_LIS:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            op->val = IMM(1);
            op->val <<= 16;
            esilprintf(op, "%s0000,%s,=", ARG(1), ARG(0));
            break;
        case PPC_INS_CLRLWI:
            op->type = RZ_ANALYSIS_OP_TYPE_AND;
            esilprintf(op, "%s,%s,&,%s,=", ARG(1), cmask32(ARG(2), "0x1F"), ARG(0));
            break;
        case PPC_INS_RLWINM:
            op->type = RZ_ANALYSIS_OP_TYPE_ROL;
            esilprintf(op, "%s,%s,<<<,%s,&,%s,=", ARG(2), ARG(1), cmask32(ARG(3), ARG(4)), ARG(0));
            break;
        case PPC_INS_SC:
            op->type = RZ_ANALYSIS_OP_TYPE_SWI;
            esilprintf(op, "0,$");
            break;
        case PPC_INS_EXTSB:
            op->sign = true;
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            if (a->bits == 64) {
                esilprintf(op, "%s,0x80,&,?{,0xFFFFFFFFFFFFFF00,%s,|,%s,=,}", ARG(1), ARG(1), ARG(0));
            } else {
                esilprintf(op, "%s,0x80,&,?{,0xFFFFFF00,%s,|,%s,=,}", ARG(1), ARG(1), ARG(0));
            }
            break;
        case PPC_INS_EXTSH:
            op->sign = true;
            if (a->bits == 64) {
                esilprintf(op, "%s,0x8000,&,?{,0xFFFFFFFFFFFF0000,%s,|,%s,=,}", ARG(1), ARG(1), ARG(0));
            } else {
                esilprintf(op, "%s,0x8000,&,?{,0xFFFF0000,%s,|,%s,=,}", ARG(1), ARG(1), ARG(0));
            }
            break;
        case PPC_INS_EXTSW:
            op->sign = true;
            esilprintf(op, "%s,0x80000000,&,?{,0xFFFFFFFF00000000,%s,|,%s,=,}", ARG(1), ARG(1), ARG(0));
            break;
        case PPC_INS_SYNC:
        case PPC_INS_ISYNC:
        case PPC_INS_LWSYNC:
        case PPC_INS_MSYNC:
        case PPC_INS_PTESYNC:
        case PPC_INS_TLBSYNC:
        case PPC_INS_SLBIA:
        case PPC_INS_SLBIE:
        case PPC_INS_SLBMFEE:
        case PPC_INS_SLBMTE:
        case PPC_INS_EIEIO:
        case PPC_INS_NOP:
            op->type = RZ_ANALYSIS_OP_TYPE_NOP;
            esilprintf(op, ",");
            break;
        case PPC_INS_STW:
        case PPC_INS_STWUX:
        case PPC_INS_STWX:
        case PPC_INS_STWCX:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            esilprintf(op, "%s,%s", ARG(0), ARG2(1, "=[4]"));
            break;
        case PPC_INS_STWU:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,%s,=[4],%s=", ARG(0), op1, op1);
            if (strstr(op1, "r1")) {
                op->stackop = RZ_ANALYSIS_STACK_INC;
                op->stackptr = -atoi(op1);
            }
            break;
        case PPC_INS_STWBRX:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            break;
        case PPC_INS_STB:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            esilprintf(op, "%s,%s", ARG(0), ARG2(1, "=[1]"));
            break;
        case PPC_INS_STBU:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,%s,=[1],%s=", ARG(0), op1, op1);
            break;
        case PPC_INS_STH:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            esilprintf(op, "%s,%s", ARG(0), ARG2(1, "=[2]"));
            break;
        case PPC_INS_STHU:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,%s,=[2],%s=", ARG(0), op1, op1);
            break;
        case PPC_INS_STD:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            esilprintf(op, "%s,%s", ARG(0), ARG2(1, "=[8]"));
            break;
        case PPC_INS_STDU:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,%s,=[8],%s=", ARG(0), op1, op1);
            break;
        case PPC_INS_LBZ:
#if CS_API_MAJOR >= 4
        case PPC_INS_LBZCIX:
#endif
        case PPC_INS_LBZU:
        case PPC_INS_LBZUX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,[1],%s,=,%s=", op1, ARG(0), op1);
            break;
        case PPC_INS_LBZX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            esilprintf(op, "%s,%s,=", ARG2(1, "[1]"), ARG(0));
            break;
        case PPC_INS_LD:
        case PPC_INS_LDARX:
#if CS_API_MAJOR >= 4
        case PPC_INS_LDCIX:
#endif
        case PPC_INS_LDU:
        case PPC_INS_LDUX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,[8],%s,=,%s=", op1, ARG(0), op1);
            break;
        case PPC_INS_LDX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            esilprintf(op, "%s,%s,=", ARG2(1, "[8]"), ARG(0));
            break;
        case PPC_INS_LDBRX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            break;
        case PPC_INS_LFD:
        case PPC_INS_LFDU:
        case PPC_INS_LFDUX:
        case PPC_INS_LFDX:
        case PPC_INS_LFIWAX:
        case PPC_INS_LFIWZX:
        case PPC_INS_LFS:
        case PPC_INS_LFSU:
        case PPC_INS_LFSUX:
        case PPC_INS_LFSX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            esilprintf(op, "%s,%s,=", ARG2(1, "[4]"), ARG(0));
            break;
        case PPC_INS_LHA:
        case PPC_INS_LHAU:
        case PPC_INS_LHAUX:
        case PPC_INS_LHAX:
        case PPC_INS_LHZ:
        case PPC_INS_LHZU:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,[2],%s,=,%s=", op1, ARG(0), op1);
            break;
        case PPC_INS_LHBRX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            break;
        case PPC_INS_LWA:
        case PPC_INS_LWARX:
        case PPC_INS_LWAUX:
        case PPC_INS_LWAX:
        case PPC_INS_LWZ:
#if CS_API_MAJOR >= 4
        case PPC_INS_LWZCIX:
#endif
        case PPC_INS_LWZX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            esilprintf(op, "%s,%s,=", ARG2(1, "[4]"), ARG(0));
            break;
        case PPC_INS_LWZU:
        case PPC_INS_LWZUX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            op1 = shrink(ARG(1));
            if (!op1) {
                break;
            }
            esilprintf(op, "%s,[4],%s,=,%s=", op1, ARG(0), op1);
            break;
        case PPC_INS_LWBRX:
            op->type = RZ_ANALYSIS_OP_TYPE_LOAD;
            break;
        case PPC_INS_SLW:
        case PPC_INS_SLWI:
            op->type = RZ_ANALYSIS_OP_TYPE_SHL;
            esilprintf(op, "%s,%s,<<,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_SRW:
        case PPC_INS_SRWI:
            op->type = RZ_ANALYSIS_OP_TYPE_SHR;
            esilprintf(op, "%s,%s,>>,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_MULLI:
            op->sign = true;
            // fallthrough
        case PPC_INS_MULLW:
        case PPC_INS_MULLD:
            op->type = RZ_ANALYSIS_OP_TYPE_MUL;
            esilprintf(op, "%s,%s,*,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_SUB:
        case PPC_INS_SUBC:
        case PPC_INS_SUBF:
        case PPC_INS_SUBFIC:
        case PPC_INS_SUBFZE:
            op->type = RZ_ANALYSIS_OP_TYPE_SUB;
            esilprintf(op, "%s,%s,-,%s,=", ARG(1), ARG(2), ARG(0));
            break;
        case PPC_INS_ADDI:
            op->val = ((st16)IMM(2));
            // fallthrough
        case PPC_INS_ADD:
            op->sign = true;
            op->type = RZ_ANALYSIS_OP_TYPE_ADD;
            esilprintf(op, "%s,%s,+,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_CRCLR:
        case PPC_INS_CRSET:
        case PPC_INS_CRMOVE:
        case PPC_INS_CRXOR:
        case PPC_INS_CRNOR:
        case PPC_INS_CRNOT:
            // reset conditional bits
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            break;
        case PPC_INS_ADDC:
        case PPC_INS_ADDIC:
            op->type = RZ_ANALYSIS_OP_TYPE_ADD;
            esilprintf(op, "%s,%s,+,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_ADDE:
        case PPC_INS_ADDIS:
        case PPC_INS_ADDME:
        case PPC_INS_ADDZE:
            op->type = RZ_ANALYSIS_OP_TYPE_ADD;
            esilprintf(op, "%s,%s,+,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_MTSPR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,%s,=", ARG(1), PPCSPR(0));
            break;
        case PPC_INS_BCTR: // switch table here
            op->type = RZ_ANALYSIS_OP_TYPE_UJMP;
            esilprintf(op, "ctr,pc,=");
            break;
        case PPC_INS_BCTRL: // switch table here
            op->type = RZ_ANALYSIS_OP_TYPE_CALL;
            esilprintf(op, "pc,lr,=,ctr,pc,=");
            break;
        case PPC_INS_B:
        case PPC_INS_BC:
        case PPC_INS_BA:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = ARG(1)[0] == '\0' ? IMM(0) : IMM(1);
            op->fail = addr + op->size;
            switch (insn->detail->ppc.bc) {
            case PPC_BC_LT:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,!,?{,%s,pc,=,},", ARG(0));
                } else {
                    esilprintf(op, "0x80,%s,&,!,!,?{,%s,pc,=,},", ARG(0), ARG(1));
                }
                break;
            case PPC_BC_LE:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,!,cr0,!,|,?{,%s,pc,=,},", ARG(0));
                } else {
                    esilprintf(op, "0x80,%s,&,!,!,0,%s,!,|,?{,%s,pc,=,},", ARG(0), ARG(0), ARG(1));
                }
                break;
            case PPC_BC_EQ:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "cr0,!,?{,%s,pc,=,},", ARG(0));
                } else {
                    esilprintf(op, "%s,!,?{,%s,pc,=,},", ARG(0), ARG(1));
                }
                break;
            case PPC_BC_GE:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,cr0,!,|,?{,%s,pc,=,},", ARG(0));
                } else {
                    esilprintf(op, "0x80,%s,&,!,%s,!,|,?{,%s,pc,=,},", ARG(0), ARG(0), ARG(1));
                }
                break;
            case PPC_BC_GT:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,?{,%s,pc,=,},", ARG(0));
                } else {
                    esilprintf(op, "0x80,%s,&,!,?{,%s,pc,=,},", ARG(0), ARG(1));
                }
                break;
            case PPC_BC_NE:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "cr0,!,!,?{,%s,pc,=,},", ARG(0));
                } else {
                    esilprintf(op, "%s,!,!,?{,%s,pc,=,},", ARG(0), ARG(1));
                }
                break;
            case PPC_BC_INVALID:
                op->type = RZ_ANALYSIS_OP_TYPE_JMP;
                esilprintf(op, "%s,pc,=", ARG(0));
            case PPC_BC_UN: // unordered
            case PPC_BC_NU: // not unordered
            case PPC_BC_SO: // summary overflow
            case PPC_BC_NS: // not summary overflow
            default:
                break;
            }
            break;
        case PPC_INS_BT:
        case PPC_INS_BF:
            switch (insn->detail->ppc.operands[0].type) {
            case PPC_OP_CRX:
                op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
                op->fail = addr + op->size;
                break;
            case PPC_OP_REG:
                if (op->type == RZ_ANALYSIS_OP_TYPE_CJMP) {
                    op->type = RZ_ANALYSIS_OP_TYPE_UCJMP;
                } else {
                    op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
                }
                op->jump = IMM(1);
                op->fail = addr + op->size;
                // op->type = RZ_ANALYSIS_OP_TYPE_UJMP;
            default:
                break;
            }
            break;
        case PPC_INS_BDNZ:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            esilprintf(op, "1,ctr,-=,$z,!,?{,%s,pc,=,}", ARG(0));
            break;
        case PPC_INS_BDNZA:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            break;
        case PPC_INS_BDNZL:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            break;
        case PPC_INS_BDNZLA:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            break;
        case PPC_INS_BDNZLR:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->fail = addr + op->size;
            esilprintf(op, "1,ctr,-=,$z,!,?{,lr,pc,=,},");
            break;
        case PPC_INS_BDNZLRL:
            op->fail = addr + op->size;
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            break;
        case PPC_INS_BDZ:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            esilprintf(op, "1,ctr,-=,$z,?{,%s,pc,=,}", ARG(0));
            break;
        case PPC_INS_BDZA:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            break;
        case PPC_INS_BDZL:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            break;
        case PPC_INS_BDZLA:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            break;
        case PPC_INS_BDZLR:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->fail = addr + op->size;
            esilprintf(op, "1,ctr,-=,$z,?{,lr,pc,=,}");
            break;
        case PPC_INS_BDZLRL:
            op->type = RZ_ANALYSIS_OP_TYPE_CJMP;
            op->fail = addr + op->size;
            break;
        case PPC_INS_BLR:
        case PPC_INS_BLRL:
        case PPC_INS_BCLR:
        case PPC_INS_BCLRL:
            op->type = RZ_ANALYSIS_OP_TYPE_CRET;
            op->fail = addr + op->size;
            switch (insn->detail->ppc.bc) {
            case PPC_BC_INVALID:
                op->type = RZ_ANALYSIS_OP_TYPE_RET;
                esilprintf(op, "lr,pc,=");
                break;
            case PPC_BC_LT:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,!,?{,lr,pc,=,},");
                } else {
                    esilprintf(op, "0x80,%s,&,!,!,?{,lr,pc,=,},", ARG(0));
                }
                break;
            case PPC_BC_LE:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,!,cr0,!,|,?{,lr,pc,=,},");
                } else {
                    esilprintf(op, "0x80,%s,&,!,!,0,%s,!,|,?{,lr,pc,=,},", ARG(0), ARG(0));
                }
                break;
            case PPC_BC_EQ:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "cr0,!,?{,lr,pc,=,},");
                } else {
                    esilprintf(op, "%s,!,?{,lr,pc,=,},", ARG(0));
                }
                break;
            case PPC_BC_GE:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,cr0,!,|,?{,lr,pc,=,},");
                } else {
                    esilprintf(op, "0x80,%s,&,!,%s,!,|,?{,lr,pc,=,},", ARG(0), ARG(0));
                }
                break;
            case PPC_BC_GT:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "0x80,cr0,&,!,?{,lr,pc,=,},");
                } else {
                    esilprintf(op, "0x80,%s,&,!,?{,lr,pc,=,},", ARG(0));
                }
                break;
            case PPC_BC_NE:
                if (ARG(1)[0] == '\0') {
                    esilprintf(op, "cr0,!,!,?{,lr,pc,=,},");
                } else {
                    esilprintf(op, "%s,!,!,?{,lr,pc,=,},", ARG(0));
                }
                break;
            case PPC_BC_UN: // unordered
            case PPC_BC_NU: // not unordered
            case PPC_BC_SO: // summary overflow
            case PPC_BC_NS: // not summary overflow
            default:
                break;
            }
            break;
        case PPC_INS_NOR:
            op->type = RZ_ANALYSIS_OP_TYPE_NOR;
            esilprintf(op, "%s,%s,|,!,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_XOR:
        case PPC_INS_XORI:
            op->type = RZ_ANALYSIS_OP_TYPE_XOR;
            esilprintf(op, "%s,%s,^,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_XORIS:
            op->type = RZ_ANALYSIS_OP_TYPE_XOR;
            esilprintf(op, "16,%s,<<,%s,^,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_DIVD:
        case PPC_INS_DIVW:
            op->sign = true;
            op->type = RZ_ANALYSIS_OP_TYPE_DIV;
            esilprintf(op, "%s,%s,/,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_DIVDU:
        case PPC_INS_DIVWU:
            op->type = RZ_ANALYSIS_OP_TYPE_DIV;
            esilprintf(op, "%s,%s,/,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_BL:
        case PPC_INS_BLA:
            op->type = RZ_ANALYSIS_OP_TYPE_CALL;
            op->jump = IMM(0);
            op->fail = addr + op->size;
            esilprintf(op, "pc,lr,=,%s,pc,=", ARG(0));
            break;
        case PPC_INS_TRAP:
            op->sign = true;
            op->type = RZ_ANALYSIS_OP_TYPE_TRAP;
            break;
        case PPC_INS_AND:
        case PPC_INS_NAND:
        case PPC_INS_ANDI:
            op->type = RZ_ANALYSIS_OP_TYPE_AND;
            esilprintf(op, "%s,%s,&,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_ANDIS:
            op->type = RZ_ANALYSIS_OP_TYPE_AND;
            esilprintf(op, "16,%s,<<,%s,&,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_OR:
        case PPC_INS_ORI:
            op->type = RZ_ANALYSIS_OP_TYPE_OR;
            esilprintf(op, "%s,%s,|,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_ORIS:
            op->type = RZ_ANALYSIS_OP_TYPE_OR;
            esilprintf(op, "16,%s,<<,%s,|,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_MFPVR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "pvr,%s,=", ARG(0));
            break;
        case PPC_INS_MFSPR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,%s,=", PPCSPR(1), ARG(0));
            break;
        case PPC_INS_MFCTR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "ctr,%s,=", ARG(0));
            break;
        case PPC_INS_MFDCCR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "dccr,%s,=", ARG(0));
            break;
        case PPC_INS_MFICCR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "iccr,%s,=", ARG(0));
            break;
        case PPC_INS_MFDEAR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "dear,%s,=", ARG(0));
            break;
        case PPC_INS_MFMSR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "msr,%s,=", ARG(0));
            break;
        case PPC_INS_MTCTR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,ctr,=", ARG(0));
            break;
        case PPC_INS_MTDCCR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,dccr,=", ARG(0));
            break;
        case PPC_INS_MTICCR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,iccr,=", ARG(0));
            break;
        case PPC_INS_MTDEAR:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,dear,=", ARG(0));
            break;
        case PPC_INS_MTMSR:
        case PPC_INS_MTMSRD:
            op->type = RZ_ANALYSIS_OP_TYPE_MOV;
            esilprintf(op, "%s,msr,=", ARG(0));
            break;
            // Data Cache Block Zero
        case PPC_INS_DCBZ:
            op->type = RZ_ANALYSIS_OP_TYPE_STORE;
            esilprintf(op, "%s,%s", ARG(0), ARG2(1, ",=[128]"));
            break;
        case PPC_INS_CLRLDI:
            op->type = RZ_ANALYSIS_OP_TYPE_AND;
            esilprintf(op, "%s,%s,&,%s,=", ARG(1), cmask64(ARG(2), "0x3F"), ARG(0));
            break;
        case PPC_INS_ROTLDI:
            op->type = RZ_ANALYSIS_OP_TYPE_ROL;
            esilprintf(op, "%s,%s,<<<,%s,=", ARG(2), ARG(1), ARG(0));
            break;
        case PPC_INS_RLDCL:
        case PPC_INS_RLDICL:
            op->type = RZ_ANALYSIS_OP_TYPE_ROL;
            esilprintf(op, "%s,%s,<<<,%s,&,%s,=", ARG(2), ARG(1), cmask64(ARG(3), "0x3F"), ARG(0));
            break;
        case PPC_INS_RLDCR:
        case PPC_INS_RLDICR:
            op->type = RZ_ANALYSIS_OP_TYPE_ROL;
            esilprintf(op, "%s,%s,<<<,%s,&,%s,=", ARG(2), ARG(1), cmask64(0, ARG(3)), ARG(0));
            break;
        }
        if (mask & RZ_ANALYSIS_OP_MASK_VAL) {
            op_fillval(op, handle, insn);
        }
        if (!(mask & RZ_ANALYSIS_OP_MASK_ESIL)) {
            rz_strbuf_fini(&op->esil);
        }
        cs_free(insn, n);
        // cs_close (&handle);
    }
    return op->size;
}

References a, addr, analop_vle(), ARG, ARG2, cmask32(), cmask64(), CS_ARCH_PPC, cs_close(), cs_disasm(), capstone::CS_ERR_OK, cs_free(), CS_MODE_32, CS_MODE_64, CS_MODE_BIG_ENDIAN, CS_MODE_LITTLE_ENDIAN, cs_open(), CS_OPT_DETAIL, CS_OPT_ON, cs_option(), esilprintf, Getarg::handle, handle, IMM, Getarg::insn, len, mask, n, op_fillval(), opex(), PPC_BC_EQ, PPC_BC_GE, PPC_BC_GT, PPC_BC_INVALID, PPC_BC_LE, PPC_BC_LT, PPC_BC_NE, PPC_BC_NS, PPC_BC_NU, PPC_BC_SO, PPC_BC_UN, PPC_INS_ADD, PPC_INS_ADDC, PPC_INS_ADDE, PPC_INS_ADDI, PPC_INS_ADDIC, PPC_INS_ADDIS, PPC_INS_ADDME, PPC_INS_ADDZE, PPC_INS_AND, PPC_INS_ANDI, PPC_INS_ANDIS, PPC_INS_B, PPC_INS_BA, PPC_INS_BC, PPC_INS_BCLR, PPC_INS_BCLRL, PPC_INS_BCTR, PPC_INS_BCTRL, PPC_INS_BDNZ, PPC_INS_BDNZA, PPC_INS_BDNZL, PPC_INS_BDNZLA, PPC_INS_BDNZLR, PPC_INS_BDNZLRL, PPC_INS_BDZ, PPC_INS_BDZA, PPC_INS_BDZL, PPC_INS_BDZLA, PPC_INS_BDZLR, PPC_INS_BDZLRL, PPC_INS_BF, PPC_INS_BL, PPC_INS_BLA, PPC_INS_BLR, PPC_INS_BLRL, PPC_INS_BT, PPC_INS_CLRLDI, PPC_INS_CLRLWI, PPC_INS_CMPB, PPC_INS_CMPD, PPC_INS_CMPDI, PPC_INS_CMPLD, PPC_INS_CMPLDI, PPC_INS_CMPLW, PPC_INS_CMPLWI, PPC_INS_CMPW, PPC_INS_CMPWI, PPC_INS_CRCLR, PPC_INS_CRMOVE, PPC_INS_CRNOR, PPC_INS_CRNOT, PPC_INS_CRSET, PPC_INS_CRXOR, PPC_INS_DCBZ, PPC_INS_DIVD, PPC_INS_DIVDU, PPC_INS_DIVW, PPC_INS_DIVWU, PPC_INS_EIEIO, PPC_INS_EXTSB, PPC_INS_EXTSH, PPC_INS_EXTSW, PPC_INS_ISYNC, PPC_INS_LBZ, PPC_INS_LBZCIX, PPC_INS_LBZU, PPC_INS_LBZUX, PPC_INS_LBZX, PPC_INS_LD, PPC_INS_LDARX, PPC_INS_LDBRX, PPC_INS_LDCIX, PPC_INS_LDU, PPC_INS_LDUX, PPC_INS_LDX, PPC_INS_LFD, PPC_INS_LFDU, PPC_INS_LFDUX, PPC_INS_LFDX, PPC_INS_LFIWAX, PPC_INS_LFIWZX, PPC_INS_LFS, PPC_INS_LFSU, PPC_INS_LFSUX, PPC_INS_LFSX, PPC_INS_LHA, PPC_INS_LHAU, PPC_INS_LHAUX, PPC_INS_LHAX, PPC_INS_LHBRX, PPC_INS_LHZ, PPC_INS_LHZU, PPC_INS_LI, PPC_INS_LIS, PPC_INS_LWA, PPC_INS_LWARX, PPC_INS_LWAUX, PPC_INS_LWAX, PPC_INS_LWBRX, PPC_INS_LWSYNC, PPC_INS_LWZ, PPC_INS_LWZCIX, PPC_INS_LWZU, PPC_INS_LWZUX, PPC_INS_LWZX, PPC_INS_MFCTR, PPC_INS_MFDCCR, PPC_INS_MFDEAR, PPC_INS_MFICCR, PPC_INS_MFLR, PPC_INS_MFMSR, PPC_INS_MFPVR, PPC_INS_MFSPR, PPC_INS_MR, PPC_INS_MSYNC, PPC_INS_MTCTR, PPC_INS_MTDCCR, PPC_INS_MTDEAR, PPC_INS_MTICCR, PPC_INS_MTLR, PPC_INS_MTMSR, PPC_INS_MTMSRD, PPC_INS_MTSPR, PPC_INS_MULLD, PPC_INS_MULLI, PPC_INS_MULLW, PPC_INS_NAND, PPC_INS_NOP, PPC_INS_NOR, PPC_INS_OR, PPC_INS_ORI, PPC_INS_ORIS, PPC_INS_PTESYNC, PPC_INS_RLDCL, PPC_INS_RLDCR, PPC_INS_RLDICL, PPC_INS_RLDICR, PPC_INS_RLWINM, PPC_INS_ROTLDI, PPC_INS_SC, PPC_INS_SLBIA, PPC_INS_SLBIE, PPC_INS_SLBMFEE, PPC_INS_SLBMTE, PPC_INS_SLW, PPC_INS_SLWI, PPC_INS_SRW, PPC_INS_SRWI, PPC_INS_STB, PPC_INS_STBU, PPC_INS_STD, PPC_INS_STDU, PPC_INS_STH, PPC_INS_STHU, PPC_INS_STW, PPC_INS_STWBRX, PPC_INS_STWCX, PPC_INS_STWU, PPC_INS_STWUX, PPC_INS_STWX, PPC_INS_SUB, PPC_INS_SUBC, PPC_INS_SUBF, PPC_INS_SUBFIC, PPC_INS_SUBFZE, PPC_INS_SYNC, PPC_INS_TLBSYNC, PPC_INS_TRAP, PPC_INS_XOR, PPC_INS_XORI, PPC_INS_XORIS, PPC_OP_CRX, PPC_OP_REG, PPCSPR, RZ_ANALYSIS_OP_MASK_DISASM, RZ_ANALYSIS_OP_MASK_ESIL, RZ_ANALYSIS_OP_MASK_OPEX, RZ_ANALYSIS_OP_MASK_VAL, RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_AND, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_CMP, RZ_ANALYSIS_OP_TYPE_CRET, RZ_ANALYSIS_OP_TYPE_DIV, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_MUL, RZ_ANALYSIS_OP_TYPE_NOP, RZ_ANALYSIS_OP_TYPE_NOR, RZ_ANALYSIS_OP_TYPE_OR, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_ROL, RZ_ANALYSIS_OP_TYPE_SHL, RZ_ANALYSIS_OP_TYPE_SHR, RZ_ANALYSIS_OP_TYPE_STORE, RZ_ANALYSIS_OP_TYPE_SUB, RZ_ANALYSIS_OP_TYPE_SWI, RZ_ANALYSIS_OP_TYPE_TRAP, RZ_ANALYSIS_OP_TYPE_UCJMP, RZ_ANALYSIS_OP_TYPE_UJMP, RZ_ANALYSIS_OP_TYPE_XOR, RZ_ANALYSIS_STACK_INC, rz_strbuf_fini(), shrink(), st16, and strdup().

analop_vle()

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

static

Definition at line 417 of file analysis_ppc_cs.c.

                                                                                                                  {
    vle_t *instr = NULL;
    vle_handle handle = { 0 };
    op->size = 2;
    if (len > 1 && !vle_init(&handle, buf, len) && (instr = vle_next(&handle))) {
        op->size = instr->size;
        op->type = instr->analysis_op;
        // op->id = instr->type;
 
        if (mask & RZ_ANALYSIS_OP_MASK_DISASM) {
            op->mnemonic = strdup(instr->name);
        }
        switch (op->type) {
        case RZ_ANALYSIS_OP_TYPE_ILL:
            break;
        case RZ_ANALYSIS_OP_TYPE_ADD:
            break;
        case RZ_ANALYSIS_OP_TYPE_AND:
            break;
        case RZ_ANALYSIS_OP_TYPE_CALL:
            op->jump = addr + instr->fields[instr->n - 1].value;
            op->fail = addr + op->size;
            break;
        case RZ_ANALYSIS_OP_TYPE_CCALL:
            op->eob = true;
            op->jump = addr + instr->fields[instr->n - 1].value;
            op->fail = addr + op->size;
            break;
        case RZ_ANALYSIS_OP_TYPE_CJMP:
            op->cond = instr->cond; // RZ_TYPE_COND_NE;
            op->eob = true;
            op->jump = addr + instr->fields[instr->n - 1].value;
            op->fail = addr + op->size;
            break;
        case RZ_ANALYSIS_OP_TYPE_CMP:
            break;
        case RZ_ANALYSIS_OP_TYPE_JMP:
            op->jump = addr + instr->fields[instr->n - 1].value;
            break;
        case RZ_ANALYSIS_OP_TYPE_LOAD:
            break;
        case RZ_ANALYSIS_OP_TYPE_MOV:
            break;
        case RZ_ANALYSIS_OP_TYPE_MUL:
            break;
        case RZ_ANALYSIS_OP_TYPE_NOT:
            break;
        case RZ_ANALYSIS_OP_TYPE_OR:
            break;
        case RZ_ANALYSIS_OP_TYPE_ROR:
            break;
        case RZ_ANALYSIS_OP_TYPE_ROL:
            break;
        case RZ_ANALYSIS_OP_TYPE_RCALL:
            op->eob = true;
            break;
        case RZ_ANALYSIS_OP_TYPE_RET:
            op->eob = true;
            break;
        case RZ_ANALYSIS_OP_TYPE_RJMP:
            break;
        case RZ_ANALYSIS_OP_TYPE_SHL:
            break;
        case RZ_ANALYSIS_OP_TYPE_SHR:
            break;
        case RZ_ANALYSIS_OP_TYPE_STORE:
            break;
        case RZ_ANALYSIS_OP_TYPE_SUB:
            break;
        case RZ_ANALYSIS_OP_TYPE_SWI:
            break;
        case RZ_ANALYSIS_OP_TYPE_SYNC:
            break;
        case RZ_ANALYSIS_OP_TYPE_TRAP:
            break;
        case RZ_ANALYSIS_OP_TYPE_XOR:
            break;
        default:
            // RZ_LOG_ERROR("Missing an RZ_ANALYSIS_OP_TYPE (%"PFMT64u")\n", op->type);
            break;
        }
        vle_free(instr);
        return op->size;
    }
    return -1;
}

References addr, vle_t::analysis_op, vle_t::cond, vle_t::fields, handle, len, mask, vle_t::n, vle_t::name, NULL, RZ_ANALYSIS_OP_MASK_DISASM, RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_AND, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CCALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_CMP, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_MUL, RZ_ANALYSIS_OP_TYPE_NOT, RZ_ANALYSIS_OP_TYPE_OR, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_RJMP, RZ_ANALYSIS_OP_TYPE_ROL, RZ_ANALYSIS_OP_TYPE_ROR, RZ_ANALYSIS_OP_TYPE_SHL, RZ_ANALYSIS_OP_TYPE_SHR, RZ_ANALYSIS_OP_TYPE_STORE, RZ_ANALYSIS_OP_TYPE_SUB, RZ_ANALYSIS_OP_TYPE_SWI, RZ_ANALYSIS_OP_TYPE_SYNC, RZ_ANALYSIS_OP_TYPE_TRAP, RZ_ANALYSIS_OP_TYPE_XOR, vle_t::size, strdup(), vle_field_t::value, vle_free(), vle_init(), and vle_next().

Referenced by analop().

analysis_preludes()

static RzList* analysis_preludes ( RzAnalysis *  analysis )

static

Definition at line 1310 of file analysis_ppc_cs.c.

                                                       {
#define KW(d, ds, m, ms) rz_list_append(l, rz_search_keyword_new((const ut8 *)d, ds, (const ut8 *)m, ms, NULL))
    RzList *l = rz_list_newf((RzListFree)rz_search_keyword_free);
    KW("\x7c\x08\x02\xa6", 4, NULL, 0);
    return l;
}

References KW, NULL, rz_list_newf(), and rz_search_keyword_free().

archinfo()

static int archinfo ( RzAnalysis *  a, int  q  )

static

Definition at line 1303 of file analysis_ppc_cs.c.

                                          {
    if (a->cpu && !strncmp(a->cpu, "vle", 3)) {
        return 2;
    }
    return 4;
}

References a.

cmask32()

static const char* cmask32 ( const char *  mb_c, const char *  me_c  )

static

Definition at line 57 of file analysis_ppc_cs.c.

                                                               {
    static char cmask[32];
    ut32 mb = 0;
    ut32 me = 0;
    if (mb_c) {
        mb = strtol(mb_c, NULL, 16);
    }
    if (me_c) {
        me = strtol(me_c, NULL, 16);
    }
    snprintf(cmask, sizeof(cmask), "0x%" PFMT32x "", mask32(mb, me));
    return cmask;
}

References mask32(), NULL, PFMT32x, and snprintf.

Referenced by analop().

cmask64()

static const char* cmask64 ( const char *  mb_c, const char *  me_c  )

static

Definition at line 43 of file analysis_ppc_cs.c.

                                                               {
    static char cmask[32];
    ut64 mb = 0;
    ut64 me = 0;
    if (mb_c) {
        mb = strtol(mb_c, NULL, 16);
    }
    if (me_c) {
        me = strtol(me_c, NULL, 16);
    }
    snprintf(cmask, sizeof(cmask), "0x%" PFMT64x "", mask64(mb, me));
    return cmask;
}

References mask64(), NULL, PFMT64x, snprintf, and ut64().

Referenced by analop().

create_src_dst()

static void create_src_dst ( RzAnalysisOp *  op )

static

Definition at line 525 of file analysis_ppc_cs.c.

                                             {
    op->src[0] = rz_analysis_value_new();
    op->src[1] = rz_analysis_value_new();
    op->src[2] = rz_analysis_value_new();
    op->dst = rz_analysis_value_new();
    ZERO_FILL(base_regs[0]);
    ZERO_FILL(base_regs[1]);
    ZERO_FILL(base_regs[2]);
    ZERO_FILL(base_regs[3]);
}

References base_regs, rz_analysis_value_new(), and ZERO_FILL.

Referenced by op_fillval().

get_reg_profile()

static char* get_reg_profile ( RzAnalysis *  analysis )

static

Definition at line 210 of file analysis_ppc_cs.c.

                                                   {
    const char *p = NULL;
    if (analysis->bits == 32) {
        p =
            "=PC    pc\n"
            "=SP    r1\n"
            "=BP    r31\n"
            "=SR    srr1\n" // status register ??
            "=SN    r3\n" // also for ret
            "=A0    r3\n" // also for ret
            "=A1    r4\n"
            "=A2    r5\n"
            "=A3    r6\n"
            "=A4    r7\n"
            "=A5    r8\n"
            "=A6    r6\n"
            "gpr    srr0   .32 0   0\n"
            "gpr    srr1   .32 4   0\n"
            "gpr    r0   .32 8   0\n"
            "gpr    r1   .32 12  0\n"
            "gpr    r2   .32 16  0\n"
            "gpr    r3   .32 20  0\n"
            "gpr    r4   .32 24  0\n"
            "gpr    r5   .32 28  0\n"
            "gpr    r6   .32 32  0\n"
            "gpr    r7   .32 36  0\n"
            "gpr    r8   .32 40  0\n"
            "gpr    r9   .32 44  0\n"
            "gpr    r10 .32 48  0\n"
            "gpr    r11 .32 52  0\n"
            "gpr    r12 .32 56  0\n"
            "gpr    r13 .32 60  0\n"
            "gpr    r14 .32 64  0\n"
            "gpr    r15 .32 68  0\n"
            "gpr    r16 .32 72  0\n"
            "gpr    r17 .32 76  0\n"
            "gpr    r18 .32 80  0\n"
            "gpr    r19 .32 84  0\n"
            "gpr    r20 .32 88  0\n"
            "gpr    r21 .32 92  0\n"
            "gpr    r22 .32 96  0\n"
            "gpr    r23 .32 100 0\n"
            "gpr    r24 .32 104 0\n"
            "gpr    r25 .32 108 0\n"
            "gpr    r26 .32 112 0\n"
            "gpr    r27 .32 116 0\n"
            "gpr    r28 .32 120 0\n"
            "gpr    r29 .32 124 0\n"
            "gpr    r30 .32 128 0\n"
            "gpr    r31 .32 132 0\n"
            "gpr    lr   .32 136 0\n"
            "gpr    ctr .32 140 0\n"
            "gpr    msr .32 144 0\n"
            "gpr    pc   .32 148 0\n"
            "gpr    cr  .64 152 0\n"
            "gpr    cr0 .8  152 0\n"
            "gpr    cr1 .8  153 0\n"
            "gpr    cr2 .8  154 0\n"
            "gpr    cr3 .8  155 0\n"
            "gpr    cr4 .8  156 0\n"
            "gpr    cr5 .8  157 0\n"
            "gpr    cr6 .8  158 0\n"
            "gpr    cr7 .8  159 0\n"
            "gpr    xer .32 160 0\n"
            "gpr    mq   .32 164 0\n"
            "gpr    fpscr  .32 168 0\n"
            "gpr    vrsave .32 172 0\n"
            "gpr    pvr .32 176 0\n"
            "gpr    dccr   .32 180 0\n"
            "gpr    iccr   .32 184 0\n"
            "gpr    dear   .32 188 0\n"
            "gpr    hid0   .32 192 0\n"
            "gpr    hid1   .32 196 0\n"
            "gpr    hid2   .32 200 0\n"
            "gpr    hid3   .32 204 0\n"
            "gpr    hid4   .32 208 0\n"
            "gpr    hid5   .32 212 0\n"
            "gpr    hid6   .32 216 0\n"
            "gpr    ibat0  .64 220 0\n"
            "gpr    ibat1  .64 228 0\n"
            "gpr    ibat2  .64 236 0\n"
            "gpr    ibat3  .64 244 0\n"
            "gpr    ibat0l .32 220 0\n"
            "gpr    ibat1l .32 228 0\n"
            "gpr    ibat2l .32 236 0\n"
            "gpr    ibat3l .32 244 0\n"
            "gpr    ibat0u .32 224 0\n"
            "gpr    ibat1u .32 232 0\n"
            "gpr    ibat2u .32 240 0\n"
            "gpr    ibat3u .32 248 0\n"
            "gpr    dbat0  .64 256 0\n"
            "gpr    dbat1  .64 264 0\n"
            "gpr    dbat2  .64 272 0\n"
            "gpr    dbat3  .64 280 0\n"
            "gpr    dbat0l .32 256 0\n"
            "gpr    dbat1l .32 264 0\n"
            "gpr    dbat2l .32 272 0\n"
            "gpr    dbat3l .32 280 0\n"
            "gpr    dbat0u .32 260 0\n"
            "gpr    dbat1u .32 268 0\n"
            "gpr    dbat2u .32 276 0\n"
            "gpr    dbat3u .32 284 0\n"
            "gpr    mask   .32 288 0\n";
    } else {
        p =
            "=PC    pc\n"
            "=SP    r1\n"
            "=SR    srr1\n" // status register ??
            "=SN    r0\n" // also for ret
            "=A0    r3\n" // also for ret
            "=A1    r4\n"
            "=A2    r5\n"
            "=A3    r6\n"
            "=A4    r7\n"
            "=A5    r8\n"
            "=A6    r6\n"
            "gpr    srr0   .64 0   0\n"
            "gpr    srr1   .64 8   0\n"
            "gpr    r0   .64 16  0\n"
            "gpr    r1   .64 24  0\n"
            "gpr    r2   .64 32  0\n"
            "gpr    r3   .64 40  0\n"
            "gpr    r4   .64 48  0\n"
            "gpr    r5   .64 56  0\n"
            "gpr    r6   .64 64  0\n"
            "gpr    r7   .64 72  0\n"
            "gpr    r8   .64 80  0\n"
            "gpr    r9   .64 88  0\n"
            "gpr    r10 .64 96  0\n"
            "gpr    r11 .64 104 0\n"
            "gpr    r12 .64 112 0\n"
            "gpr    r13 .64 120 0\n"
            "gpr    r14 .64 128 0\n"
            "gpr    r15 .64 136 0\n"
            "gpr    r16 .64 144 0\n"
            "gpr    r17 .64 152 0\n"
            "gpr    r18 .64 160 0\n"
            "gpr    r19 .64 168 0\n"
            "gpr    r20 .64 176 0\n"
            "gpr    r21 .64 184 0\n"
            "gpr    r22 .64 192 0\n"
            "gpr    r23 .64 200 0\n"
            "gpr    r24 .64 208 0\n"
            "gpr    r25 .64 216 0\n"
            "gpr    r26 .64 224 0\n"
            "gpr    r27 .64 232 0\n"
            "gpr    r28 .64 240 0\n"
            "gpr    r29 .64 248 0\n"
            "gpr    r30 .64 256 0\n"
            "gpr    r31 .64 264 0\n"
            "gpr    lr   .64 272 0\n"
            "gpr    ctr .64 280 0\n"
            "gpr    msr .64 288 0\n"
            "gpr    pc   .64 296 0\n"
            "gpr    cr  .64 304 0\n"
            "gpr    cr0 .8  304 0\n"
            "gpr    cr1 .8  305 0\n"
            "gpr    cr2 .8  306 0\n"
            "gpr    cr3 .8  307 0\n"
            "gpr    cr4 .8  308 0\n"
            "gpr    cr5 .8  309 0\n"
            "gpr    cr6 .8  310 0\n"
            "gpr    cr7 .8  311 0\n"
            "gpr    xer .64 312 0\n"
            "gpr    mq   .64 320 0\n"
            "gpr    fpscr  .64 328 0\n"
            "gpr    vrsave .64 336 0\n"
            "gpr    pvr .64 344 0\n"
            "gpr    dccr   .32 352 0\n"
            "gpr    iccr   .32 356 0\n"
            "gpr    dear   .32 360 0\n"
            "gpr    hid0   .64 364 0\n"
            "gpr    hid1   .64 372 0\n"
            "gpr    hid2   .64 380 0\n"
            "gpr    hid3   .64 388 0\n"
            "gpr    hid4   .64 396 0\n"
            "gpr    hid5   .64 404 0\n"
            "gpr    hid6   .64 412 0\n"
            "gpr    ibat0  .64 420 0\n"
            "gpr    ibat1  .64 428 0\n"
            "gpr    ibat2  .64 436 0\n"
            "gpr    ibat3  .64 444 0\n"
            "gpr    ibat0l .32 420 0\n"
            "gpr    ibat1l .32 428 0\n"
            "gpr    ibat2l .32 436 0\n"
            "gpr    ibat3l .32 444 0\n"
            "gpr    ibat0u .32 424 0\n"
            "gpr    ibat1u .32 432 0\n"
            "gpr    ibat2u .32 440 0\n"
            "gpr    ibat3u .32 448 0\n"
            "gpr    dbat0  .64 456 0\n"
            "gpr    dbat1  .64 464 0\n"
            "gpr    dbat2  .64 472 0\n"
            "gpr    dbat3  .64 480 0\n"
            "gpr    dbat0l .32 456 0\n"
            "gpr    dbat1l .32 464 0\n"
            "gpr    dbat2l .32 472 0\n"
            "gpr    dbat3l .32 480 0\n"
            "gpr    dbat0u .32 460 0\n"
            "gpr    dbat1u .32 468 0\n"
            "gpr    dbat2u .32 476 0\n"
            "gpr    dbat3u .32 484 0\n"
            "gpr    mask   .64 488 0\n"; // not a real register used on complex functions
    }
    return strdup(p);
}

References rz_analysis_t::bits, NULL, p, and strdup().

getarg()

static ut64 getarg ( struct Getarg *  gop, int  n  )

static

Definition at line 108 of file analysis_ppc_cs.c.

                                              {
    ut64 value = 0;
    cs_insn *insn = gop->insn;
    cs_ppc_op op;
 
    if (n < 0 || n >= 8) {
        return 0;
    }
 
    op = INSOP(n);
    switch (op.type) {
    case PPC_OP_INVALID:
        break;
    case PPC_OP_REG:
        value = op.reg;
        break;
    case PPC_OP_IMM:
        value = (ut64)op.imm;
        break;
    case PPC_OP_MEM:
        value = op.mem.disp + op.mem.base;
        break;
    case PPC_OP_CRX: // Condition Register field
        value = (ut64)op.imm;
        break;
    }
    return value;
}

References Getarg::insn, INSOP, n, op, PPC_OP_CRX, PPC_OP_IMM, PPC_OP_INVALID, PPC_OP_MEM, PPC_OP_REG, ut64(), and value.

Referenced by getspr().

getarg2()

static char* getarg2 ( struct Getarg *  gop, int  n, const char *  setstr  )

static

Definition at line 71 of file analysis_ppc_cs.c.

                                                                    {
    cs_insn *insn = gop->insn;
    csh handle = gop->handle;
    static char words[8][64];
    cs_ppc_op op;
 
    if (n < 0 || n >= 8) {
        return NULL;
    }
    op = INSOP(n);
    switch (op.type) {
    case PPC_OP_INVALID:
        words[n][0] = '\0';
        // strcpy (words[n], "invalid");
        break;
    case PPC_OP_REG:
        snprintf(words[n], sizeof(words[n]),
            "%s%s", cs_reg_name(handle, op.reg), setstr);
        break;
    case PPC_OP_IMM:
        snprintf(words[n], sizeof(words[n]),
            "0x%" PFMT64x "%s", (ut64)op.imm, setstr);
        break;
    case PPC_OP_MEM:
        snprintf(words[n], sizeof(words[n]),
            "%" PFMT64d ",%s,+,%s",
            (ut64)op.mem.disp,
            cs_reg_name(handle, op.mem.base), setstr);
        break;
    case PPC_OP_CRX: // Condition Register field
        snprintf(words[n], sizeof(words[n]),
            "%" PFMT64d "%s", (ut64)op.imm, setstr);
        break;
    }
    return words[n];
}

References cs_reg_name(), Getarg::handle, handle, Getarg::insn, INSOP, n, NULL, op, PFMT64d, PFMT64x, PPC_OP_CRX, PPC_OP_IMM, PPC_OP_INVALID, PPC_OP_MEM, PPC_OP_REG, snprintf, and ut64().

getspr()

static const char* getspr ( struct Getarg *  gop, int  n  )

static

Definition at line 137 of file analysis_ppc_cs.c.

                                                     {
    static char cspr[16];
    ut32 spr = 0;
    if (n < 0 || n >= 8) {
        return NULL;
    }
    spr = getarg(gop, 0);
    switch (spr) {
    case SPR_HID0:
        return "hid0";
    case SPR_HID1:
        return "hid1";
    case SPR_HID2:
        return "hid2";
    case SPR_HID4:
        return "hid4";
    case SPR_HID5:
        return "hid5";
    case SPR_HID6:
        return "hid6";
    default:
        snprintf(cspr, sizeof(cspr), "spr_%u", spr);
        break;
    }
    return cspr;
}

References getarg(), NULL, snprintf, SPR_HID0, SPR_HID1, SPR_HID2, SPR_HID4, SPR_HID5, and SPR_HID6.

mask32()

static ut32 mask32 ( ut32  mb, ut32  me  )

static

Definition at line 37 of file analysis_ppc_cs.c.

                                     {
    ut32 maskmb = UT32_MAX >> mb;
    ut32 maskme = UT32_MAX << (31 - me);
    return (mb <= me) ? maskmb & maskme : maskmb | maskme;
}

References UT32_MAX.

Referenced by cmask32().

mask64()

static ut64 mask64 ( ut64  mb, ut64  me  )

static

Definition at line 31 of file analysis_ppc_cs.c.

                                     {
    ut64 maskmb = UT64_MAX >> mb;
    ut64 maskme = UT64_MAX << (63 - me);
    return (mb <= me) ? maskmb & maskme : maskmb | maskme;
}

References ut64(), and UT64_MAX.

Referenced by cmask64().

op_fillval()

static void op_fillval ( RzAnalysisOp *  op, csh  handle, cs_insn *  insn  )

static

Definition at line 554 of file analysis_ppc_cs.c.

                                                                    {
    create_src_dst(op);
    switch (op->type & RZ_ANALYSIS_OP_TYPE_MASK) {
    case RZ_ANALYSIS_OP_TYPE_MOV:
    case RZ_ANALYSIS_OP_TYPE_CMP:
    case RZ_ANALYSIS_OP_TYPE_ADD:
    case RZ_ANALYSIS_OP_TYPE_SUB:
    case RZ_ANALYSIS_OP_TYPE_MUL:
    case RZ_ANALYSIS_OP_TYPE_DIV:
    case RZ_ANALYSIS_OP_TYPE_SHR:
    case RZ_ANALYSIS_OP_TYPE_SHL:
    case RZ_ANALYSIS_OP_TYPE_SAL:
    case RZ_ANALYSIS_OP_TYPE_SAR:
    case RZ_ANALYSIS_OP_TYPE_OR:
    case RZ_ANALYSIS_OP_TYPE_AND:
    case RZ_ANALYSIS_OP_TYPE_XOR:
    case RZ_ANALYSIS_OP_TYPE_NOR:
    case RZ_ANALYSIS_OP_TYPE_NOT:
    case RZ_ANALYSIS_OP_TYPE_LOAD:
    case RZ_ANALYSIS_OP_TYPE_LEA:
    case RZ_ANALYSIS_OP_TYPE_ROR:
    case RZ_ANALYSIS_OP_TYPE_ROL:
    case RZ_ANALYSIS_OP_TYPE_CAST:
        set_src_dst(op->src[2], &handle, insn, 3);
        set_src_dst(op->src[1], &handle, insn, 2);
        set_src_dst(op->src[0], &handle, insn, 1);
        set_src_dst(op->dst, &handle, insn, 0);
        break;
    case RZ_ANALYSIS_OP_TYPE_STORE:
        set_src_dst(op->dst, &handle, insn, 1);
        set_src_dst(op->src[0], &handle, insn, 0);
        break;
    }
}

References create_src_dst(), handle, RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_AND, RZ_ANALYSIS_OP_TYPE_CAST, RZ_ANALYSIS_OP_TYPE_CMP, RZ_ANALYSIS_OP_TYPE_DIV, RZ_ANALYSIS_OP_TYPE_LEA, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MASK, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_MUL, RZ_ANALYSIS_OP_TYPE_NOR, RZ_ANALYSIS_OP_TYPE_NOT, RZ_ANALYSIS_OP_TYPE_OR, RZ_ANALYSIS_OP_TYPE_ROL, RZ_ANALYSIS_OP_TYPE_ROR, RZ_ANALYSIS_OP_TYPE_SAL, RZ_ANALYSIS_OP_TYPE_SAR, RZ_ANALYSIS_OP_TYPE_SHL, RZ_ANALYSIS_OP_TYPE_SHR, RZ_ANALYSIS_OP_TYPE_STORE, RZ_ANALYSIS_OP_TYPE_SUB, RZ_ANALYSIS_OP_TYPE_XOR, and set_src_dst().

Referenced by analop().

opex()

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

static

Definition at line 164 of file analysis_ppc_cs.c.

                                                           {
    int i;
    PJ *pj = pj_new();
    if (!pj) {
        return;
    }
    pj_o(pj);
    pj_ka(pj, "operands");
    cs_ppc *x = &insn->detail->ppc;
    for (i = 0; i < x->op_count; i++) {
        cs_ppc_op *op = x->operands + i;
        pj_o(pj);
        switch (op->type) {
        case PPC_OP_REG:
            pj_ks(pj, "type", "reg");
            pj_ks(pj, "value", cs_reg_name(handle, op->reg));
            break;
        case PPC_OP_IMM:
            pj_ks(pj, "type", "imm");
            pj_kN(pj, "value", op->imm);
            break;
        case PPC_OP_MEM:
            pj_ks(pj, "type", "mem");
            if (op->mem.base != PPC_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_kN(), pj_ks(), pj_new(), pj_o(), pj_string(), PPC_OP_IMM, PPC_OP_MEM, PPC_OP_REG, PPC_REG_INVALID, rz_strbuf_append(), rz_strbuf_init(), and x.

Referenced by analop().

parse_reg_name()

static int parse_reg_name ( RzRegItem *  reg, csh  handle, cs_insn *  insn, int  reg_num  )

static

Definition at line 504 of file analysis_ppc_cs.c.

                                                                                  {
    if (!reg) {
        return -1;
    }
    switch (INSOP(reg_num).type) {
    case PPC_OP_REG:
        reg->name = (char *)cs_reg_name(handle, INSOP(reg_num).reg);
        break;
    case PPC_OP_MEM:
        if (INSOP(reg_num).mem.base != PPC_REG_INVALID) {
            reg->name = (char *)cs_reg_name(handle, INSOP(reg_num).mem.base);
        }
        break;
    default:
        break;
    }
    return 0;
}

References cs_reg_name(), handle, INSOP, PPC_OP_MEM, PPC_OP_REG, PPC_REG_INVALID, reg, and type.

Referenced by set_src_dst().

set_src_dst()

static void set_src_dst ( RzAnalysisValue *  val, csh *  handle, cs_insn *  insn, int  x  )

static

Definition at line 536 of file analysis_ppc_cs.c.

                                                                                 {
    cs_ppc_op ppcop = INSOP(x);
    parse_reg_name(&base_regs[x], *handle, insn, x);
    switch (ppcop.type) {
    case PPC_OP_REG:
        break;
    case PPC_OP_MEM:
        val->delta = ppcop.mem.disp;
        break;
    case PPC_OP_IMM:
        val->imm = ppcop.imm;
        break;
    default:
        break;
    }
    val->reg = &base_regs[x];
}

References base_regs, ppc_op_mem::disp, handle, cs_ppc_op::imm, INSOP, cs_ppc_op::mem, parse_reg_name(), PPC_OP_IMM, PPC_OP_MEM, PPC_OP_REG, cs_ppc_op::type, val, and x.

Referenced by op_fillval().

shrink()

static char* shrink ( char *  op )

static

Definition at line 589 of file analysis_ppc_cs.c.

                              {
    if (!op) {
        return NULL;
    }
    size_t len = strlen(op);
    if (!len) {
        return NULL;
    }
    op[len - 1] = 0;
    return op;
}

References len, NULL, and op.

Referenced by analop().

Variable Documentation

base_regs

RzRegItem base_regs[4]

static

Definition at line 523 of file analysis_ppc_cs.c.

Referenced by create_src_dst(), and set_src_dst().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 1331 of file analysis_ppc_cs.c.

rz_analysis_plugin_ppc_cs

RzAnalysisPlugin rz_analysis_plugin_ppc_cs

Initial value:

= {
    .name = "ppc",
    .desc = "Capstone PowerPC analysis",
    .license = "BSD",
    .esil = true,
    .arch = "ppc",
    .bits = 32 | 64,
    .archinfo = archinfo,
    .preludes = analysis_preludes,
    .op = &analop,
    .get_reg_profile = &get_reg_profile,
}

Definition at line 1317 of file analysis_ppc_cs.c.