carg.c File Reference

#include <rz_core.h>

Go to the source code of this file.

Macros
#define	MAXSTRLEN   50

Functions
RZ_DEPRECATE RZ_API ut64	rz_core_arg_get (RzCore *core, const char *cc, int num)
	Get the value of the num-th argument from the current debug or emulation state. More...
RZ_DEPRECATE RZ_API bool	rz_core_arg_set (RzCore *core, const char *cc, int num, ut64 val)
	Set the value of the num-th argument in the current debug or emulation state. More...
static void	set_fcn_args_info (RzAnalysisFuncArg *arg, RzAnalysis *analysis, const char *fcn_name, const char *cc, int arg_num)
RZ_API char *	resolve_fcn_name (RzAnalysis *analysis, const char *func_name)
static ut64	get_buf_val (ut8 *buf, int endian, int width)
static void	print_arg_str (int argcnt, const char *name, bool color)
static void	print_format_values (RzCore *core, const char *fmt, bool onstack, ut64 src, bool color)
RZ_API void	rz_core_print_func_args (RzCore *core)
static void	rz_analysis_fcn_arg_free (RzAnalysisFuncArg *arg)
RZ_API RZ_OWN RzList *	rz_core_get_func_args (RzCore *core, const char *fcn_name)

Macro Definition Documentation

MAXSTRLEN

#define MAXSTRLEN   50

Definition at line 6 of file carg.c.

Function Documentation

get_buf_val()

static ut64 get_buf_val ( ut8 *  buf, int  endian, int  width  )

static

Definition at line 102 of file carg.c.

                                                         {
    return (width == 8) ? rz_read_ble64(buf, endian) : (ut64)rz_read_ble32(buf, endian);
}

References rz_read_ble32(), rz_read_ble64(), ut64(), and width.

Referenced by print_format_values().

print_arg_str()

static void print_arg_str ( int  argcnt, const char *  name, bool  color  )

static

Definition at line 106 of file carg.c.

                                                                    {
    if (color) {
        rz_cons_printf(Color_BYELLOW " arg [%d]" Color_RESET " -" Color_BCYAN " %s" Color_RESET " : ",
            argcnt, name);
    } else {
        rz_cons_printf(" arg [%d] -  %s : ", argcnt, name);
    }
}

References color, Color_BCYAN, Color_BYELLOW, Color_RESET, and rz_cons_printf().

Referenced by rz_core_print_func_args().

print_format_values()

static void print_format_values ( RzCore *  core, const char *  fmt, bool  onstack, ut64  src, bool  color  )

static

Definition at line 115 of file carg.c.

                                                                                                   {
    char opt;
    ut64 bval = src;
    int i;
    int endian = core->print->big_endian;
    int width = (core->analysis->bits == 64) ? 8 : 4;
    int bsize = RZ_MIN(64, core->blocksize);
 
    ut8 *buf = malloc(bsize);
    if (!buf) {
        eprintf("Cannot allocate %d byte(s)\n", bsize);
        free(buf);
        return;
    }
    if (fmt) {
        opt = *fmt;
    } else {
        opt = 'p'; // void *ptr
    }
    if (onstack || ((opt != 'd' && opt != 'x') && !onstack)) {
        if (color) {
            rz_cons_printf(Color_BGREEN "0x%08" PFMT64x Color_RESET " --> ", bval);
        } else {
            rz_cons_printf("0x%08" PFMT64x " --> ", bval);
        }
        rz_io_read_at(core->io, bval, buf, bsize);
    }
    if (onstack) { // Fetch value from stack
        bval = get_buf_val(buf, endian, width);
        if (opt != 'd' && opt != 'x') {
            rz_io_read_at(core->io, bval, buf, bsize); // update buf with val from stack
        }
    }
    rz_cons_print(color ? Color_BGREEN : "");
    switch (opt) {
    case 'z': // Null terminated string
        rz_cons_print(color ? Color_RESET Color_BWHITE : "");
        rz_cons_print("\"");
        for (i = 0; i < MAXSTRLEN; i++) {
            if (buf[i] == '\0') {
                break;
            }
            ut8 b = buf[i];
            if (IS_PRINTABLE(b)) {
                rz_cons_printf("%c", b);
            } else {
                rz_cons_printf("\\x%02x", b);
            }
            if (i == MAXSTRLEN - 1) {
                rz_cons_print("..."); // To show string is truncated
            }
        }
        rz_cons_print("\"");
        rz_cons_newline();
        break;
    case 'd': // integer
    case 'x':
        rz_cons_printf("0x%08" PFMT64x, bval);
        rz_cons_newline();
        break;
    case 'c': // char
        rz_cons_print("\'");
        ut8 ch = buf[0];
        if (IS_PRINTABLE(ch)) {
            rz_cons_printf("%c", ch);
        } else {
            rz_cons_printf("\\x%02x", ch);
        }
        rz_cons_print("\'");
        rz_cons_newline();
        break;
    case 'p': // pointer
    {
        // Try to deref the pointer once again
        rz_cons_printf("0x%08" PFMT64x, get_buf_val(buf, endian, width));
        rz_cons_newline();
        break;
    }
    default:
        // TODO: support types like structs and unions
        rz_cons_println("unk_format");
    }
    rz_cons_print(Color_RESET);
    free(buf);
}

