ctypes.c File Reference

#include <string.h>
#include <rz_types.h>
#include <rz_list.h>
#include <rz_core.h>
#include <rz_type.h>
#include "core_private.h"

Go to the source code of this file.

Classes
struct	TLAnalysisContext
struct	coremodepj

Functions
RZ_IPI void	rz_core_types_calling_conventions_print (RzCore *core, RzOutputMode mode)
RZ_IPI void	rz_core_types_enum_print (RzCore *core, const RzBaseType *btype, RzOutputMode mode, PJ *pj)
RZ_IPI void	rz_core_types_enum_print_all (RzCore *core, RzOutputMode mode)
RZ_IPI RZ_OWN char *	rz_core_types_enum_as_c (RzTypeDB *typedb, const RzBaseType *btype, bool multiline)
RZ_IPI RZ_OWN char *	rz_core_types_enum_as_c_all (RzTypeDB *typedb, bool multiline)
RZ_IPI void	rz_core_types_union_print (RzCore *core, const RzBaseType *btype, RzOutputMode mode, PJ *pj)
RZ_IPI void	rz_core_types_union_print_all (RzCore *core, RzOutputMode mode)
RZ_IPI RZ_OWN char *	rz_core_types_union_as_c (RzTypeDB *typedb, const RzBaseType *btype, bool multiline)
RZ_IPI RZ_OWN char *	rz_core_types_union_as_c_all (RzTypeDB *typedb, bool multiline)
RZ_IPI void	rz_core_types_struct_print (RzCore *core, const RzBaseType *btype, RzOutputMode mode, PJ *pj)
RZ_IPI void	rz_core_types_struct_print_all (RzCore *core, RzOutputMode mode)
RZ_IPI RZ_OWN char *	rz_core_types_struct_as_c (RzTypeDB *typedb, const RzBaseType *btype, bool multiline)
RZ_IPI RZ_OWN char *	rz_core_types_struct_as_c_all (RzTypeDB *typedb, bool multiline)
RZ_IPI void	rz_core_types_typedef_print (RzCore *core, const RzBaseType *btype, RzOutputMode mode, PJ *pj)
RZ_IPI void	rz_core_types_typedef_print_all (RzCore *core, RzOutputMode mode)
RZ_IPI RZ_OWN char *	rz_core_types_typedef_as_c (RzTypeDB *typedb, const RzBaseType *btype)
RZ_IPI RZ_OWN char *	rz_core_types_typedef_as_c_all (RzTypeDB *typedb)
RZ_IPI RZ_OWN char *	rz_core_base_type_as_c (RzCore *core, RZ_NONNULL RzBaseType *type, bool multiline)
RZ_API RZ_OWN char *	rz_core_types_as_c (RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, bool multiline)
	Get a type string by name (. More...
RZ_API RZ_OWN char *	rz_core_types_as_c_all (RZ_NONNULL RzCore *core, bool multiline)
	Get all types with pretty printing. More...
RZ_IPI void	rz_core_types_function_print (RzTypeDB *typedb, const char *function, RzOutputMode mode, PJ *pj)
RZ_IPI void	rz_core_types_function_print_all (RzCore *core, RzOutputMode mode)
static bool	nonreturn_print (RzCore *core, RzList *noretl)
static bool	nonreturn_print_json (RzCore *core, RzList *noretl)
RZ_IPI void	rz_core_types_function_noreturn_print (RzCore *core, RzOutputMode mode)
RZ_IPI void	rz_core_types_show_format (RzCore *core, const char *name, RzOutputMode mode)
RZ_IPI void	rz_core_types_struct_print_format_all (RzCore *core)
RZ_IPI void	rz_core_types_union_print_format_all (RzCore *core)
static void	set_retval (RzCore *core, ut64 at)
static void	set_offset_hint (RzCore *core, RzAnalysisOp *op, RZ_BORROW RzTypePath *tpath, ut64 laddr, ut64 at, int offimm)
static void	resolve_type_links (RzCore *core, ut64 at, struct TLAnalysisContext *ctx, int ret, bool *resolved)
RZ_API void	rz_core_link_stroff (RzCore *core, RzAnalysisFunction *fcn)
RZ_IPI void	rz_core_types_link_print (RzCore *core, RzType *type, ut64 addr, RzOutputMode mode, PJ *pj)
static bool	typelink_print_cb (void *user, ut64 k, const void *v)
RZ_IPI void	rz_core_types_link_print_all (RzCore *core, RzOutputMode mode)
RZ_API void	rz_core_types_link (RzCore *core, const char *typestr, ut64 addr)
	Link an address addr to the type referenced by typestr. More...
RZ_IPI void	rz_core_types_link_show (RzCore *core, ut64 addr)
RZ_IPI void	rz_core_types_print_all (RzCore *core, RzOutputMode mode)
RZ_IPI void	rz_types_define (RzCore *core, const char *type)
RZ_IPI bool	rz_types_open_file (RzCore *core, const char *path)
RZ_IPI bool	rz_types_open_editor (RzCore *core, RZ_NONNULL const char *name)

Function Documentation

nonreturn_print()

static bool nonreturn_print ( RzCore *  core, RzList *  noretl  )

static

Definition at line 530 of file ctypes.c.

                                                          {
    RzListIter *it;
    char *s;
    rz_list_foreach (noretl, it, s) {
        rz_cons_println(s);
    }
    return true;
}

References rz_cons_println(), and s.

Referenced by rz_core_types_function_noreturn_print().

nonreturn_print_json()

static bool nonreturn_print_json ( RzCore *  core, RzList *  noretl  )

static

Definition at line 539 of file ctypes.c.

                                                               {
    RzListIter *it;
    char *s;
    PJ *pj = pj_new();
    pj_a(pj);
    rz_list_foreach (noretl, it, s) {
        pj_s(pj, s);
    }
    pj_end(pj);
    rz_cons_println(pj_string(pj));
    pj_free(pj);
    return true;
}

References pj_a(), pj_end(), pj_free(), pj_new(), pj_s(), pj_string(), rz_cons_println(), and s.

Referenced by rz_core_types_function_noreturn_print().

resolve_type_links()

static void resolve_type_links ( RzCore *  core, ut64  at, struct TLAnalysisContext *  ctx, int  ret, bool *  resolved  )

static

Definition at line 681 of file ctypes.c.

                                                                                                              {
    // At first we check if there are links to the corresponding addresses
    RzList *slinks = rz_analysis_type_paths_by_address(core->analysis, ctx->src_addr);
    RzList *dlinks = rz_analysis_type_paths_by_address(core->analysis, ctx->dst_addr);
    RzList *vlinks = rz_analysis_type_paths_by_address(core->analysis, ctx->src_addr + ctx->src_imm);
    // TODO: Handle register based arg for struct offset propgation
    if (vlinks && rz_list_length(vlinks) && ctx->var && ctx->var->kind != 'r') {
        RzTypePath *vlink = rz_list_get_top(vlinks);
        // FIXME: For now we only propagate simple type identifiers,
        // no pointers or arrays
        if (vlink->typ->kind == RZ_TYPE_KIND_IDENTIFIER) {
            if (!vlink->typ->identifier.name) {
                rz_warn_if_reached();
                return;
            }
            RzBaseType *varbtype = rz_type_db_get_base_type(core->analysis->typedb, vlink->typ->identifier.name);
            if (varbtype) {
                // if a var addr matches with struct , change it's type and name
                // var int local_e0h --> var struct foo
                // if (strcmp(var->name, vlink) && !*resolved) {
                if (!*resolved) {
                    *resolved = true;
                    rz_analysis_var_set_type(ctx->var, vlink->typ, true);
                    rz_analysis_var_rename(ctx->var, vlink->typ->identifier.name, false);
                }
            }
        }
    } else if (slinks && rz_list_length(slinks)) {
        RzTypePath *slink = rz_list_get_top(slinks);
        set_offset_hint(core, ctx->aop, slink, ctx->src_addr, at - ret, ctx->src_imm);
    } else if (dlinks && rz_list_length(dlinks)) {
        RzTypePath *dlink = rz_list_get_top(dlinks);
        set_offset_hint(core, ctx->aop, dlink, ctx->dst_addr, at - ret, ctx->dst_imm);
    }
}

References rz_core_t::analysis, rz_type_t::identifier, rz_type_t::kind, rz_analysis_type_paths_by_address(), rz_analysis_var_rename(), rz_analysis_var_set_type(), rz_list_get_top(), rz_list_length(), rz_type_db_get_base_type(), RZ_TYPE_KIND_IDENTIFIER, rz_warn_if_reached, set_offset_hint(), rz_type_path_t::typ, and rz_analysis_t::typedb.

Referenced by rz_core_link_stroff().

rz_core_base_type_as_c()

RZ_IPI RZ_OWN char* rz_core_base_type_as_c	(	RzCore *	core,
		RZ_NONNULL RzBaseType *	type,
		bool	multiline
	)

Definition at line 408 of file ctypes.c.

                                                                                                      {
    rz_return_val_if_fail(type, NULL);
 
    unsigned int multiline_opt = 0;
    if (multiline) {
        multiline_opt = RZ_TYPE_PRINT_MULTILINE;
    }
    return rz_type_db_base_type_as_pretty_string(core->analysis->typedb, type, multiline_opt | RZ_TYPE_PRINT_END_NEWLINE | RZ_TYPE_PRINT_ANONYMOUS, 1);
}

References rz_core_t::analysis, NULL, rz_return_val_if_fail, rz_type_db_base_type_as_pretty_string(), RZ_TYPE_PRINT_ANONYMOUS, RZ_TYPE_PRINT_END_NEWLINE, RZ_TYPE_PRINT_MULTILINE, type, and rz_analysis_t::typedb.

Referenced by rz_core_types_as_c(), and rz_types_open_editor().

rz_core_link_stroff()

RZ_API void rz_core_link_stroff	(	RzCore *	core,
		RzAnalysisFunction *	fcn
	)

Definition at line 717 of file ctypes.c.

                                                                       {
    rz_return_if_fail(core && core->analysis && fcn);
    RzAnalysisBlock *bb;
    RzListIter *it;
    RzAnalysisOp aop = { 0 };
    bool ioCache = rz_config_get_i(core->config, "io.cache");
    bool stack_set = false;
    bool resolved = false;
    int dbg_follow = rz_config_get_i(core->config, "dbg.follow");
    RzAnalysisEsil *esil;
    int iotrap = rz_config_get_i(core->config, "esil.iotrap");
    int stacksize = rz_config_get_i(core->config, "esil.stack.depth");
    unsigned int addrsize = rz_config_get_i(core->config, "esil.addr.size");
    const char *pc_name = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_PC);
    const char *sp_name = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_SP);
    RzRegItem *pc = rz_reg_get(core->analysis->reg, pc_name, -1);
 
    if (!(esil = rz_analysis_esil_new(stacksize, iotrap, addrsize))) {
        return;
    }
    rz_analysis_esil_setup(esil, core->analysis, 0, 0, 0);
    int i, ret, bsize = RZ_MAX(64, core->blocksize);
    const int mininstrsz = rz_analysis_archinfo(core->analysis, RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE);
    const int maxinstrsz = rz_analysis_archinfo(core->analysis, RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE);
    const int minopcode = RZ_MAX(1, mininstrsz);
    ut8 *buf = malloc(bsize);
    if (!buf) {
        free(buf);
        rz_analysis_esil_free(esil);
        return;
    }
    rz_reg_arena_push(core->analysis->reg);
    rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ANY, true);
    ut64 spval = rz_reg_getv(esil->analysis->reg, sp_name);
    if (spval) {
        // reset stack pointer to initial value
        RzRegItem *sp = rz_reg_get(esil->analysis->reg, sp_name, -1);
        ut64 curpc = rz_reg_getv(esil->analysis->reg, pc_name);
        int stacksz = rz_core_get_stacksz(core, fcn->addr, curpc);
        if (stacksz > 0) {
            rz_reg_arena_zero(esil->analysis->reg, RZ_REG_TYPE_ANY); // clear prev reg values
            rz_reg_set_value(esil->analysis->reg, sp, spval + stacksz);
        }
    } else {
        // initialize stack
        rz_core_analysis_esil_init_mem(core, NULL, UT64_MAX, UT32_MAX);
        stack_set = true;
    }
    rz_config_set_i(core->config, "io.cache", 1);
    rz_config_set_i(core->config, "dbg.follow", 0);
    ut64 oldoff = core->offset;
    rz_cons_break_push(NULL, NULL);
    // TODO: The algorithm can be more accurate if blocks are followed by their jmp/fail, not just by address
    rz_list_sort(fcn->bbs, bb_cmpaddr);
    rz_list_foreach (fcn->bbs, it, bb) {
        ut64 at = bb->addr;
        ut64 to = bb->addr + bb->size;
        rz_reg_set_value(esil->analysis->reg, pc, at);
        for (i = 0; at < to; i++) {
            if (rz_cons_is_breaked()) {
                goto beach;
            }
            if (at < bb->addr) {
                break;
            }
            if (i >= (bsize - maxinstrsz)) {
                i = 0;
            }
            if (!i) {
                rz_io_read_at(core->io, at, buf, bsize);
            }
            ret = rz_analysis_op(core->analysis, &aop, at, buf + i, bsize - i, RZ_ANALYSIS_OP_MASK_VAL);
            if (ret <= 0) {
                i += minopcode;
                at += minopcode;
                rz_analysis_op_fini(&aop);
                continue;
            }
            i += ret - 1;
            at += ret;
            int j, src_imm = -1, dst_imm = -1;
            ut64 src_addr = UT64_MAX;
            ut64 dst_addr = UT64_MAX;
            for (j = 0; j < 3; j++) {
                if (aop.src[j]) {
                    if (aop.src[j]->type == RZ_ANALYSIS_VAL_REG) {
                        if (aop.src[j]->reg && aop.src[j]->reg->name) {
                            src_addr = rz_reg_getv(esil->analysis->reg, aop.src[j]->reg->name);
                        }
                        src_imm = 0;
                    } else if (aop.src[j]->type == RZ_ANALYSIS_VAL_MEM) {
                        if (aop.src[j]->reg && aop.src[j]->reg->name) {
                            src_addr = rz_reg_getv(esil->analysis->reg, aop.src[j]->reg->name);
                            if (aop.src[j]->regdelta && aop.src[j]->regdelta->name) {
                                src_addr += rz_reg_getv(esil->analysis->reg, aop.src[j]->regdelta->name) * aop.src[j]->mul;
                            }
                        }
                        src_imm = aop.src[j]->base + aop.src[j]->delta;
                    } else if (aop.src[j]->type == RZ_ANALYSIS_VAL_IMM) {
                        src_addr = aop.src[j]->imm;
                        src_imm = 0;
                    }
                }
            }
            if (aop.dst) {
                if (aop.dst->type == RZ_ANALYSIS_VAL_REG) {
                    if (aop.dst->reg && aop.dst->reg->name) {
                        dst_addr = rz_reg_getv(esil->analysis->reg, aop.dst->reg->name);
                    }
                    dst_imm = 0;
                } else if (aop.dst->type == RZ_ANALYSIS_VAL_MEM) {
                    if (aop.dst->reg && aop.dst->reg->name) {
                        dst_addr = rz_reg_getv(esil->analysis->reg, aop.dst->reg->name);
                        if (aop.dst->regdelta && aop.dst->regdelta->name) {
                            dst_addr += rz_reg_getv(esil->analysis->reg, aop.dst->regdelta->name) * aop.dst->mul;
                        }
                    }
                    dst_imm = aop.dst->base + aop.dst->delta;
                } else if (aop.dst->type == RZ_ANALYSIS_VAL_IMM) {
                    dst_addr = aop.dst->imm;
                    dst_imm = 0;
                }
            }
            RzAnalysisVar *var = rz_analysis_get_used_function_var(core->analysis, aop.addr);
            if (false) { // src_addr != UT64_MAX || dst_addr != UT64_MAX) {
                //  if (src_addr == UT64_MAX && dst_addr == UT64_MAX) {
                rz_analysis_op_fini(&aop);
                continue;
            }
            struct TLAnalysisContext ctx = {
                .aop = &aop,
                .var = var,
                .src_addr = src_addr,
                .dst_addr = dst_addr,
                .src_imm = src_imm,
                .dst_imm = dst_imm
            };
            resolve_type_links(core, at, &ctx, ret, &resolved);
            if (rz_analysis_op_nonlinear(aop.type)) {
                rz_reg_set_value(esil->analysis->reg, pc, at);
                set_retval(core, at - ret);
            } else {
                rz_core_esil_step(core, UT64_MAX, NULL, NULL, false);
            }
            rz_analysis_op_fini(&aop);
        }
    }
