op.c File Reference

#include <rz_analysis.h>
#include <rz_util.h>
#include <rz_list.h>

Go to the source code of this file.

Classes
struct	optype

Functions
RZ_API RzAnalysisOp *	rz_analysis_op_new (void)
RZ_API RzList *	rz_analysis_op_list_new (void)
RZ_API void	rz_analysis_op_init (RzAnalysisOp *op)
RZ_API bool	rz_analysis_op_fini (RzAnalysisOp *op)
RZ_API void	rz_analysis_op_free (void *op)
static int	defaultCycles (RzAnalysisOp *op)
RZ_API int	rz_analysis_op (RzAnalysis *analysis, RzAnalysisOp *op, ut64 addr, const ut8 *data, int len, RzAnalysisOpMask mask)
RZ_API RzAnalysisOp *	rz_analysis_op_copy (RzAnalysisOp *op)
RZ_API bool	rz_analysis_op_nonlinear (int t)
RZ_API bool	rz_analysis_op_ismemref (int t)
RZ_API int	rz_analysis_optype_from_string (RZ_NONNULL const char *name)
RZ_API const char *	rz_analysis_optype_to_string (int type)
RZ_API const char *	rz_analysis_op_to_esil_string (RzAnalysis *analysis, RzAnalysisOp *op)
RZ_API char *	rz_analysis_op_to_string (RzAnalysis *analysis, RzAnalysisOp *op)
RZ_API const char *	rz_analysis_stackop_tostring (int s)
RZ_API const char *	rz_analysis_op_family_to_string (int id)
RZ_API int	rz_analysis_op_family_from_string (RZ_NONNULL const char *name)
RZ_API int	rz_analysis_op_hint (RzAnalysisOp *op, RzAnalysisHint *hint)
RZ_API int	rz_analysis_op_reg_delta (RzAnalysis *analysis, ut64 addr, const char *name)

Variables
static struct optype	optypes []
struct {
int   id
const char *   name
}	op_families []

Function Documentation

defaultCycles()

static int defaultCycles ( RzAnalysisOp *  op )

static

Definition at line 70 of file op.c.

                                           {
    switch (op->type) {
    case RZ_ANALYSIS_OP_TYPE_PUSH:
    case RZ_ANALYSIS_OP_TYPE_POP:
    case RZ_ANALYSIS_OP_TYPE_STORE:
    case RZ_ANALYSIS_OP_TYPE_LOAD:
        return 2;
    case RZ_ANALYSIS_OP_TYPE_LEA:
    case RZ_ANALYSIS_OP_TYPE_MOV:
    case RZ_ANALYSIS_OP_TYPE_NOP:
        return 1;
    case RZ_ANALYSIS_OP_TYPE_TRAP:
    case RZ_ANALYSIS_OP_TYPE_SWI:
        return 4;
    case RZ_ANALYSIS_OP_TYPE_SYNC:
        return 4;
    case RZ_ANALYSIS_OP_TYPE_RET:
    case RZ_ANALYSIS_OP_TYPE_JMP:
    case RZ_ANALYSIS_OP_TYPE_RJMP:
    case RZ_ANALYSIS_OP_TYPE_CALL:
        return 4;
    default:
        return 1;
    }
}

References RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_LEA, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_NOP, RZ_ANALYSIS_OP_TYPE_POP, RZ_ANALYSIS_OP_TYPE_PUSH, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_RJMP, RZ_ANALYSIS_OP_TYPE_STORE, RZ_ANALYSIS_OP_TYPE_SWI, RZ_ANALYSIS_OP_TYPE_SYNC, and RZ_ANALYSIS_OP_TYPE_TRAP.

Referenced by rz_analysis_op().

rz_analysis_op()

RZ_API int rz_analysis_op	(	RzAnalysis *	analysis,
		RzAnalysisOp *	op,
		ut64	addr,
		const ut8 *	data,
		int	len,
		RzAnalysisOpMask	mask
	)

Definition at line 96 of file op.c.

                                                                                                                              {
    rz_analysis_op_init(op);
    rz_return_val_if_fail(analysis && op && len > 0, -1);
 
    int ret = RZ_MIN(2, len);
    if (len > 0 && analysis->cur && analysis->cur->op) {
        // use core binding to set asm.bits correctly based on the addr
        // this is because of the hassle of arm/thumb
        if (analysis && analysis->coreb.archbits) {
            analysis->coreb.archbits(analysis->coreb.core, addr);
        }
        if (analysis->pcalign && addr % analysis->pcalign) {
            op->type = RZ_ANALYSIS_OP_TYPE_ILL;
            op->addr = addr;
            // RZ_LOG_DEBUG("Unaligned instruction for %d bits at 0x%"PFMT64x"\n", analysis->bits, addr);
            op->size = 1;
            return -1;
        }
        ret = analysis->cur->op(analysis, op, addr, data, len, mask);
        if (ret < 1) {
            op->type = RZ_ANALYSIS_OP_TYPE_ILL;
        }
        op->addr = addr;
        /* consider at least 1 byte to be part of the opcode */
        if (op->nopcode < 1) {
            op->nopcode = 1;
        }
    } else if (!memcmp(data, "\xff\xff\xff\xff", RZ_MIN(4, len))) {
        op->type = RZ_ANALYSIS_OP_TYPE_ILL;
    } else {
        op->type = RZ_ANALYSIS_OP_TYPE_MOV;
        if (op->cycles == 0) {
            op->cycles = defaultCycles(op);
        }
    }
    if (!op->mnemonic && (mask & RZ_ANALYSIS_OP_MASK_DISASM)) {
        RZ_LOG_DEBUG("Warning: unhandled RZ_ANALYSIS_OP_MASK_DISASM in rz_analysis_op\n");
    }
    if (mask & RZ_ANALYSIS_OP_MASK_HINT) {
        RzAnalysisHint *hint = rz_analysis_hint_get(analysis, addr);
        if (hint) {
            rz_analysis_op_hint(op, hint);
            rz_analysis_hint_free(hint);
        }
    }
    return ret;
}