References rz_core_t::analysis, b, rz_print_t::big_endian, rz_analysis_t::bits, rz_core_t::blocksize, color, Color_BGREEN, Color_BWHITE, Color_RESET, eprintf, free(), get_buf_val(), i, rz_core_t::io, IS_PRINTABLE, malloc(), MAXSTRLEN, PFMT64x, rz_core_t::print, rz_cons_newline(), rz_cons_printf(), rz_cons_println(), rz_io_read_at(), RZ_MIN, src, ut64(), and width.

Referenced by rz_core_print_func_args().

resolve_fcn_name()

RZ_API char* resolve_fcn_name	(	RzAnalysis *	analysis,
		const char *	func_name
	)

Definition at line 86 of file carg.c.

                                                                           {
    const char *str = func_name;
    const char *name = func_name;
    if (rz_type_func_exist(analysis->typedb, func_name)) {
        return strdup(func_name);
    }
    while ((str = strchr(str, '.'))) {
        name = str + 1;
        str++;
    }
    if (rz_type_func_exist(analysis->typedb, name)) {
        return strdup(name);
    }
    return rz_analysis_function_name_guess(analysis->typedb, (char *)func_name);
}

References rz_analysis_function_name_guess(), rz_type_func_exist(), cmd_descs_generate::str, strdup(), and rz_analysis_t::typedb.

Referenced by ds_print_esil_analysis(), rz_core_analysis_function_signature(), and rz_core_get_func_args().

rz_analysis_fcn_arg_free()

static void rz_analysis_fcn_arg_free ( RzAnalysisFuncArg *  arg )

static

Definition at line 269 of file carg.c.

                                                             {
    if (!arg) {
        return;
    }
    free(arg);
}

References free().

Referenced by rz_core_get_func_args().

rz_core_arg_get()

RZ_DEPRECATE RZ_API ut64 rz_core_arg_get	(	RzCore *	core,
		const char *	cc,
		int	num
	)

Get the value of the num-th argument from the current debug or emulation state.

Warning: this function contains hacks. Rewrite it before using it in new code.

Definition at line 13 of file carg.c.

                                                                                {
    rz_return_val_if_fail(core, UT64_MAX);
    if (!cc) {
        cc = rz_analysis_syscc_default(core->analysis);
    }
    if (rz_core_is_debug(core)) {
        rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ANY, false);
    }
    if (!RZ_STR_ISEMPTY(cc)) {
        if (!strcmp(cc, "stdcall") || !strcmp(cc, "pascal")) {
            ut64 sp = rz_reg_get_value_by_role(rz_core_reg_default(core), RZ_REG_NAME_SP);
            int bits = rz_core_is_debug(core) ? core->dbg->bits : core->analysis->bits;
            if (bits) {
                ut64 n64;
                sp += 8; // skip return address, assume we are inside the call
                sp += 8 * num;
                // FIXME: honor endianness of platform
                rz_io_read_at(core->io, sp, (ut8 *)&n64, sizeof(ut64));
                return (ut64)n64;
            } else {
                sp += 4; // skip return address, assume we are inside the call
                sp += 4 * num;
                ut32 n32;
                // FIXME: honor endianness of platform
                rz_io_read_at(core->io, sp, (ut8 *)&n32, sizeof(ut32));
                return (ut64)n32;
            }
        }
        const char *rn = rz_analysis_cc_arg(core->analysis, cc, num);
        if (rn) {
            return rz_core_reg_getv_by_role_or_name(core, rn);
        }
    }
    char reg[32];
    return rz_core_reg_getv_by_role_or_name(core, rz_strf(reg, "A%d", num));
}