beach:
    rz_io_cache_reset(core->io, core->io->cached); // drop cache writes
    rz_config_set_i(core->config, "io.cache", ioCache);
    rz_config_set_i(core->config, "dbg.follow", dbg_follow);
    if (stack_set) {
        rz_core_analysis_esil_init_mem_del(core, NULL, UT64_MAX, UT32_MAX);
    }
    rz_core_seek(core, oldoff, true);
    rz_analysis_esil_free(esil);
    rz_reg_arena_pop(core->analysis->reg);
    rz_core_reg_update_flags(core);
    rz_cons_break_pop();
    free(buf);
}

References addr, rz_analysis_function_t::addr, rz_analysis_op_t::addr, rz_analysis_bb_t::addr, rz_analysis_esil_t::analysis, rz_core_t::analysis, TLAnalysisContext::aop, rz_analysis_value_t::base, bb_cmpaddr(), rz_analysis_function_t::bbs, rz_core_t::blocksize, rz_io_t::cached, rz_core_t::config, rz_core_t::dbg, rz_analysis_value_t::delta, rz_analysis_op_t::dst, TLAnalysisContext::dst_addr, TLAnalysisContext::dst_imm, free(), i, rz_analysis_value_t::imm, rz_core_t::io, malloc(), rz_analysis_value_t::mul, rz_reg_item_t::name, NULL, rz_core_t::offset, pc, rz_analysis_t::reg, rz_analysis_value_t::reg, rz_analysis_value_t::regdelta, resolve_type_links(), rz_analysis_archinfo(), RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE, RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE, rz_analysis_esil_free(), rz_analysis_esil_new(), rz_analysis_esil_setup(), rz_analysis_get_used_function_var(), rz_analysis_op(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_VAL, rz_analysis_op_nonlinear(), RZ_ANALYSIS_VAL_IMM, RZ_ANALYSIS_VAL_MEM, RZ_ANALYSIS_VAL_REG, rz_config_get_i(), rz_config_set_i(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_analysis_esil_init_mem(), rz_core_analysis_esil_init_mem_del(), rz_core_esil_step(), rz_core_get_stacksz(), rz_core_reg_update_flags(), rz_core_seek(), rz_debug_reg_sync(), rz_io_cache_reset(), rz_io_read_at(), rz_list_sort(), RZ_MAX, rz_reg_arena_pop(), rz_reg_arena_push(), rz_reg_arena_zero(), rz_reg_get(), rz_reg_get_name(), rz_reg_getv(), RZ_REG_NAME_PC, RZ_REG_NAME_SP, rz_reg_set_value(), RZ_REG_TYPE_ANY, rz_return_if_fail, set_retval(), rz_analysis_bb_t::size, sp, rz_analysis_op_t::src, TLAnalysisContext::src_addr, TLAnalysisContext::src_imm, to, rz_analysis_value_t::type, rz_analysis_op_t::type, UT32_MAX, ut64(), UT64_MAX, and TLAnalysisContext::var.

Referenced by rz_analyze_function_linked_offsets_handler(), and rz_core_types_link().

rz_core_types_as_c()

RZ_API RZ_OWN char* rz_core_types_as_c	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL const char *	name,
		bool	multiline
	)

Get a type string by name (.

See also

rz_type_db_base_type_as_pretty_string)

Parameters

core	RzCore reference
name	Type name
multiline	Pretty printing with RZ_TYPE_PRINT_MULTILINE

Definition at line 424 of file ctypes.c.

                                                                                                             {
    rz_return_val_if_fail(core && core->analysis, NULL);
 
    RzBaseType *btype = rz_type_db_get_base_type(core->analysis->typedb, name);
    if (!btype) {
        return NULL;
    }
    return rz_core_base_type_as_c(core, btype, multiline);
}

References NULL, rz_core_base_type_as_c(), rz_return_val_if_fail, and rz_type_db_get_base_type().

Referenced by rz_type_list_c_handler(), and rz_type_list_c_nl_handler().

rz_core_types_as_c_all()

RZ_API RZ_OWN char* rz_core_types_as_c_all	(	RZ_NONNULL RzCore *	core,
		bool	multiline
	)

Get all types with pretty printing.

Parameters

core	RzCore reference
multiline	Pretty printing with RZ_TYPE_PRINT_MULTILINE

Definition at line 439 of file ctypes.c.

                                                                                    {
    rz_return_val_if_fail(core && core->analysis, NULL);
 
    RzStrBuf *buf = rz_strbuf_new("");
    // List all unions in the C format with newlines
    char *str = rz_core_types_union_as_c_all(core->analysis->typedb, multiline);
    if (str) {
        rz_strbuf_append(buf, str);
        free(str);
    }
    // List all structures in the C format with newlines
    str = rz_core_types_struct_as_c_all(core->analysis->typedb, multiline);
    if (str) {
        rz_strbuf_append(buf, str);
        free(str);
    }
    // List all typedefs in the C format with newlines
    str = rz_core_types_typedef_as_c_all(core->analysis->typedb);
    if (str) {
        rz_strbuf_append(buf, str);
        free(str);
    }
    // List all enums in the C format with newlines
    str = rz_core_types_enum_as_c_all(core->analysis->typedb, multiline);
    if (str) {
        rz_strbuf_append(buf, str);
        free(str);
    }
    return rz_strbuf_drain(buf);
}

References free(), NULL, rz_core_types_enum_as_c_all(), rz_core_types_struct_as_c_all(), rz_core_types_typedef_as_c_all(), rz_core_types_union_as_c_all(), rz_return_val_if_fail, rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), and cmd_descs_generate::str.

