asm_x86_cs.c File Reference

#include <rz_asm.h>
#include <rz_lib.h>
#include <capstone/capstone.h>
#include "cs_mnemonics.c"
#include "asm_x86_vm.c"

Go to the source code of this file.

Functions
static bool	the_end (void *p)
static int	check_features (RzAsm *a, cs_insn *insn)
static int	disassemble (RzAsm *a, RzAsmOp *op, const ut8 *buf, int len)

Variables
static csh	cd = 0
static int	n = 0
RzAsmPlugin	rz_asm_plugin_x86_cs
RZ_API RzLibStruct	rizin_plugin

Function Documentation

check_features()

static int check_features ( RzAsm *  a, cs_insn *  insn  )

static

Definition at line 126 of file asm_x86_cs.c.

                                                   {
    const char *name;
    int i;
    if (!insn || !insn->detail) {
        return 1;
    }
    for (i = 0; i < insn->detail->groups_count; i++) {
        int id = insn->detail->groups[i];
        if (id < 128) {
            continue;
        }
        if (id == X86_GRP_MODE32) {
            continue;
        }
        if (id == X86_GRP_MODE64) {
            continue;
        }
        name = cs_group_name(cd, id);
        if (!name) {
            return 1;
        }
        if (!strstr(a->features, name)) {
            return 0;
        }
    }
    return 1;
}

References a, cd, cs_group_name(), i, name, X86_GRP_MODE32, and X86_GRP_MODE64.

Referenced by disassemble().

disassemble()

static int disassemble ( RzAsm *  a, RzAsmOp *  op, const ut8 *  buf, int  len  )

static

Definition at line 25 of file asm_x86_cs.c.

                                                                       {
    static int omode = 0;
    int mode, ret;
    ut64 off = a->pc;
 
    mode = (a->bits == 64) ? CS_MODE_64 : (a->bits == 32) ? CS_MODE_32
        : (a->bits == 16)                             ? CS_MODE_16
                                  : 0;
    if (cd && mode != omode) {
        cs_close(&cd);
        cd = 0;
    }
    if (op) {
        op->size = 0;
    }
    omode = mode;
    if (cd == 0) {
        ret = cs_open(CS_ARCH_X86, mode, &cd);
        if (ret) {
            return 0;
        }
    }
    if (a->features && *a->features) {
        cs_option(cd, CS_OPT_DETAIL, CS_OPT_ON);
    } else {
        cs_option(cd, CS_OPT_DETAIL, CS_OPT_OFF);
    }
    // always unsigned immediates (kernel addresses)
    // maybe rizin should have an option for this too?
#if CS_API_MAJOR >= 4
    cs_option(cd, CS_OPT_UNSIGNED, CS_OPT_ON);
#endif
    if (a->syntax == RZ_ASM_SYNTAX_MASM) {
#if CS_API_MAJOR >= 4
        cs_option(cd, CS_OPT_SYNTAX, CS_OPT_SYNTAX_MASM);
#endif
    } else if (a->syntax == RZ_ASM_SYNTAX_ATT) {
        cs_option(cd, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT);
    } else {
        cs_option(cd, CS_OPT_SYNTAX, CS_OPT_SYNTAX_INTEL);
    }
    if (!op) {
        return true;
    }
    op->size = 1;
    cs_insn *insn = NULL;
    n = cs_disasm(cd, (const ut8 *)buf, len, off, 1, &insn);
    if (op) {
        op->size = 0;
    }
    if (a->features && *a->features) {
        if (!check_features(a, insn)) {
            op->size = insn->size;
            rz_asm_op_set_asm(op, "illegal");
        }
    }
    if (op->size == 0 && n > 0 && insn->size > 0) {
        char *ptrstr;
        op->size = insn->size;
        char *buf_asm = sdb_fmt("%s%s%s",
            insn->mnemonic, insn->op_str[0] ? " " : "",
            insn->op_str);
        ptrstr = strstr(buf_asm, "ptr ");
        if (ptrstr) {
            memmove(ptrstr, ptrstr + 4, strlen(ptrstr + 4) + 1);
        }
        rz_asm_op_set_asm(op, buf_asm);
    } else {
        decompile_vm(a, op, buf, len);
    }
    if (a->syntax == RZ_ASM_SYNTAX_JZ) {
        char *buf_asm = rz_strbuf_get(&op->buf_asm);
        if (!strncmp(buf_asm, "je ", 3)) {
            memcpy(buf_asm, "jz", 2);
        } else if (!strncmp(buf_asm, "jne ", 4)) {
            memcpy(buf_asm, "jnz", 3);
        }
    }
    if (insn) {
        cs_free(insn, n);
    }
    return op->size;
}

References a, cd, check_features(), CS_ARCH_X86, cs_close(), cs_disasm(), cs_free(), CS_MODE_16, CS_MODE_32, CS_MODE_64, cs_open(), CS_OPT_DETAIL, CS_OPT_OFF, CS_OPT_ON, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT, CS_OPT_SYNTAX_INTEL, CS_OPT_SYNTAX_MASM, CS_OPT_UNSIGNED, cs_option(), decompile_vm(), len, memcpy(), n, NULL, off, rz_asm_op_set_asm(), RZ_ASM_SYNTAX_ATT, RZ_ASM_SYNTAX_JZ, RZ_ASM_SYNTAX_MASM, rz_strbuf_get(), sdb_fmt(), and ut64().

the_end()

static bool the_end ( void *  p )

static

Definition at line 11 of file asm_x86_cs.c.

                             {
    if (cd) {
        cs_close(&cd);
        cd = 0;
    }
    return true;
}

References cd, and cs_close().

Variable Documentation

cd

csh cd = 0

static

Definition at line 8 of file asm_x86_cs.c.

Referenced by check_features(), disassemble(), and the_end().

n

int n = 0

static

Definition at line 9 of file asm_x86_cs.c.

Referenced by disassemble().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_ASM,
    .data = &rz_asm_plugin_x86_cs,
    .version = RZ_VERSION
}

Definition at line 155 of file asm_x86_cs.c.

rz_asm_plugin_x86_cs

RzAsmPlugin rz_asm_plugin_x86_cs

Initial value:

= {
    .name = "x86",
    .desc = "Capstone X86 disassembler",
    .license = "BSD",
    .cpus = "generic",
    .platforms = "generic",
    .arch = "x86",
    .bits = 16 | 32 | 64,
    .endian = RZ_SYS_ENDIAN_LITTLE,
    .fini = the_end,
    .mnemonics = mnemonics,
    .disassemble = &disassemble,
    .features = "vm,3dnow,aes,adx,avx,avx2,avx512,bmi,bmi2,cmov,"
            "f16c,fma,fma4,fsgsbase,hle,mmx,rtm,sha,sse1,sse2,"
            "sse3,sse41,sse42,sse4a,ssse3,pclmul,xop"
}

Definition at line 109 of file asm_x86_cs.c.