References rz_core_t::analysis, rz_analysis_t::bits, rz_debug_t::bits, bits(), rz_core_t::dbg, rz_core_t::io, num, reg, rz_analysis_cc_arg(), rz_analysis_syscc_default(), rz_core_is_debug(), rz_core_reg_default(), rz_core_reg_getv_by_role_or_name(), rz_debug_reg_sync(), rz_io_read_at(), rz_reg_get_value_by_role(), RZ_REG_NAME_SP, RZ_REG_TYPE_ANY, rz_return_val_if_fail, RZ_STR_ISEMPTY, rz_strf, sp, ut64(), and UT64_MAX.

Referenced by ds_print_esil_analysis(), rz_core_print_func_args(), and rz_core_syscall_as_string().

rz_core_arg_set()

RZ_DEPRECATE RZ_API bool rz_core_arg_set	(	RzCore *	core,
		const char *	cc,
		int	num,
		ut64	val
	)

Set the value of the num-th argument in the current debug or emulation state.

Warning: this function contains hacks. Rewrite it before using it in new code.

Definition at line 55 of file carg.c.

                                                                                          {
    rz_return_val_if_fail(core, false);
    if (!RZ_STR_ISEMPTY(cc)) {
        cc = rz_analysis_syscc_default(core->analysis);
    }
    const char *rn = rz_analysis_cc_arg(core->analysis, cc, num);
    if (rn) {
        rz_core_reg_set_by_role_or_name(core, rn, val);
        return true;
    }
    char reg[32];
    rz_core_reg_set_by_role_or_name(core, rz_strf(reg, "A%d", num), val);
    return true;
}

References rz_core_t::analysis, num, reg, rz_analysis_cc_arg(), rz_analysis_syscc_default(), rz_core_reg_set_by_role_or_name(), rz_return_val_if_fail, RZ_STR_ISEMPTY, rz_strf, and val.

rz_core_get_func_args()

RZ_API RZ_OWN RzList* rz_core_get_func_args	(	RzCore *	core,
		const char *	fcn_name
	)

Definition at line 276 of file carg.c.

                                                                                  {
    if (!fcn_name || !core->analysis) {
        return NULL;
    }
    char *key = resolve_fcn_name(core->analysis, fcn_name);
    if (!key) {
        return NULL;
    }
    RzList *list = rz_list_newf((RzListFree)rz_analysis_fcn_arg_free);
    const char *sp = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_SP);
    int nargs = rz_type_func_args_count(core->analysis->typedb, key);
    if (!rz_analysis_cc_func(core->analysis, key)) {
        rz_list_free(list);
        return NULL;
    }
    char *cc = strdup(rz_analysis_cc_func(core->analysis, key));
    const char *src = rz_analysis_cc_arg(core->analysis, cc, 0); // src of first argument
    if (!cc) {
        // unsupported calling convention
        free(key);
        rz_list_free(list);
        return NULL;
    }
    int i;
    ut64 spv = rz_reg_getv(core->analysis->reg, sp);
    ut64 s_width = (core->analysis->bits == 64) ? 8 : 4;
    if (src && !strcmp(src, "stack_rev")) {
        for (i = nargs - 1; i >= 0; i--) {
            RzAnalysisFuncArg *arg = RZ_NEW0(RzAnalysisFuncArg);
            set_fcn_args_info(arg, core->analysis, key, cc, i);
            arg->src = spv;
            spv += arg->size ? arg->size : s_width;
            rz_list_append(list, arg);
        }
    } else {
        for (i = 0; i < nargs; i++) {
            RzAnalysisFuncArg *arg = RZ_NEW0(RzAnalysisFuncArg);
            if (!arg) {
                free(cc);
                rz_list_free(list);
                return NULL;
            }
            set_fcn_args_info(arg, core->analysis, key, cc, i);
            if (src && !strncmp(src, "stack", 5)) {
                arg->src = spv;
                if (!arg->size) {
                    arg->size = s_width;
                }
                spv += arg->size;
            } else {
                const char *cs = arg->cc_source;
                if (!cs) {
                    cs = rz_analysis_cc_default(core->analysis);
                }
                if (cs) {
                    arg->src = rz_reg_getv(core->analysis->reg, cs);
                }
            }
            rz_list_append(list, arg);
        }
    }
    free(key);
    free(cc);
    return list;
}