Referenced by type_list_c_all(), and type_list_c_all_nl().

rz_core_types_calling_conventions_print()

RZ_IPI void rz_core_types_calling_conventions_print	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 19 of file ctypes.c.

                                                                                     {
    RzList *list = rz_analysis_calling_conventions(core->analysis);
    RzListIter *iter;
    const char *cc;
    switch (mode) {
    case RZ_OUTPUT_MODE_STANDARD: {
        rz_list_foreach (list, iter, cc) {
            rz_cons_println(cc);
        }
    } break;
    case RZ_OUTPUT_MODE_JSON: {
        PJ *pj = pj_new();
        pj_a(pj);
        rz_list_foreach (list, iter, cc) {
            rz_core_analysis_cc_print(core, cc, pj);
        }
        pj_end(pj);
        rz_cons_printf("%s\n", pj_string(pj));
        pj_free(pj);
    } break;
    case RZ_OUTPUT_MODE_LONG: {
        rz_list_foreach (list, iter, cc) {
            char *ccexpr = rz_analysis_cc_get(core->analysis, cc);
            rz_cons_printf("%s\n", ccexpr);
            free(ccexpr);
        }
    } break;
    case RZ_OUTPUT_MODE_RIZIN: {
        rz_list_foreach (list, iter, cc) {
            char *ccexpr = rz_analysis_cc_get(core->analysis, cc);
            rz_cons_printf("tcc \"%s\"\n", ccexpr);
            free(ccexpr);
        }
    } break;
    case RZ_OUTPUT_MODE_SDB:
        rz_core_kuery_print(core, "analysis/cc/*");
        break;
    default:
        rz_warn_if_reached();
        break;
    }
    rz_list_free(list);
}