References addr, rz_core_bind_t::archbits, rz_core_bind_t::core, rz_analysis_t::coreb, rz_analysis_t::cur, defaultCycles(), len, mask, rz_analysis_plugin_t::op, rz_analysis_t::pcalign, rz_analysis_hint_free(), rz_analysis_hint_get(), rz_analysis_op_hint(), rz_analysis_op_init(), RZ_ANALYSIS_OP_MASK_DISASM, RZ_ANALYSIS_OP_MASK_HINT, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_MOV, RZ_LOG_DEBUG, RZ_MIN, and rz_return_val_if_fail.

Referenced by __analysis_esil_function(), __analysis_fcn_check_bp_use(), __core_cmd_search_asm_infinite(), __esil_step(), _analysis_calls(), bbget(), cmd_aea(), cmd_analysis_esil(), cmd_debug_backtrace(), cmd_print_pxA(), construct_rop_gadget(), core_analysis_bytes_desc(), core_analysis_bytes_esil(), core_analysis_bytes_size(), decode_auipc_set_addr(), decode_disp_set_addr(), decode_ldr_set_addr(), decode_lui_set_addr(), decode_one_opcode_size(), decode_ptr_set_addr(), decode_val_add_addr(), decode_val_set_addr(), decode_val_set_size(), do_analysis_search(), do_debug_trace_calls(), do_syscall_search(), ds_show_refs(), get_calls(), getpcfromstack(), is_delta_pointer_table(), iscallret(), noreturn_recurse(), num_callback(), opiscall(), prevop_addr(), print_cmd_analysis_after_traps_print(), print_rop(), process_reference_noreturn_cb(), rasm_disasm(), run_basic_block_analysis(), rz_analysis_block_analyze_ops(), rz_analysis_check_fcn(), rz_analysis_diff_fingerprint_bb(), rz_analysis_function_cost(), rz_analysis_get_delta_jmptbl_info(), rz_analysis_get_jmptbl_info(), rz_analysis_il_vm_step(), rz_analysis_mask(), rz_analysis_op_hexstr(), rz_analysis_op_reg_delta(), rz_analysis_reflines_get(), rz_analysis_xrefs_from_list_handler(), rz_cmd_debug_step_prog_handler(), rz_cmd_disassemble_recursively_no_function_handler(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_all_possible_opcodes_treeview_handler(), rz_core_analysis_bytes(), rz_core_analysis_esil(), rz_core_analysis_esil_emulate(), rz_core_analysis_hint_set_offset(), rz_core_analysis_name(), rz_core_analysis_op(), rz_core_analysis_rename(), rz_core_analysis_search(), rz_core_analysis_search_xrefs(), rz_core_asm_strsearch(), rz_core_debug_step_skip(), rz_core_disasm_instruction(), rz_core_disasm_pde(), rz_core_disasm_pdi_with_buf(), rz_core_esil_of_assembly(), rz_core_esil_of_hex(), rz_core_esil_step(), rz_core_hack(), rz_core_link_stroff(), rz_core_op_analysis(), rz_core_print_disasm(), rz_core_print_disasm_all(), rz_core_print_disasm_instructions_with_buf(), rz_core_search_rop(), rz_core_seek_next(), rz_core_seek_opcode_forward(), rz_core_visual_bit_editor(), rz_core_visual_define(), rz_core_visual_esil(), rz_core_write_assembly_fill(), rz_debug_continue_kill(), rz_debug_continue_until_optype(), rz_debug_esil_stepi(), rz_debug_step_over(), rz_debug_step_soft(), rz_debug_trace_ins_before(), rz_debug_trace_pc(), show_analinfo(), step_until_optype(), update_varz_analysisysis(), and vtable_is_addr_vtable_start_msvc().

rz_analysis_op_copy()

RZ_API RzAnalysisOp* rz_analysis_op_copy

(

RzAnalysisOp *

op

)

Definition at line 144 of file op.c.

                                                           {
    RzAnalysisOp *nop = RZ_NEW0(RzAnalysisOp);
    if (!nop) {
        return NULL;
    }
    *nop = *op;
    if (op->mnemonic) {
        nop->mnemonic = strdup(op->mnemonic);
        if (!nop->mnemonic) {
            free(nop);
            return NULL;
        }
    } else {
        nop->mnemonic = NULL;
    }
    nop->src[0] = rz_analysis_value_copy(op->src[0]);
    nop->src[1] = rz_analysis_value_copy(op->src[1]);
    nop->src[2] = rz_analysis_value_copy(op->src[2]);
    nop->dst = rz_analysis_value_copy(op->dst);
    if (op->access) {
        RzListIter *it;
        RzAnalysisValue *val;
        RzList *naccess = rz_list_newf((RzListFree)rz_analysis_value_free);
        rz_list_foreach (op->access, it, val) {
            rz_list_append(naccess, rz_analysis_value_copy(val));
        }
        nop->access = naccess;
    }
    rz_strbuf_init(&nop->esil);
    rz_strbuf_copy(&nop->esil, &op->esil);
    return nop;
}

References rz_analysis_op_t::access, rz_analysis_op_t::dst, rz_analysis_op_t::esil, free(), rz_analysis_op_t::mnemonic, NULL, op, rz_analysis_value_copy(), rz_analysis_value_free(), rz_list_append(), rz_list_newf(), RZ_NEW0, rz_strbuf_copy(), rz_strbuf_init(), rz_analysis_op_t::src, strdup(), and val.

rz_analysis_op_family_from_string()

RZ_API int rz_analysis_op_family_from_string

(

RZ_NONNULL const char *

name

)

Return the op family id given its name

Parameters

name	string, name of the op family

Returns

id int, id of the operation family (one of RzAnalysisOpFamily)

Definition at line 576 of file op.c.

                                                                          {
    int i;
    rz_return_val_if_fail(name, RZ_ANALYSIS_OP_FAMILY_UNKNOWN);
    for (i = 0; i < RZ_ARRAY_SIZE(op_families); i++) {
        if (!strcmp(name, op_families[i].name)) {
            return op_families[i].id;
        }
    }
    return RZ_ANALYSIS_OP_FAMILY_UNKNOWN;
}

References i, op_families, RZ_ANALYSIS_OP_FAMILY_UNKNOWN, RZ_ARRAY_SIZE, and rz_return_val_if_fail.

rz_analysis_op_family_to_string()

RZ_API const char* rz_analysis_op_family_to_string

(

int

id

)

Return the name of the given op family

Parameters

id	int, id of the operation family (one of RzAnalysisOpFamily)

Returns

name string, name of the op family

Definition at line 560 of file op.c.

                                                           {
    int i;
 
    for (i = 0; i < RZ_ARRAY_SIZE(op_families); i++) {
        if (op_families[i].id == id) {
            return op_families[i].name;
        }
    }
    return NULL;
}

References i, NULL, op_families, and RZ_ARRAY_SIZE.

Referenced by core_analysis_bytes_json(), core_analysis_bytes_standard(), do_analysis_search(), ds_print_family(), rz_core_print_disasm_json(), and update_stat_for_op().

rz_analysis_op_fini()

RZ_API bool rz_analysis_op_fini

(

RzAnalysisOp *

op

)

Definition at line 37 of file op.c.

                                                  {
    if (!op) {
        return false;
    }
    rz_analysis_value_free(op->src[0]);
    rz_analysis_value_free(op->src[1]);
    rz_analysis_value_free(op->src[2]);
    op->src[0] = NULL;
    op->src[1] = NULL;
    op->src[2] = NULL;
    rz_analysis_value_free(op->dst);
    op->dst = NULL;
    rz_list_free(op->access);
    op->access = NULL;
    rz_strbuf_fini(&op->opex);
    rz_strbuf_fini(&op->esil);
    rz_analysis_switch_op_free(op->switch_op);
    op->switch_op = NULL;
    RZ_FREE(op->mnemonic);
    rz_il_op_effect_free(op->il_op);
    op->il_op = NULL;
    return true;
}

References NULL, rz_analysis_switch_op_free(), rz_analysis_value_free(), RZ_FREE, rz_il_op_effect_free(), rz_list_free(), and rz_strbuf_fini().

Referenced by __analysis_esil_function(), __analysis_fcn_check_bp_use(), __core_cmd_search_asm_infinite(), __esil_step(), _analysis_calls(), bbget(), cmd_aea(), cmd_analysis_esil(), cmd_print_pxA(), construct_rop_gadget(), core_analysis_bytes_desc(), core_analysis_bytes_esil(), core_analysis_bytes_size(), decode_auipc_set_addr(), decode_disp_set_addr(), decode_ldr_set_addr(), decode_lui_set_addr(), decode_one_opcode_size(), decode_ptr_set_addr(), decode_val_add_addr(), decode_val_set_addr(), decode_val_set_size(), do_syscall_search(), ds_free(), get_calls(), getpcfromstack(), is_delta_pointer_table(), num_callback(), prevop_addr(), print_cmd_analysis_after_traps_print(), print_rop(), process_reference_noreturn_cb(), rasm_disasm(), run_basic_block_analysis(), rz_analysis_block_analyze_ops(), rz_analysis_check_fcn(), rz_analysis_function_cost(), rz_analysis_get_delta_jmptbl_info(), rz_analysis_get_jmptbl_info(), rz_analysis_il_vm_step(), rz_analysis_mask(), rz_analysis_op_free(), rz_analysis_op_reg_delta(), rz_analysis_reflines_get(), rz_cmd_disassemble_recursively_no_function_handler(), rz_core_analysis_esil(), rz_core_analysis_esil_emulate(), rz_core_analysis_hint_set_offset(), rz_core_analysis_name(), rz_core_analysis_rename(), rz_core_analysis_search(), rz_core_analysis_search_xrefs(), rz_core_asm_strsearch(), rz_core_disasm_instruction(), rz_core_disasm_pde(), rz_core_disasm_pdi_with_buf(), rz_core_esil_of_assembly(), rz_core_esil_of_hex(), rz_core_esil_step(), rz_core_link_stroff(), rz_core_print_disasm(), rz_core_print_disasm_instructions_with_buf(), rz_core_print_func_args(), rz_core_search_rop(), rz_core_seek_opcode_forward(), rz_core_visual_bit_editor(), rz_core_visual_define(), rz_core_visual_esil(), rz_debug_trace_pc(), show_analinfo(), update_varz_analysisysis(), and vtable_is_addr_vtable_start_msvc().

rz_analysis_op_free()

RZ_API void rz_analysis_op_free

(

void *

op

)

Definition at line 61 of file op.c.

                                          {
    if (!op) {
        return;
    }
    rz_analysis_op_fini(op);
    memset(op, 0, sizeof(RzAnalysisOp));
    free(op);
}

References free(), memset(), and rz_analysis_op_fini().

Referenced by __cursor_down(), analBars(), analPaths(), analysis_block_cb(), analysis_function_vars_getsetref(), analysis_mask(), analysis_mask_avr(), analyze_noreturn_function(), disasm_until_ret(), disassemble_till_return_is_found(), disassembly_as_table(), ds_pre_emulation(), free_op_cache_kv(), get_src_regname(), handle_stack_canary(), is_repeatable_inst(), nextOpcode(), op_cache_get(), propagate_types_among_used_variables(), rz_analysis_bytes_free(), rz_analysis_mask(), rz_analysis_op_list_new(), rz_cmd_debug_trace_add_handler(), rz_cmd_debug_traces_esil_i_handler(), rz_cmd_print(), rz_core_analysis_continue_until_call(), rz_core_analysis_continue_until_syscall(), rz_core_analysis_cycles(), rz_core_analysis_esil_fcn(), rz_core_analysis_esil_step_over(), rz_core_analysis_op(), rz_core_analysis_propagate_noreturn(), rz_core_analysis_var_rename(), rz_core_get_stacksz(), rz_core_visual_cmd(), rz_core_visual_define(), rz_debug_free(), rz_debug_trace_ins_after(), rz_debug_trace_ins_before(), and update_stat_for_op().

rz_analysis_op_hint()

RZ_API int rz_analysis_op_hint	(	RzAnalysisOp *	op,
		RzAnalysisHint *	hint
	)

Definition at line 588 of file op.c.

                                                                       {
    int changes = 0;
    if (hint) {
        if (hint->val != UT64_MAX) {
            op->val = hint->val;
            changes++;
        }
        if (hint->type > 0) {
            op->type = hint->type;
            changes++;
        }
        if (hint->jump != UT64_MAX) {
            op->jump = hint->jump;
            changes++;
        }
        if (hint->fail != UT64_MAX) {
            op->fail = hint->fail;
            changes++;
        }
        if (hint->opcode) {
            /* XXX: this is not correct */
            free(op->mnemonic);
            op->mnemonic = strdup(hint->opcode);
            changes++;
        }
        if (hint->esil) {
            rz_strbuf_set(&op->esil, hint->esil);
            changes++;
        }
        if (hint->size) {
            op->size = hint->size;
            changes++;
        }
    }
    return changes;
}

References rz_analysis_hint_t::esil, rz_analysis_hint_t::fail, free(), rz_analysis_hint_t::jump, rz_analysis_hint_t::opcode, rz_strbuf_set(), rz_analysis_hint_t::size, strdup(), rz_analysis_hint_t::type, UT64_MAX, and rz_analysis_hint_t::val.

Referenced by rz_analysis_op().

rz_analysis_op_init()

RZ_API void rz_analysis_op_init

(

RzAnalysisOp *

op

)

Definition at line 23 of file op.c.

                                                  {
    if (op) {
        memset(op, 0, sizeof(*op));
        op->addr = UT64_MAX;
        op->jump = UT64_MAX;
        op->fail = UT64_MAX;
        op->ptr = UT64_MAX;
        op->refptr = 0;
        op->val = UT64_MAX;
        op->disp = UT64_MAX;
        op->mmio_address = UT64_MAX;
    }
}

References memset(), and UT64_MAX.

Referenced by decode_auipc_set_addr(), decode_disp_set_addr(), decode_ldr_set_addr(), decode_lui_set_addr(), decode_one_opcode_size(), decode_ptr_set_addr(), decode_val_add_addr(), decode_val_set_addr(), decode_val_set_size(), rz_analysis_mask(), rz_analysis_op(), rz_analysis_op_new(), rz_analysis_op_reg_delta(), and rz_cmd_disassemble_recursively_no_function_handler().

rz_analysis_op_ismemref()

RZ_API bool rz_analysis_op_ismemref

(

int

t

)

Definition at line 208 of file op.c.

                                           {
    t &= RZ_ANALYSIS_OP_TYPE_MASK;
    switch (t) {
    case RZ_ANALYSIS_OP_TYPE_LOAD:
    case RZ_ANALYSIS_OP_TYPE_MOV:
    case RZ_ANALYSIS_OP_TYPE_STORE:
    case RZ_ANALYSIS_OP_TYPE_LEA:
    case RZ_ANALYSIS_OP_TYPE_CMP:
        return true;
    default:
        return false;
    }
}

References RZ_ANALYSIS_OP_TYPE_CMP, RZ_ANALYSIS_OP_TYPE_LEA, RZ_ANALYSIS_OP_TYPE_LOAD, RZ_ANALYSIS_OP_TYPE_MASK, RZ_ANALYSIS_OP_TYPE_MOV, and RZ_ANALYSIS_OP_TYPE_STORE.

Referenced by set_offset_hint().

rz_analysis_op_list_new()

RZ_API RzList* rz_analysis_op_list_new

(

void

)

Definition at line 15 of file op.c.

                                               {
    RzList *list = rz_list_new();
    if (list) {
        list->free = &rz_analysis_op_free;
    }
    return list;
}

References list(), rz_analysis_op_free(), and rz_list_new().

rz_analysis_op_new()

RZ_API RzAnalysisOp* rz_analysis_op_new

(

void

)

Definition at line 9 of file op.c.

                                              {
    RzAnalysisOp *op = RZ_NEW(RzAnalysisOp);
    rz_analysis_op_init(op);
    return op;
}

References op, rz_analysis_op_init(), and RZ_NEW.

Referenced by analysis_mask(), rz_analysis_diff_fingerprint_bb(), rz_analysis_mask(), and rz_core_analysis_bytes().

rz_analysis_op_nonlinear()

RZ_API bool rz_analysis_op_nonlinear

(

int

t

)

Definition at line 177 of file op.c.

                                            {
    t &= RZ_ANALYSIS_OP_TYPE_MASK;
    switch (t) {
    // call
    case RZ_ANALYSIS_OP_TYPE_CALL:
    case RZ_ANALYSIS_OP_TYPE_RCALL:
    case RZ_ANALYSIS_OP_TYPE_ICALL:
    case RZ_ANALYSIS_OP_TYPE_UCALL:
    case RZ_ANALYSIS_OP_TYPE_IRCALL:
    case RZ_ANALYSIS_OP_TYPE_UCCALL:
    // jmp
    case RZ_ANALYSIS_OP_TYPE_JMP:
    case RZ_ANALYSIS_OP_TYPE_MJMP:
    case RZ_ANALYSIS_OP_TYPE_UJMP:
    case RZ_ANALYSIS_OP_TYPE_CJMP:
    case RZ_ANALYSIS_OP_TYPE_UCJMP:
    case RZ_ANALYSIS_OP_TYPE_RJMP:
    case RZ_ANALYSIS_OP_TYPE_IJMP:
    case RZ_ANALYSIS_OP_TYPE_IRJMP:
    // trap| ill| unk
    case RZ_ANALYSIS_OP_TYPE_TRAP:
    case RZ_ANALYSIS_OP_TYPE_ILL:
    case RZ_ANALYSIS_OP_TYPE_UNK:
    case RZ_ANALYSIS_OP_TYPE_SWI:
    case RZ_ANALYSIS_OP_TYPE_RET:
        return true;
    default:
        return false;
    }
}

References RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_ICALL, RZ_ANALYSIS_OP_TYPE_IJMP, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_IRCALL, RZ_ANALYSIS_OP_TYPE_IRJMP, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_MASK, RZ_ANALYSIS_OP_TYPE_MJMP, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_RJMP, RZ_ANALYSIS_OP_TYPE_SWI, RZ_ANALYSIS_OP_TYPE_TRAP, RZ_ANALYSIS_OP_TYPE_UCALL, RZ_ANALYSIS_OP_TYPE_UCCALL, RZ_ANALYSIS_OP_TYPE_UCJMP, RZ_ANALYSIS_OP_TYPE_UJMP, and RZ_ANALYSIS_OP_TYPE_UNK.

Referenced by rz_core_analysis_type_match(), and rz_core_link_stroff().

rz_analysis_op_reg_delta()

RZ_API int rz_analysis_op_reg_delta	(	RzAnalysis *	analysis,
		ut64	addr,
		const char *	name
	)

Definition at line 627 of file op.c.

                                                                                       {
    int delta = 0;
    ut8 buf[32];
    analysis->iob.read_at(analysis->iob.io, addr, buf, sizeof(buf));
    RzAnalysisOp op;
    rz_analysis_op_init(&op);
    if (rz_analysis_op(analysis, &op, addr, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_ALL) > 0) {
        if (op.dst && op.dst->reg && op.dst->reg->name && (!name || !strcmp(op.dst->reg->name, name))) {
            if (op.src[0]) {
                delta = op.src[0]->delta;
            }
        }
    }
    rz_analysis_op_fini(&op);
    return delta;
}

References addr, delta, rz_io_bind_t::io, rz_analysis_t::iob, op, rz_io_bind_t::read_at, rz_analysis_op(), rz_analysis_op_fini(), rz_analysis_op_init(), and RZ_ANALYSIS_OP_MASK_ALL.

rz_analysis_op_to_esil_string()

RZ_API const char* rz_analysis_op_to_esil_string	(	RzAnalysis *	analysis,
		RzAnalysisOp *	op
	)

Definition at line 329 of file op.c.

                                                                                         {
    return rz_strbuf_get(&op->esil);
}

References rz_strbuf_get().

rz_analysis_op_to_string()

RZ_API char* rz_analysis_op_to_string	(	RzAnalysis *	analysis,
		RzAnalysisOp *	op
	)

Definition at line 334 of file op.c.

                                                                              {
    RzAnalysisBlock *bb;
    RzAnalysisFunction *f;
    char *cstr, ret[128];
    char *r0 = rz_analysis_value_to_string(op->dst);
    char *a0 = rz_analysis_value_to_string(op->src[0]);
    char *a1 = rz_analysis_value_to_string(op->src[1]);
    if (!r0) {
        r0 = strdup("?");
    }
    if (!a0) {
        a0 = strdup("?");
    }
    if (!a1) {
        a1 = strdup("?");
    }
 
    switch (op->type) {
    case RZ_ANALYSIS_OP_TYPE_MOV:
        snprintf(ret, sizeof(ret), "%s = %s", r0, a0);
        break;
    case RZ_ANALYSIS_OP_TYPE_CJMP:
        if ((bb = rz_analysis_find_most_relevant_block_in(analysis, op->addr))) {
            cstr = rz_analysis_cond_to_string(bb->cond);
            snprintf(ret, sizeof(ret), "if (%s) goto 0x%" PFMT64x, cstr, op->jump);
            free(cstr);
        } else {
            snprintf(ret, sizeof(ret), "if (%s) goto 0x%" PFMT64x, "?", op->jump);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_JMP:
        snprintf(ret, sizeof(ret), "goto 0x%" PFMT64x, op->jump);
        break;
    case RZ_ANALYSIS_OP_TYPE_UJMP:
    case RZ_ANALYSIS_OP_TYPE_RJMP:
    case RZ_ANALYSIS_OP_TYPE_IJMP:
    case RZ_ANALYSIS_OP_TYPE_IRJMP:
        snprintf(ret, sizeof(ret), "goto %s", r0);
        break;
    case RZ_ANALYSIS_OP_TYPE_PUSH:
    case RZ_ANALYSIS_OP_TYPE_UPUSH:
    case RZ_ANALYSIS_OP_TYPE_RPUSH:
        snprintf(ret, sizeof(ret), "push %s", a0);
        break;
    case RZ_ANALYSIS_OP_TYPE_POP:
        snprintf(ret, sizeof(ret), "pop %s", r0);
        break;
    case RZ_ANALYSIS_OP_TYPE_UCALL:
    case RZ_ANALYSIS_OP_TYPE_RCALL:
    case RZ_ANALYSIS_OP_TYPE_ICALL:
    case RZ_ANALYSIS_OP_TYPE_IRCALL:
        snprintf(ret, sizeof(ret), "%s()", r0);
        break;
    case RZ_ANALYSIS_OP_TYPE_CALL:
        f = rz_analysis_get_fcn_in(analysis, op->jump, RZ_ANALYSIS_FCN_TYPE_NULL);
        if (f) {
            snprintf(ret, sizeof(ret), "%s()", f->name);
        } else {
            snprintf(ret, sizeof(ret), "0x%" PFMT64x "()", op->jump);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_CCALL:
        f = rz_analysis_get_fcn_in(analysis, op->jump, RZ_ANALYSIS_FCN_TYPE_NULL);
        if ((bb = rz_analysis_find_most_relevant_block_in(analysis, op->addr))) {
            cstr = rz_analysis_cond_to_string(bb->cond);
            if (f) {
                snprintf(ret, sizeof(ret), "if (%s) %s()", cstr, f->name);
            } else {
                snprintf(ret, sizeof(ret), "if (%s) 0x%" PFMT64x "()", cstr, op->jump);
            }
            free(cstr);
        } else {
            if (f) {
                snprintf(ret, sizeof(ret), "if (unk) %s()", f->name);
            } else {
                snprintf(ret, sizeof(ret), "if (unk) 0x%" PFMT64x "()", op->jump);
            }
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_ADD:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s += %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s + %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_SUB:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s -= %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s - %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_MUL:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s *= %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s * %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_DIV:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s /= %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s / %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_AND:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s &= %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s & %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_OR:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s |= %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s | %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_XOR:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s ^= %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s ^ %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_LEA:
        snprintf(ret, sizeof(ret), "%s -> %s", r0, a0);
        break;
    case RZ_ANALYSIS_OP_TYPE_CMP:
        memcpy(ret, ";", 2);
        break;
    case RZ_ANALYSIS_OP_TYPE_NOP:
        memcpy(ret, "nop", 4);
        break;
    case RZ_ANALYSIS_OP_TYPE_RET:
        memcpy(ret, "ret", 4);
        break;
    case RZ_ANALYSIS_OP_TYPE_CRET:
        if ((bb = rz_analysis_find_most_relevant_block_in(analysis, op->addr))) {
            cstr = rz_analysis_cond_to_string(bb->cond);
            snprintf(ret, sizeof(ret), "if (%s) ret", cstr);
            free(cstr);
        } else {
            strcpy(ret, "if (unk) ret");
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_LEAVE:
        memcpy(ret, "leave", 6);
        break;
    case RZ_ANALYSIS_OP_TYPE_MOD:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "%s %%= %s", r0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s %% %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_XCHG:
        if (!a1 || !strcmp(a0, a1)) {
            snprintf(ret, sizeof(ret), "tmp = %s; %s = %s; %s = tmp", r0, r0, a0, a0);
        } else {
            snprintf(ret, sizeof(ret), "%s = %s ^ %s", r0, a0, a1);
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_ROL:
    case RZ_ANALYSIS_OP_TYPE_ROR:
    case RZ_ANALYSIS_OP_TYPE_SWITCH:
    case RZ_ANALYSIS_OP_TYPE_CASE:
        RZ_LOG_DEBUG("Command not implemented.\n");
        free(r0);
        free(a0);
        free(a1);
        return NULL;
    default:
        free(r0);
        free(a0);
        free(a1);
        return NULL;
    }
    free(r0);
    free(a0);
    free(a1);
    return strdup(ret);
}

References a0, rz_analysis_bb_t::cond, f, free(), memcpy(), NULL, PFMT64x, r0, rz_analysis_cond_to_string(), RZ_ANALYSIS_FCN_TYPE_NULL, rz_analysis_find_most_relevant_block_in(), rz_analysis_get_fcn_in(), RZ_ANALYSIS_OP_TYPE_ADD, RZ_ANALYSIS_OP_TYPE_AND, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CASE, RZ_ANALYSIS_OP_TYPE_CCALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_CMP, RZ_ANALYSIS_OP_TYPE_CRET, RZ_ANALYSIS_OP_TYPE_DIV, RZ_ANALYSIS_OP_TYPE_ICALL, RZ_ANALYSIS_OP_TYPE_IJMP, RZ_ANALYSIS_OP_TYPE_IRCALL, RZ_ANALYSIS_OP_TYPE_IRJMP, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_LEA, RZ_ANALYSIS_OP_TYPE_LEAVE, RZ_ANALYSIS_OP_TYPE_MOD, RZ_ANALYSIS_OP_TYPE_MOV, RZ_ANALYSIS_OP_TYPE_MUL, RZ_ANALYSIS_OP_TYPE_NOP, RZ_ANALYSIS_OP_TYPE_OR, RZ_ANALYSIS_OP_TYPE_POP, RZ_ANALYSIS_OP_TYPE_PUSH, 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_RPUSH, RZ_ANALYSIS_OP_TYPE_SUB, RZ_ANALYSIS_OP_TYPE_SWITCH, RZ_ANALYSIS_OP_TYPE_UCALL, RZ_ANALYSIS_OP_TYPE_UJMP, RZ_ANALYSIS_OP_TYPE_UPUSH, RZ_ANALYSIS_OP_TYPE_XCHG, RZ_ANALYSIS_OP_TYPE_XOR, rz_analysis_value_to_string(), RZ_LOG_DEBUG, snprintf, and strdup().

Referenced by ds_build_op_str(), rz_core_disasm_pdi_with_buf(), and rz_core_print_disasm_instructions_with_buf().

rz_analysis_optype_from_string()

RZ_API int rz_analysis_optype_from_string

(

RZ_NONNULL const char *

name

)

Return the op type corresponding the given name

Parameters

name	string, name of the optype

Returns

type int, id of the op type (one of _RzAnalysisOpType)

Definition at line 294 of file op.c.

                                                                       {
    rz_return_val_if_fail(name, -1);
    int i;
    for (i = 0; RZ_ARRAY_SIZE(optypes); i++) {
        if (!strcmp(optypes[i].name, name)) {
            return optypes[i].type;
        }
    }
    return -1;
}

References i, optypes, RZ_ARRAY_SIZE, rz_return_val_if_fail, and optype::type.

Referenced by rz_analysis_hint_set_optype_handler().

rz_analysis_optype_to_string()

RZ_API const char* rz_analysis_optype_to_string

(

int

type

)

Return the name of the given op type

Parameters

type	int, id of the op type (one of _RzAnalysisOpType)

Returns

name string, string, name of the optype

Definition at line 310 of file op.c.

                                                          {
    int i;
 
    for (i = 0; i < RZ_ARRAY_SIZE(optypes); i++) {
        if (optypes[i].type == type) {
            return optypes[i].name;
        }
    }
 
    type &= RZ_ANALYSIS_OP_TYPE_MASK;
 
    for (i = 0; i < RZ_ARRAY_SIZE(optypes); i++) {
        if (optypes[i].type == type) {
            return optypes[i].name;
        }
    }
    return "undefined";
}

References i, optype::name, optypes, RZ_ANALYSIS_OP_TYPE_MASK, RZ_ARRAY_SIZE, and type.

Referenced by anop32(), core_analysis_bytes_json(), core_analysis_bytes_standard(), do_analysis_search(), ds_must_strip(), ds_print_optype(), hint_node_print(), print_hint_h_format(), print_rop(), rz_core_disasm_pde(), rz_core_print_disasm_json(), showanalysis(), step_until_optype(), and update_stat_for_op().

rz_analysis_stackop_tostring()

RZ_API const char* rz_analysis_stackop_tostring

(

int

s

)

Definition at line 521 of file op.c.

                                                       {
    switch (s) {
    case RZ_ANALYSIS_STACK_NULL:
        return "null";
    case RZ_ANALYSIS_STACK_NOP:
        return "nop";
    case RZ_ANALYSIS_STACK_INC:
        return "inc";
    case RZ_ANALYSIS_STACK_GET:
        return "get";
    case RZ_ANALYSIS_STACK_SET:
        return "set";
    case RZ_ANALYSIS_STACK_RESET:
        return "reset";
    }
    return "unk";
}

References RZ_ANALYSIS_STACK_GET, RZ_ANALYSIS_STACK_INC, RZ_ANALYSIS_STACK_NOP, RZ_ANALYSIS_STACK_NULL, RZ_ANALYSIS_STACK_RESET, RZ_ANALYSIS_STACK_SET, and s.

Referenced by core_analysis_bytes_json(), and core_analysis_bytes_standard().

Variable Documentation

id

int id

Definition at line 540 of file op.c.

Referenced by _zip_ef_delete_by_id(), _zip_ef_new(), avr_AAAAAbbb(), avr_AAdddddAAAA(), avr_AArrrrrAAAA(), avr_dddcrrr(), avr_ddddcccc(), avr_dddddcbbb(), avr_dddddcccc(), avr_dddddcccc_load32(), avr_dddddcccc_store32(), avr_dddddcccc_x(), avr_dddddcccc_xm(), avr_dddddcccc_xp(), avr_dddddcccc_y(), avr_dddddcccc_ym(), avr_dddddcccc_yp(), avr_dddddcccc_z(), avr_dddddcccc_zm(), avr_dddddcccc_zp(), avr_ddddrrrr(), avr_ddddrrrr_2x(), avr_KKddKKKK(), avr_kkkddddkkkk_load16(), avr_kkkddddkkkk_store16(), avr_KKKKcccc(), avr_KKKKddddKKKK(), avr_kkkkkccck(), avr_kkkkkkkccc(), avr_kkkkkkkkkkkk(), avr_qcqqcdddddcqqq_y(), avr_qcqqcdddddcqqq_z(), avr_qcqqcrrrrrcqqq_y(), avr_qcqqcrrrrrcqqq_z(), avr_rdddddrrrr(), avr_rrrrrcbbb(), avr_rrrrrcccc_x(), avr_rrrrrcccc_xm(), avr_rrrrrcccc_xp(), avr_rrrrrcccc_y(), avr_rrrrrcccc_ym(), avr_rrrrrcccc_yp(), avr_rrrrrcccc_z(), avr_rrrrrcccc_zm(), avr_rrrrrcccc_zp(), avr_spmz(), avr_unique(), capture_list_pool_get(), capture_list_pool_get_mut(), capture_list_pool_release(), coder_add_filter(), d_substitution(), get_extra(), insn_find(), kd_send_ctrl_packet(), kd_send_data_packet(), M68K_get_insn_id(), M68K_insn_name(), oids_od_binsert(), rz_convert_mne_handler(), rz_id_storage_delete(), rz_id_storage_get(), rz_id_storage_get_next(), rz_id_storage_get_prev(), rz_id_storage_set(), rz_oids_add(), rz_oids_foreach(), rz_oids_foreach_prev(), rz_oids_oget(), rz_oids_sort(), rz_oids_to_front(), rz_oids_to_rear(), RZ_PACKED(), rz_x509_crlentry_dump(), symbol_table_insert_name(), symbol_table_name_for_id(), ts_language_field_name_for_id(), ts_tree_cursor_current_field_name(), and wasm_dis().

name

static void struct sockaddr socklen_t static fromlen static backlog static fork char char char static envp int struct rusage static rusage struct utsname static buf struct sembuf static nsops static fd const char static length unsigned struct dirent unsigned static count const char const char static newpath const char static pathname const char const char static newpath const char const char static newpath const char static mode const char static group const char static group struct timeval struct timezone static tz struct tms static buf static getuid static getgid static getegid static getppid static setsid static egid static suid static pid static fsgid static data const char static dev unsigned static persona const char struct statfs static buf unsigned char static buf static prio struct sched_param static p static policy struct timespec static tp const void static len static munlockall const char static path const char static filename const char static path const char static len unsigned unsigned static turn_on const char name

Definition at line 541 of file op.c.

Referenced by __func_name_from_ord(), _zip_guess_encoding(), _zip_hash_add(), aarch64_symbol_is_valid(), args_parse(), bin_pe_init_sections(), bin_pe_parse_imports(), bopen(), c_parser_new_anonymous_callable_name(), c_parser_new_anonymous_enum_name(), c_parser_new_anonymous_structure_name(), c_parser_new_anonymous_union_name(), check_features(), chmd_read_headers(), cmd_foreach_cmdname_modes(), cmd_print_format(), core_recover_golang_functions_go_1_16(), core_recover_golang_functions_go_1_18(), core_recover_golang_functions_go_1_2(), cplus_demangle_fill_ctor(), cplus_demangle_fill_dtor(), cplus_demangle_fill_extended_operator(), create_class_type(), create_output_name(), create_si_class_type(), create_vmi_class_type(), d_expression_1(), d_identifier(), d_local_name(), d_make_sub(), diff_output_start_file(), ds_print_calls_hints(), ds_show_xrefs(), find_ipa_binary(), get_die_name(), get_ivar_list_t(), get_method_list_t(), get_operator_code(), get_regname(), get_sym_code_type(), gzscan(), imports(), insn_to_str(), is_cab_using_unix_paths(), is_special_char(), key_class(), lastNameFromPath(), le_get_symbol(), linux_handle_signals(), load_spanning_cabinets(), main(), main_print_var(), meta_string_guess_add(), parse_atomic_type(), parse_enumerator(), parse_options(), parse_struct_member(), parse_symbol_table(), parse_typedef(), pdb_set_symbols(), print_comment(), print_insn_sparc(), print_stats(), process_cabinet(), read_name(), read_str(), recovery_apply_complete_object_locator(), recovery_apply_type_descriptor(), resolve_path(), rtti_itanium_read_type_name_custom(), rz_analysis_extract_rarg(), rz_analysis_function_name_guess(), rz_analysis_il_init_state_set_var(), rz_analysis_noreturn_add(), rz_bin_elf_get_osabi_name(), rz_bin_filter_name(), rz_bin_force_plugin(), rz_bin_java_class_fields_as_text(), rz_bin_java_class_methods_as_text(), rz_bin_ne_get_imports(), rz_bin_ne_get_symbols(), rz_bin_select(), rz_cmd_macro_add(), rz_core_analysis_autoname_all_fcns(), rz_core_analysis_fcn_name(), rz_core_bin_pdb_gvars_as_string(), rz_core_rtr_add(), rz_core_rtr_gdb_cb(), rz_core_run_script(), rz_core_types_function_print_all(), rz_core_visual_cmd(), rz_core_visual_define(), rz_core_visual_xrefs(), rz_eval_spaces_handler(), rz_file_mkstemp(), rz_il_reg_binding_derive(), rz_io_zip_open(), rz_main_rz_bin(), rz_main_version_verify(), rz_name_filter(), RZ_PACKED(), rz_reg_is_readonly(), rz_syscmd_ls(), rz_table_set_vcolumnsf(), rz_type_noreturn_del_all_handler(), sdb_load_platform_profile(), sdb_load_sysregs(), sep64_xtr_ctx_get_slice(), set_filename_printable_name(), set_name(), set_note_file(), unique_class_name(), unix_path_seperators(), uv__random_sysctl(), walkSymbols(), xtensa_state_lookup(), xtensa_sysreg_lookup_name(), zip_delete(), and zip_stat_index().

const { ... } op_families[]

Initial value:

= {
    { RZ_ANALYSIS_OP_FAMILY_CPU, "cpu" },
    { RZ_ANALYSIS_OP_FAMILY_FPU, "fpu" },
    { RZ_ANALYSIS_OP_FAMILY_MMX, "mmx" },
    { RZ_ANALYSIS_OP_FAMILY_SSE, "sse" },
    { RZ_ANALYSIS_OP_FAMILY_PRIV, "priv" },
    { RZ_ANALYSIS_OP_FAMILY_VIRT, "virt" },
    { RZ_ANALYSIS_OP_FAMILY_CRYPTO, "crpt" },
    { RZ_ANALYSIS_OP_FAMILY_IO, "io" },
    { RZ_ANALYSIS_OP_FAMILY_SECURITY, "sec" },
    { RZ_ANALYSIS_OP_FAMILY_THREAD, "thread" },
}

Referenced by rz_analysis_op_family_from_string(), and rz_analysis_op_family_to_string().

optypes

struct optype optypes[]

static

Referenced by rz_analysis_optype_from_string(), and rz_analysis_optype_to_string().