References rz_core_t::analysis, rz_analysis_t::bits, test_evm::cs, free(), i, key, list(), cmd_descs_generate::nargs, NULL, rz_analysis_t::reg, resolve_fcn_name(), rz_analysis_cc_arg(), rz_analysis_cc_default(), rz_analysis_cc_func(), rz_analysis_fcn_arg_free(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW0, rz_reg_get_name(), rz_reg_getv(), RZ_REG_NAME_SP, rz_type_func_args_count(), set_fcn_args_info(), sp, src, strdup(), rz_analysis_t::typedb, and ut64().

Referenced by ds_print_esil_analysis(), rz_core_analysis_function_signature(), and rz_core_print_func_args().

rz_core_print_func_args()

RZ_API void rz_core_print_func_args

(

RzCore *

core

)

Definition at line 203 of file carg.c.

                                                  {
    RzListIter *iter;
    bool color = rz_config_get_i(core->config, "scr.color");
    if (!core->analysis) {
        return;
    }
    if (!core->analysis->reg) {
        return;
    }
    const char *pc = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_PC);
    ut64 cur_addr = rz_reg_getv(core->analysis->reg, pc);
    RzAnalysisOp *op = rz_core_analysis_op(core, cur_addr, RZ_ANALYSIS_OP_MASK_BASIC);
    if (!op) {
        return;
    }
    if (op->type == RZ_ANALYSIS_OP_TYPE_CALL) {
        RzAnalysisFunction *fcn;
        RzAnalysisFuncArg *arg;
        bool onstack = false;
        const char *fcn_name = NULL;
        ut64 pcv = op->jump;
        if (pcv == UT64_MAX) {
            pcv = op->ptr;
        }
        fcn = rz_analysis_get_function_at(core->analysis, pcv);
        if (fcn) {
            fcn_name = fcn->name;
        } else {
            if (core->flags) {
                RzFlagItem *item = rz_flag_get_i(core->flags, pcv);
                if (item) {
                    fcn_name = item->name;
                }
            }
        }
        RzList *list = rz_core_get_func_args(core, fcn_name);
        if (!rz_list_empty(list)) {
            int argcnt = 0;
            rz_list_foreach (list, iter, arg) {
                if (arg->cc_source && !strncmp(arg->cc_source, "stack", 5)) {
                    onstack = true;
                }
                print_arg_str(argcnt, arg->name, color);
                print_format_values(core, arg->fmt, onstack, arg->src, color);
                argcnt++;
            }
        } else {
            int nargs = 4; // TODO: use a correct value here when available
            // if (nargs > 0) {
            int i;
            const char *cc = rz_analysis_cc_default(core->analysis); // or use "reg" ?
            for (i = 0; i < nargs; i++) {
                ut64 v = rz_core_arg_get(core, cc, i);
                print_arg_str(i, "", color);
                rz_cons_printf("0x%08" PFMT64x, v);
                rz_cons_newline();
            }
            //} else {
            //  print_arg_str (0, "void", color);
            //}
        }
        rz_list_free(list);
    }
    rz_analysis_op_fini(op);
}

References rz_core_t::analysis, arg(), color, rz_core_t::config, rz_core_t::flags, i, list(), arg::name, rz_analysis_function_t::name, rz_flag_item_t::name, cmd_descs_generate::nargs, NULL, pc, PFMT64x, print_arg_str(), print_format_values(), rz_analysis_t::reg, rz_analysis_cc_default(), rz_analysis_get_function_at(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_TYPE_CALL, rz_config_get_i(), rz_cons_newline(), rz_cons_printf(), rz_core_analysis_op(), rz_core_arg_get(), rz_core_get_func_args(), rz_flag_get_i(), rz_list_free(), rz_reg_get_name(), rz_reg_getv(), RZ_REG_NAME_PC, ut64(), UT64_MAX, and v.

Referenced by rz_analysis_function_analyze_args_handler().

set_fcn_args_info()

static void set_fcn_args_info ( RzAnalysisFuncArg *  arg, RzAnalysis *  analysis, const char *  fcn_name, const char *  cc, int  arg_num  )

static

Definition at line 70 of file carg.c.

                                                                                                                               {
    if (!fcn_name || !arg || !analysis) {
        return;
    }
    arg->name = rz_type_func_args_name(analysis->typedb, fcn_name, arg_num);
    arg->orig_c_type = rz_type_func_args_type(analysis->typedb, fcn_name, arg_num);
    if (!arg->name || !arg->orig_c_type) {
        eprintf("Missing type for function argument (%s)\n", fcn_name);
        return;
    }
    arg->c_type = arg->orig_c_type;
    arg->fmt = rz_type_as_format(analysis->typedb, arg->c_type);
    arg->size = rz_type_db_get_bitsize(analysis->typedb, arg->c_type) / 8;
    arg->cc_source = rz_analysis_cc_arg(analysis, cc, arg_num);
}

References eprintf, arg::name, rz_analysis_cc_arg(), rz_type_as_format(), rz_type_db_get_bitsize(), rz_type_func_args_name(), rz_type_func_args_type(), and rz_analysis_t::typedb.

Referenced by rz_core_get_func_args().