References rz_core_t::analysis, free(), list(), pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), rz_analysis_calling_conventions(), rz_analysis_cc_get(), rz_cons_printf(), rz_cons_println(), rz_core_analysis_cc_print(), rz_core_kuery_print(), rz_list_free(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_SDB, RZ_OUTPUT_MODE_STANDARD, and rz_warn_if_reached.

Referenced by cb_analysiscc(), cb_analysissyscc(), rz_analysis_function_cc_list_handler(), and rz_type_cc_list_handler().

rz_core_types_enum_as_c()

RZ_IPI RZ_OWN char* rz_core_types_enum_as_c	(	RzTypeDB *	typedb,
		const RzBaseType *	btype,
		bool	multiline
	)

Definition at line 123 of file ctypes.c.

                                                                                                       {
    rz_return_val_if_fail(btype, NULL);
    rz_return_val_if_fail(btype->kind == RZ_BASE_TYPE_KIND_ENUM, NULL);
 
    unsigned int multiline_opt = 0;
    if (multiline) {
        multiline_opt = RZ_TYPE_PRINT_MULTILINE;
    }
    return rz_type_db_base_type_as_pretty_string(typedb, btype, multiline_opt | RZ_TYPE_PRINT_END_NEWLINE | RZ_TYPE_PRINT_ANONYMOUS, 1);
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_ENUM, rz_return_val_if_fail, rz_type_db_base_type_as_pretty_string(), RZ_TYPE_PRINT_ANONYMOUS, RZ_TYPE_PRINT_END_NEWLINE, and RZ_TYPE_PRINT_MULTILINE.

Referenced by rz_core_types_enum_as_c_all(), rz_type_enum_c_handler(), and rz_type_enum_c_nl_handler().

rz_core_types_enum_as_c_all()

RZ_IPI RZ_OWN char* rz_core_types_enum_as_c_all	(	RzTypeDB *	typedb,
		bool	multiline
	)

Definition at line 134 of file ctypes.c.

                                                                                  {
    RzList *enumlist = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_ENUM);
    RzListIter *it;
    RzBaseType *btype;
    RzStrBuf *buf = rz_strbuf_new("");
    rz_list_foreach (enumlist, it, btype) {
        char *str = rz_core_types_enum_as_c(typedb, btype, multiline);
        if (str) {
            rz_strbuf_append(buf, str);
        }
        free(str);
    }
    rz_list_free(enumlist);
    return rz_strbuf_drain(buf);
}

References free(), RZ_BASE_TYPE_KIND_ENUM, rz_core_types_enum_as_c(), rz_list_free(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), rz_type_db_get_base_types_of_kind(), and cmd_descs_generate::str.

Referenced by rz_core_types_as_c_all(), rz_type_enum_c_handler(), and rz_type_enum_c_nl_handler().

rz_core_types_enum_print()

RZ_IPI void rz_core_types_enum_print	(	RzCore *	core,
		const RzBaseType *	btype,
		RzOutputMode	mode,
		PJ *	pj
	)

Definition at line 65 of file ctypes.c.

                                                                                                       {
    rz_return_if_fail(core && btype);
    rz_return_if_fail(btype->kind == RZ_BASE_TYPE_KIND_ENUM);
 
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON: {
        rz_return_if_fail(pj);
        pj_o(pj);
        if (btype && !rz_vector_empty(&btype->enum_data.cases)) {
            pj_ks(pj, "name", btype->name);
            pj_k(pj, "values");
            pj_o(pj);
            RzTypeEnumCase *cas;
            rz_vector_foreach(&btype->enum_data.cases, cas) {
                pj_kn(pj, cas->name, cas->val);
            }
            pj_end(pj);
        }
        pj_end(pj);
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD: {
        if (btype && !rz_vector_empty(&btype->enum_data.cases)) {
            RzTypeEnumCase *cas;
            rz_vector_foreach(&btype->enum_data.cases, cas) {
                rz_cons_printf("%s = 0x%" PFMT64x "\n", cas->name, cas->val);
            }
        }
        break;
    }
    case RZ_OUTPUT_MODE_QUIET:
        rz_cons_println(btype->name);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
}

References rz_base_type_enum_t::cases, rz_base_type_t::enum_data, rz_base_type_t::kind, rz_type_enum_case_t::name, rz_base_type_t::name, PFMT64x, pj_end(), pj_k(), pj_kn(), pj_ks(), pj_o(), RZ_BASE_TYPE_KIND_ENUM, rz_cons_printf(), rz_cons_println(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, rz_return_if_fail, rz_vector_empty(), rz_vector_foreach, rz_warn_if_reached, and rz_type_enum_case_t::val.

Referenced by rz_core_types_enum_print_all(), and rz_type_list_enum_handler().

rz_core_types_enum_print_all()

RZ_IPI void rz_core_types_enum_print_all	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 104 of file ctypes.c.

                                                                          {
    RzList *enumlist = rz_type_db_get_base_types_of_kind(core->analysis->typedb, RZ_BASE_TYPE_KIND_ENUM);
    RzListIter *it;
    PJ *pj = (mode == RZ_OUTPUT_MODE_JSON) ? pj_new() : NULL;
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_a(pj);
    }
    RzBaseType *btype;
    rz_list_foreach (enumlist, it, btype) {
        rz_core_types_enum_print(core, btype, mode, pj);
    }
    rz_list_free(enumlist);
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
    }
}

References rz_core_t::analysis, NULL, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), RZ_BASE_TYPE_KIND_ENUM, rz_cons_println(), rz_core_types_enum_print(), rz_list_free(), RZ_OUTPUT_MODE_JSON, rz_type_db_get_base_types_of_kind(), and rz_analysis_t::typedb.

Referenced by rz_type_list_enum_handler().

rz_core_types_function_noreturn_print()

RZ_IPI void rz_core_types_function_noreturn_print	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 553 of file ctypes.c.

                                                                                   {
    RzList *noretl = rz_type_noreturn_function_names(core->analysis->typedb);
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON:
        nonreturn_print_json(core, noretl);
        break;
    default:
        nonreturn_print(core, noretl);
        break;
    }
    rz_list_free(noretl);
}

References rz_core_t::analysis, nonreturn_print(), nonreturn_print_json(), rz_list_free(), RZ_OUTPUT_MODE_JSON, rz_type_noreturn_function_names(), and rz_analysis_t::typedb.

Referenced by rz_type_list_noreturn_handler().

rz_core_types_function_print()

RZ_IPI void rz_core_types_function_print	(	RzTypeDB *	typedb,
		const char *	function,
		RzOutputMode	mode,
		PJ *	pj
	)

Definition at line 472 of file ctypes.c.

                                                                                                            {
    rz_return_if_fail(function);
    RzCallable *callable = rz_type_func_get(typedb, function);
    if (!callable) {
        return;
    }
    char *ret = callable->ret ? rz_type_as_string(typedb, callable->ret) : NULL;
    void **it;
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON: {
        rz_return_if_fail(pj);
        pj_o(pj);
        pj_ks(pj, "name", function);
        pj_ks(pj, "ret", ret);
        pj_k(pj, "args");
        pj_a(pj);
        rz_pvector_foreach (callable->args, it) {
            RzCallableArg *arg = (RzCallableArg *)*it;
            char *typestr = rz_type_as_string(typedb, arg->type);
            pj_o(pj);
            pj_ks(pj, "type", rz_str_get_null(typestr));
            pj_ks(pj, "name", rz_str_get_null(arg->name));
            pj_end(pj);
            free(typestr);
        }
        pj_end(pj);
        pj_end(pj);
    } break;
    default: {
        char *str = rz_type_callable_as_string(typedb, callable);
        rz_cons_printf("%s;\n", str);
        free(str);
    } break;
    }
    free(ret);
}

References rz_callable_at::args, free(), arg::name, NULL, pj_a(), pj_end(), pj_k(), pj_ks(), pj_o(), rz_callable_at::ret, rz_cons_printf(), RZ_OUTPUT_MODE_JSON, rz_pvector_foreach, rz_return_if_fail, rz_str_get_null(), rz_type_as_string(), rz_type_callable_as_string(), rz_type_func_get(), and cmd_descs_generate::str.

Referenced by rz_core_types_function_print_all(), and rz_type_list_function_handler().

rz_core_types_function_print_all()

RZ_IPI void rz_core_types_function_print_all	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 509 of file ctypes.c.

                                                                              {
    PJ *pj = (mode == RZ_OUTPUT_MODE_JSON) ? pj_new() : NULL;
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_a(pj);
    }
    RzList *l = rz_type_function_names(core->analysis->typedb);
    RzListIter *iter;
    char *name;
    rz_list_foreach (l, iter, name) {
        rz_core_types_function_print(core->analysis->typedb, name, mode, pj);
    }
    rz_list_free(l);
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
    }
}

References rz_core_t::analysis, name, NULL, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), rz_cons_println(), rz_core_types_function_print(), rz_list_free(), RZ_OUTPUT_MODE_JSON, rz_type_function_names(), and rz_analysis_t::typedb.

Referenced by rz_type_list_function_handler().

rz_core_types_link()

RZ_API void rz_core_types_link	(	RzCore *	core,
		const char *	typestr,
		ut64	addr
	)

Link an address addr to the type referenced by typestr.

NOTE: This is likely going to be deprecated with the use of global variables.

Parameters

core	RzCore reference
typestr	Name of the type that should be defined at addr
addr	Address where the type should be used

Definition at line 954 of file ctypes.c.

                                                                             {
    char *error_msg = NULL;
    RzType *type = rz_type_parse_string_single(core->analysis->typedb->parser, typestr, &error_msg);
    if (!type || error_msg) {
        if (error_msg) {
            eprintf("%s", error_msg);
        }
        free(error_msg);
        return;
    }
    rz_analysis_type_set_link(core->analysis, type, addr);
    RzList *fcns = rz_analysis_get_functions_in(core->analysis, core->offset);
    if (rz_list_length(fcns) > 1) {
        eprintf("Multiple functions found in here.\n");
    } else if (rz_list_length(fcns) == 1) {
        RzAnalysisFunction *fcn = rz_list_first(fcns);
        rz_core_link_stroff(core, fcn);
    }
    rz_list_free(fcns);
}

References addr, rz_core_t::analysis, coremodepj::core, eprintf, free(), NULL, rz_core_t::offset, rz_type_db_t::parser, rz_analysis_get_functions_in(), rz_analysis_type_set_link(), rz_core_link_stroff(), rz_list_first(), rz_list_free(), rz_list_length(), rz_type_parse_string_single(), type, and rz_analysis_t::typedb.

Referenced by rz_type_link_handler().

rz_core_types_link_print()

RZ_IPI void rz_core_types_link_print	(	RzCore *	core,
		RzType *	type,
		ut64	addr,
		RzOutputMode	mode,
		PJ *	pj
	)

Definition at line 879 of file ctypes.c.

                                                                                                       {
    rz_return_if_fail(type);
    char *typestr = rz_type_as_string(core->analysis->typedb, type);
    if (!typestr) {
        return;
    }
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON: {
        rz_return_if_fail(pj);
        pj_o(pj);
        char *saddr = rz_str_newf("0x%08" PFMT64x, addr);
        pj_ks(pj, saddr, typestr);
        pj_end(pj);
        free(saddr);
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD:
        rz_cons_printf("0x%08" PFMT64x " = %s\n", addr, typestr);
        break;
    case RZ_OUTPUT_MODE_RIZIN:
        rz_cons_printf("tl \"%s\" 0x%" PFMT64x "\n", typestr, addr);
        break;
    case RZ_OUTPUT_MODE_LONG: {
        char *fmt = rz_type_as_format(core->analysis->typedb, type);
        if (!fmt) {
            eprintf("Can't fint type %s", typestr);
        }
        rz_cons_printf("(%s)\n", typestr);
        rz_core_cmdf(core, "pf %s @ 0x%" PFMT64x "\n", fmt, addr);
        free(fmt);
        break;
    }
    default:
        rz_warn_if_reached();
        break;
    }
    free(typestr);
}

References addr, rz_core_t::analysis, eprintf, free(), PFMT64x, pj_end(), pj_ks(), pj_o(), rz_cons_printf(), rz_core_cmdf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_return_if_fail, rz_str_newf(), rz_type_as_format(), rz_type_as_string(), rz_warn_if_reached, type, and rz_analysis_t::typedb.

Referenced by rz_core_types_link_show(), and typelink_print_cb().

rz_core_types_link_print_all()

RZ_IPI void rz_core_types_link_print_all	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 931 of file ctypes.c.

                                                                          {
    PJ *pj = (mode == RZ_OUTPUT_MODE_JSON) ? pj_new() : NULL;
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_a(pj);
    }
    struct coremodepj c = { core, mode, pj };
    ht_up_foreach(core->analysis->type_links, typelink_print_cb, &c);
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
    }
}

References rz_core_t::analysis, c, coremodepj::core, NULL, coremodepj::pj, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), rz_cons_println(), RZ_OUTPUT_MODE_JSON, rz_analysis_t::type_links, and typelink_print_cb().

Referenced by rz_type_link_handler().

rz_core_types_link_show()

RZ_IPI void rz_core_types_link_show	(	RzCore *	core,
		ut64	addr
	)

Definition at line 975 of file ctypes.c.

                                                             {
    RzType *link = rz_analysis_type_link_at(core->analysis, addr);
    if (link) {
        rz_core_types_link_print(core, link, addr, RZ_OUTPUT_MODE_LONG, NULL);
    }
}

References addr, rz_core_t::analysis, coremodepj::core, link, NULL, rz_analysis_type_link_at(), rz_core_types_link_print(), and RZ_OUTPUT_MODE_LONG.

Referenced by rz_type_link_show_handler().

rz_core_types_print_all()

RZ_IPI void rz_core_types_print_all	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 984 of file ctypes.c.

                                                                     {
    RzListIter *it;
    RzBaseType *btype;
    RzList *types = rz_type_db_get_base_types(core->analysis->typedb);
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON: {
        PJ *pj = pj_new();
        if (!pj) {
            return;
        }
        pj_a(pj);
        rz_list_foreach (types, it, btype) {
            pj_o(pj);
            // rz_str_trim(format_s);
            pj_ks(pj, "type", btype->name);
            pj_ki(pj, "size", btype->size);
            // pj_ks(pj, "format", format_s);
            pj_end(pj);
        }
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD:
        rz_list_foreach (types, it, btype) {
            rz_cons_println(btype->name);
        }
        break;
    case RZ_OUTPUT_MODE_RIZIN:
        rz_list_foreach (types, it, btype) {
            char *fmt = rz_type_format(core->analysis->typedb, btype->name);
            if (fmt) {
                rz_cons_printf("pf.%s %s\n", btype->name, fmt);
                free(fmt);
            }
        }
        break;
    default:
        rz_warn_if_reached();
        break;
    }
    rz_list_free(types);
}

References rz_core_t::analysis, coremodepj::core, free(), rz_base_type_t::name, coremodepj::pj, pj_a(), pj_end(), pj_free(), pj_ki(), pj_ks(), pj_new(), pj_o(), pj_string(), rz_cons_printf(), rz_cons_println(), rz_list_free(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_type_db_get_base_types(), rz_type_format(), rz_warn_if_reached, rz_base_type_t::size, rz_analysis_t::typedb, and types.

Referenced by rz_type_handler().

rz_core_types_show_format()

RZ_IPI void rz_core_types_show_format	(	RzCore *	core,
		const char *	name,
		RzOutputMode	mode
	)

Definition at line 568 of file ctypes.c.

                                                                                         {
    char *fmt = rz_type_format(core->analysis->typedb, name);
    if (fmt) {
        switch (mode) {
        case RZ_OUTPUT_MODE_JSON: {
            PJ *pj = pj_new();
            if (!pj) {
                free(fmt);
                return;
            }
            pj_o(pj);
            pj_ks(pj, "name", name);
            pj_ks(pj, "format", fmt);
            pj_end(pj);
            rz_cons_printf("%s", pj_string(pj));
            pj_free(pj);
        } break;
        case RZ_OUTPUT_MODE_RIZIN: {
            rz_cons_printf("pf.%s %s\n", name, fmt);
        } break;
        case RZ_OUTPUT_MODE_STANDARD: {
            // FIXME: Not really a standard format
            // We should think about better representation by default here
            rz_cons_printf("pf %s\n", fmt);
        } break;
        default:
            break;
        }
        free(fmt);
    } else {
        eprintf("Cannot find '%s' type\n", name);
    }
}

References rz_core_t::analysis, eprintf, free(), pj_end(), pj_free(), pj_ks(), pj_new(), pj_o(), pj_string(), rz_cons_printf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_type_format(), and rz_analysis_t::typedb.

Referenced by rz_core_types_struct_print_format_all(), rz_core_types_union_print_format_all(), rz_type_handler(), rz_type_list_structure_handler(), and rz_type_list_union_handler().

rz_core_types_struct_as_c()

RZ_IPI RZ_OWN char* rz_core_types_struct_as_c	(	RzTypeDB *	typedb,
		const RzBaseType *	btype,
		bool	multiline
	)

Definition at line 312 of file ctypes.c.

                                                                                                         {
    rz_return_val_if_fail(btype, NULL);
    rz_return_val_if_fail(btype->kind == RZ_BASE_TYPE_KIND_STRUCT, NULL);
 
    unsigned int multiline_opt = multiline ? RZ_TYPE_PRINT_MULTILINE : 0;
    return rz_type_db_base_type_as_pretty_string(typedb, btype, multiline_opt | RZ_TYPE_PRINT_END_NEWLINE | RZ_TYPE_PRINT_ANONYMOUS, 1);
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_STRUCT, rz_return_val_if_fail, rz_type_db_base_type_as_pretty_string(), RZ_TYPE_PRINT_ANONYMOUS, RZ_TYPE_PRINT_END_NEWLINE, and RZ_TYPE_PRINT_MULTILINE.

Referenced by rz_core_types_struct_as_c_all(), rz_type_structure_c_handler(), and rz_type_structure_c_nl_handler().

rz_core_types_struct_as_c_all()

RZ_IPI RZ_OWN char* rz_core_types_struct_as_c_all	(	RzTypeDB *	typedb,
		bool	multiline
	)

Definition at line 320 of file ctypes.c.

                                                                                    {
    RzList *structlist = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_STRUCT);
    RzListIter *it;
    RzBaseType *btype;
    RzStrBuf *buf = rz_strbuf_new("");
    rz_list_foreach (structlist, it, btype) {
        char *str = rz_core_types_struct_as_c(typedb, btype, multiline);
        if (str) {
            rz_strbuf_append(buf, str);
        }
        free(str);
    }
    rz_list_free(structlist);
    return rz_strbuf_drain(buf);
}

References free(), RZ_BASE_TYPE_KIND_STRUCT, rz_core_types_struct_as_c(), rz_list_free(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), rz_type_db_get_base_types_of_kind(), and cmd_descs_generate::str.

Referenced by rz_core_types_as_c_all(), rz_type_structure_c_handler(), and rz_type_structure_c_nl_handler().

rz_core_types_struct_print()

RZ_IPI void rz_core_types_struct_print	(	RzCore *	core,
		const RzBaseType *	btype,
		RzOutputMode	mode,
		PJ *	pj
	)

Definition at line 246 of file ctypes.c.

                                                                                                         {
    rz_return_if_fail(core && btype);
    rz_return_if_fail(btype->kind == RZ_BASE_TYPE_KIND_STRUCT);
 
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON: {
        rz_return_if_fail(pj);
        pj_o(pj);
        pj_ks(pj, "name", btype->name);
        pj_k(pj, "members");
        pj_o(pj);
        RzTypeStructMember *memb;
        rz_vector_foreach(&btype->struct_data.members, memb) {
            char *mtype = rz_type_as_string(core->analysis->typedb, memb->type);
            pj_ks(pj, memb->name, mtype);
            free(mtype);
        }
        pj_end(pj);
        pj_end(pj);
        break;
    }
    case RZ_OUTPUT_MODE_LONG: {
        rz_cons_printf("struct %s:\n", btype->name);
        if (btype && !rz_vector_empty(&btype->union_data.members)) {
            RzTypeStructMember *memb;
            ut64 offset = 0;
            rz_vector_foreach(&btype->struct_data.members, memb) {
                char *mtype = rz_type_as_string(core->analysis->typedb, memb->type);
                ut64 size = rz_type_db_get_bitsize(core->analysis->typedb, memb->type) / 8;
                rz_cons_printf("\t%s: %s (size = %" PFMT64d ", offset = %" PFMT64d ")\n",
                    memb->name, mtype, size, offset);
                offset += size;
                free(mtype);
            }
        }
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD:
    case RZ_OUTPUT_MODE_QUIET:
        rz_cons_println(btype->name);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
}

References rz_core_t::analysis, free(), rz_base_type_t::kind, rz_base_type_struct_t::members, rz_base_type_union_t::members, rz_type_struct_member_t::name, rz_base_type_t::name, PFMT64d, pj_end(), pj_k(), pj_ks(), pj_o(), RZ_BASE_TYPE_KIND_STRUCT, rz_cons_printf(), rz_cons_println(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, rz_return_if_fail, rz_type_as_string(), rz_type_db_get_bitsize(), rz_vector_empty(), rz_vector_foreach, rz_warn_if_reached, rz_base_type_t::struct_data, rz_type_struct_member_t::type, rz_analysis_t::typedb, rz_base_type_t::union_data, and ut64().

Referenced by rz_core_types_struct_print_all(), and rz_type_list_structure_handler().

rz_core_types_struct_print_all()

RZ_IPI void rz_core_types_struct_print_all	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 293 of file ctypes.c.

                                                                            {
    RzList *structlist = rz_type_db_get_base_types_of_kind(core->analysis->typedb, RZ_BASE_TYPE_KIND_STRUCT);
    RzListIter *it;
    PJ *pj = (mode == RZ_OUTPUT_MODE_JSON) ? pj_new() : NULL;
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_a(pj);
    }
    RzBaseType *btype;
    rz_list_foreach (structlist, it, btype) {
        rz_core_types_struct_print(core, btype, mode, pj);
    }
    rz_list_free(structlist);
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
    }
}

References rz_core_t::analysis, NULL, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), RZ_BASE_TYPE_KIND_STRUCT, rz_cons_println(), rz_core_types_struct_print(), rz_list_free(), RZ_OUTPUT_MODE_JSON, rz_type_db_get_base_types_of_kind(), and rz_analysis_t::typedb.

Referenced by rz_type_list_structure_handler().

rz_core_types_struct_print_format_all()

RZ_IPI void rz_core_types_struct_print_format_all

(

RzCore *

core

)

Definition at line 602 of file ctypes.c.

                                                                {
    RzTypeDB *typedb = core->analysis->typedb;
    RzList *structlist = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_STRUCT);
    RzListIter *it;
    RzBaseType *btype;
    rz_list_foreach (structlist, it, btype) {
        rz_core_types_show_format(core, btype->name, RZ_OUTPUT_MODE_RIZIN);
    }
    rz_list_free(structlist);
}

References rz_core_t::analysis, rz_base_type_t::name, RZ_BASE_TYPE_KIND_STRUCT, rz_core_types_show_format(), rz_list_free(), RZ_OUTPUT_MODE_RIZIN, rz_type_db_get_base_types_of_kind(), and rz_analysis_t::typedb.

Referenced by rz_type_list_structure_handler().

rz_core_types_typedef_as_c()

RZ_IPI RZ_OWN char* rz_core_types_typedef_as_c	(	RzTypeDB *	typedb,
		const RzBaseType *	btype
	)

Definition at line 385 of file ctypes.c.

                                                                                          {
    rz_return_val_if_fail(btype, NULL);
    rz_return_val_if_fail(btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF, NULL);
 
    return rz_type_db_base_type_as_pretty_string(typedb, btype, RZ_TYPE_PRINT_END_NEWLINE | RZ_TYPE_PRINT_SHOW_TYPEDEF, 1);
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_TYPEDEF, rz_return_val_if_fail, rz_type_db_base_type_as_pretty_string(), RZ_TYPE_PRINT_END_NEWLINE, and RZ_TYPE_PRINT_SHOW_TYPEDEF.

Referenced by rz_core_types_typedef_as_c_all(), and rz_type_typedef_c_handler().

rz_core_types_typedef_as_c_all()

RZ_IPI RZ_OWN char* rz_core_types_typedef_as_c_all

(

RzTypeDB *

typedb

)

Definition at line 392 of file ctypes.c.

                                                                     {
    RzList *typedeflist = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_TYPEDEF);
    RzListIter *it;
    RzBaseType *btype;
    RzStrBuf *buf = rz_strbuf_new("");
    rz_list_foreach (typedeflist, it, btype) {
        char *str = rz_core_types_typedef_as_c(typedb, btype);
        if (str) {
            rz_strbuf_append(buf, str);
        }
        free(str);
    }
    rz_list_free(typedeflist);
    return rz_strbuf_drain(buf);
}

References free(), RZ_BASE_TYPE_KIND_TYPEDEF, rz_core_types_typedef_as_c(), rz_list_free(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), rz_type_db_get_base_types_of_kind(), and cmd_descs_generate::str.

Referenced by rz_core_types_as_c_all(), and rz_type_typedef_c_handler().

rz_core_types_typedef_print()

RZ_IPI void rz_core_types_typedef_print	(	RzCore *	core,
		const RzBaseType *	btype,
		RzOutputMode	mode,
		PJ *	pj
	)

Definition at line 338 of file ctypes.c.

                                                                                                          {
    rz_return_if_fail(core && btype);
    rz_return_if_fail(btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF);
 
    char *typestr = rz_type_as_string(core->analysis->typedb, btype->type);
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON: {
        rz_return_if_fail(pj);
        pj_o(pj);
        pj_ks(pj, "name", btype->name);
        pj_ks(pj, "type", typestr);
        pj_end(pj);
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD: {
        rz_cons_printf("%s = %s\n", btype->name, typestr);
        break;
    }
    case RZ_OUTPUT_MODE_QUIET:
        rz_cons_println(btype->name);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
    free(typestr);
}

References rz_core_t::analysis, free(), rz_base_type_t::kind, rz_base_type_t::name, pj_end(), pj_ks(), pj_o(), RZ_BASE_TYPE_KIND_TYPEDEF, rz_cons_printf(), rz_cons_println(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, rz_return_if_fail, rz_type_as_string(), rz_warn_if_reached, rz_base_type_t::type, and rz_analysis_t::typedb.

Referenced by rz_core_types_typedef_print_all(), and rz_type_list_typedef_handler().

rz_core_types_typedef_print_all()

RZ_IPI void rz_core_types_typedef_print_all	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 366 of file ctypes.c.

                                                                             {
    RzList *typedeflist = rz_type_db_get_base_types_of_kind(core->analysis->typedb, RZ_BASE_TYPE_KIND_TYPEDEF);
    RzListIter *it;
    PJ *pj = (mode == RZ_OUTPUT_MODE_JSON) ? pj_new() : NULL;
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_a(pj);
    }
    RzBaseType *btype;
    rz_list_foreach (typedeflist, it, btype) {
        rz_core_types_typedef_print(core, btype, mode, pj);
    }
    rz_list_free(typedeflist);
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
    }
}

References rz_core_t::analysis, NULL, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), RZ_BASE_TYPE_KIND_TYPEDEF, rz_cons_println(), rz_core_types_typedef_print(), rz_list_free(), RZ_OUTPUT_MODE_JSON, rz_type_db_get_base_types_of_kind(), and rz_analysis_t::typedb.

Referenced by rz_type_list_typedef_handler().

rz_core_types_union_as_c()

RZ_IPI RZ_OWN char* rz_core_types_union_as_c	(	RzTypeDB *	typedb,
		const RzBaseType *	btype,
		bool	multiline
	)

Definition at line 217 of file ctypes.c.

                                                                                                        {
    rz_return_val_if_fail(btype, NULL);
    rz_return_val_if_fail(btype->kind == RZ_BASE_TYPE_KIND_UNION, NULL);
 
    unsigned int multiline_opt = 0;
    if (multiline) {
        multiline_opt = RZ_TYPE_PRINT_MULTILINE;
    }
    return rz_type_db_base_type_as_pretty_string(typedb, btype, multiline_opt | RZ_TYPE_PRINT_END_NEWLINE | RZ_TYPE_PRINT_ANONYMOUS, 1);
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_UNION, rz_return_val_if_fail, rz_type_db_base_type_as_pretty_string(), RZ_TYPE_PRINT_ANONYMOUS, RZ_TYPE_PRINT_END_NEWLINE, and RZ_TYPE_PRINT_MULTILINE.

Referenced by rz_core_types_union_as_c_all(), rz_type_union_c_handler(), and rz_type_union_c_nl_handler().

rz_core_types_union_as_c_all()

RZ_IPI RZ_OWN char* rz_core_types_union_as_c_all	(	RzTypeDB *	typedb,
		bool	multiline
	)

Definition at line 228 of file ctypes.c.

                                                                                   {
    RzList *unionlist = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_UNION);
    RzListIter *it;
    RzBaseType *btype;
    RzStrBuf *buf = rz_strbuf_new("");
    rz_list_foreach (unionlist, it, btype) {
        char *str = rz_core_types_union_as_c(typedb, btype, multiline);
        if (str) {
            rz_strbuf_append(buf, str);
        }
        free(str);
    }
    rz_list_free(unionlist);
    return rz_strbuf_drain(buf);
}

References free(), RZ_BASE_TYPE_KIND_UNION, rz_core_types_union_as_c(), rz_list_free(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), rz_type_db_get_base_types_of_kind(), and cmd_descs_generate::str.

Referenced by rz_core_types_as_c_all(), rz_type_union_c_handler(), and rz_type_union_c_nl_handler().

rz_core_types_union_print()

RZ_IPI void rz_core_types_union_print	(	RzCore *	core,
		const RzBaseType *	btype,
		RzOutputMode	mode,
		PJ *	pj
	)

Definition at line 152 of file ctypes.c.

                                                                                                        {
    rz_return_if_fail(core && btype);
    rz_return_if_fail(btype->kind == RZ_BASE_TYPE_KIND_UNION);
 
    switch (mode) {
    case RZ_OUTPUT_MODE_JSON: {
        rz_return_if_fail(pj);
        pj_o(pj);
        if (btype && !rz_vector_empty(&btype->union_data.members)) {
            pj_ks(pj, "name", btype->name);
            pj_k(pj, "members");
            pj_o(pj);
            RzTypeUnionMember *memb;
            rz_vector_foreach(&btype->union_data.members, memb) {
                char *mtype = rz_type_as_string(core->analysis->typedb, memb->type);
                pj_ks(pj, memb->name, mtype);
                free(mtype);
            }
            pj_end(pj);
        }
        pj_end(pj);
        break;
    }
    case RZ_OUTPUT_MODE_LONG: {
        rz_cons_printf("union %s:\n", btype->name);
        if (btype && !rz_vector_empty(&btype->union_data.members)) {
            RzTypeUnionMember *memb;
            rz_vector_foreach(&btype->union_data.members, memb) {
                char *mtype = rz_type_as_string(core->analysis->typedb, memb->type);
                ut64 size = rz_type_db_get_bitsize(core->analysis->typedb, memb->type) / 8;
                rz_cons_printf("\t%s: %s (size = %" PFMT64d ")\n", memb->name, mtype, size);
                free(mtype);
            }
        }
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD:
    case RZ_OUTPUT_MODE_QUIET:
        rz_cons_println(btype->name);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
}

References rz_core_t::analysis, free(), rz_base_type_t::kind, rz_base_type_union_t::members, rz_type_union_member_t::name, rz_base_type_t::name, PFMT64d, pj_end(), pj_k(), pj_ks(), pj_o(), RZ_BASE_TYPE_KIND_UNION, rz_cons_printf(), rz_cons_println(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, rz_return_if_fail, rz_type_as_string(), rz_type_db_get_bitsize(), rz_vector_empty(), rz_vector_foreach, rz_warn_if_reached, rz_type_union_member_t::type, rz_analysis_t::typedb, rz_base_type_t::union_data, and ut64().

Referenced by rz_core_types_union_print_all(), and rz_type_list_union_handler().

rz_core_types_union_print_all()

RZ_IPI void rz_core_types_union_print_all	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 198 of file ctypes.c.

                                                                           {
    RzList *unionlist = rz_type_db_get_base_types_of_kind(core->analysis->typedb, RZ_BASE_TYPE_KIND_UNION);
    RzListIter *it;
    PJ *pj = (mode == RZ_OUTPUT_MODE_JSON) ? pj_new() : NULL;
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_a(pj);
    }
    RzBaseType *btype;
    rz_list_foreach (unionlist, it, btype) {
        rz_core_types_union_print(core, btype, mode, pj);
    }
    rz_list_free(unionlist);
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
    }
}

References rz_core_t::analysis, NULL, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), RZ_BASE_TYPE_KIND_UNION, rz_cons_println(), rz_core_types_union_print(), rz_list_free(), RZ_OUTPUT_MODE_JSON, rz_type_db_get_base_types_of_kind(), and rz_analysis_t::typedb.

Referenced by rz_type_list_union_handler().

rz_core_types_union_print_format_all()

RZ_IPI void rz_core_types_union_print_format_all

(

RzCore *

core

)

Definition at line 613 of file ctypes.c.

                                                               {
    RzTypeDB *typedb = core->analysis->typedb;
    RzList *unionlist = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_UNION);
    RzListIter *it;
    RzBaseType *btype;
    rz_list_foreach (unionlist, it, btype) {
        rz_core_types_show_format(core, btype->name, RZ_OUTPUT_MODE_RIZIN);
    }
    rz_list_free(unionlist);
}

References rz_core_t::analysis, rz_base_type_t::name, RZ_BASE_TYPE_KIND_UNION, rz_core_types_show_format(), rz_list_free(), RZ_OUTPUT_MODE_RIZIN, rz_type_db_get_base_types_of_kind(), and rz_analysis_t::typedb.

Referenced by rz_type_list_union_handler().

rz_types_define()

RZ_IPI void rz_types_define	(	RzCore *	core,
		const char *	type
	)

Definition at line 1029 of file ctypes.c.

                                                            {
    // Add trailing semicolon to force the valid C syntax
    // It allows us to skip the trailing semicolon in the input
    // to reduce the unnecessary typing
    char *tmp = rz_str_newf("%s;", type);
    if (!tmp) {
        return;
    }
    char *error_msg = NULL;
    RzTypeDB *typedb = core->analysis->typedb;
    int result = rz_type_parse_string_stateless(typedb->parser, tmp, &error_msg);
    if (result && error_msg) {
        eprintf("%s", error_msg);
        free(error_msg);
    }
}

References rz_core_t::analysis, coremodepj::core, eprintf, free(), NULL, rz_type_db_t::parser, rz_str_newf(), rz_type_parse_string_stateless(), autogen_x86imm::tmp, type, and rz_analysis_t::typedb.

Referenced by rz_type_define_handler().

rz_types_open_editor()

RZ_IPI bool rz_types_open_editor	(	RzCore *	core,
		RZ_NONNULL const char *	name
	)

Definition at line 1075 of file ctypes.c.

                                                                            {
    rz_return_val_if_fail(name, false);
    RzTypeDB *typedb = core->analysis->typedb;
    RzBaseType *t = rz_type_db_get_compound_type(typedb, name);
    if (!t) {
        return false;
    }
    char *str = rz_core_base_type_as_c(core, t, true);
    if (!str) {
        RZ_LOG_ERROR("Cannot generate C representation of type \"%s\"\n", name);
        return false;
    }
    bool result = false;
    char *tmp = rz_core_editor(core, NULL, str);
    if (tmp) {
        result = rz_type_db_edit_base_type(typedb, t->name, tmp);
        free(tmp);
    }
    free(str);
    return result;
}

References rz_core_t::analysis, coremodepj::core, free(), rz_base_type_t::name, NULL, rz_core_base_type_as_c(), rz_core_editor(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_type_db_edit_base_type(), rz_type_db_get_compound_type(), cmd_descs_generate::str, autogen_x86imm::tmp, and rz_analysis_t::typedb.

Referenced by rz_type_open_editor_handler().

rz_types_open_file()

RZ_IPI bool rz_types_open_file	(	RzCore *	core,
		const char *	path
	)

Definition at line 1046 of file ctypes.c.

                                                               {
    const char *dir = rz_config_get(core->config, "dir.types");
    RzTypeDB *typedb = core->analysis->typedb;
    if (!strcmp(path, "-")) {
        char *tmp = rz_core_editor(core, "*.h", "");
        if (tmp) {
            char *error_msg = NULL;
            int result = rz_type_parse_string_stateless(typedb->parser, tmp, &error_msg);
            if (result && error_msg) {
                RZ_LOG_ERROR("%s", error_msg);
                free(error_msg);
            }
            free(tmp);
        }
    } else {
        if (!rz_file_exists(path)) {
            RZ_LOG_ERROR("File \"%s\" does not exist\n", path);
            return false;
        }
        char *error_msg = NULL;
        int result = rz_type_parse_file_stateless(typedb->parser, path, dir, &error_msg);
        if (result && error_msg) {
            RZ_LOG_ERROR("%s", error_msg);
            free(error_msg);
        }
    }
    return true;
}

References rz_core_t::analysis, rz_core_t::config, coremodepj::core, free(), NULL, rz_type_db_t::parser, path, rz_config_get(), rz_core_editor(), rz_file_exists(), RZ_LOG_ERROR, rz_type_parse_file_stateless(), rz_type_parse_string_stateless(), autogen_x86imm::tmp, and rz_analysis_t::typedb.

Referenced by rz_type_open_file_handler().

set_offset_hint()

static void set_offset_hint ( RzCore *  core, RzAnalysisOp *  op, RZ_BORROW RzTypePath *  tpath, ut64  laddr, ut64  at, int  offimm  )

static

Definition at line 650 of file ctypes.c.

                                                                                                                          {
    rz_return_if_fail(core && op && tpath);
    if (tpath->typ->kind != RZ_TYPE_KIND_IDENTIFIER) {
        return;
    }
    char *cmt = (offimm == 0) ? strdup(tpath->path) : rz_type_as_string(core->analysis->typedb, tpath->typ);
    if (offimm > 0) {
        // Set only the type path as the analysis hint
        // only and only if the types are the exact match between
        // possible member offset and the type linked to the laddr
        RzList *paths = rz_analysis_type_paths_by_address(core->analysis, laddr + offimm);
        if (paths && rz_list_length(paths)) {
            RzTypePath *link = rz_list_get_top(paths);
            rz_analysis_hint_set_offset(core->analysis, at, link->path);
        }
    } else if (cmt && rz_analysis_op_ismemref(op->type)) {
        rz_meta_set_string(core->analysis, RZ_META_TYPE_VARTYPE, at, cmt);
    }
    free(cmt);
}

References rz_core_t::analysis, free(), link, rz_analysis_hint_set_offset(), rz_analysis_op_ismemref(), rz_analysis_type_paths_by_address(), rz_list_get_top(), rz_list_length(), rz_meta_set_string(), RZ_META_TYPE_VARTYPE, rz_return_if_fail, rz_type_as_string(), RZ_TYPE_KIND_IDENTIFIER, strdup(), and rz_analysis_t::typedb.

Referenced by resolve_type_links().

set_retval()

static void set_retval ( RzCore *  core, ut64  at  )

static

Definition at line 626 of file ctypes.c.

                                              {
    RzAnalysis *analysis = core->analysis;
    RzAnalysisHint *hint = rz_analysis_hint_get(analysis, at);
    RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(analysis, at, 0);
 
    if (!hint || !fcn || !fcn->name) {
        goto beach;
    }
    if (hint->ret == UT64_MAX) {
        goto beach;
    }
    const char *cc = rz_analysis_cc_func(core->analysis, fcn->name);
    const char *regname = rz_analysis_cc_ret(analysis, cc);
    if (regname) {
        RzRegItem *reg = rz_reg_get(analysis->reg, regname, -1);
        if (reg) {
            rz_reg_set_value(analysis->reg, reg, hint->ret);
        }
    }
beach:
    rz_analysis_hint_free(hint);
    return;
}

References rz_core_t::analysis, rz_analysis_function_t::name, reg, rz_analysis_t::reg, regname(), rz_analysis_hint_t::ret, rz_analysis_cc_func(), rz_analysis_cc_ret(), rz_analysis_get_fcn_in(), rz_analysis_hint_free(), rz_analysis_hint_get(), rz_reg_get(), rz_reg_set_value(), and UT64_MAX.

Referenced by rz_core_link_stroff().

typelink_print_cb()

static bool typelink_print_cb ( void *  user, ut64  k, const void *  v  )

static

Definition at line 924 of file ctypes.c.

                                                                 {
    rz_return_val_if_fail(user && v, false);
    struct coremodepj *c = user;
    rz_core_types_link_print(c->core, (RzType *)v, k, c->mode, c->pj);
    return true;
}

References c, k, rz_core_types_link_print(), rz_return_val_if_fail, and v.

Referenced by rz_core_types_link_print_all().