gdiff.c File Reference

#include <stdio.h>
#include <string.h>
#include <rz_analysis.h>
#include <rz_list.h>
#include <rz_util.h>
#include <rz_core.h>

Go to the source code of this file.

Functions
RZ_API bool	rz_core_gdiff_function_1_file (RzCore *c, ut64 addr, ut64 addr2)
	Calculates basic block differences of 2 functions within the same file. More...
RZ_API bool	rz_core_gdiff_function_2_files (RzCore *c, RzCore *c2, ut64 addr, ut64 addr2)
	Calculates basic block differences of 2 functions within 2 files. More...
RZ_API bool	rz_core_gdiff_2_files (RzCore *c, RzCore *c2)
	Calculates basic block differences of all functions within 2 files. More...
static void	diffrow (ut64 addr, const char *name, ut32 size, int maxnamelen, int digits, ut64 addr2, const char *name2, ut32 size2, double dist, bool bare, bool color)
RZ_API void	rz_core_diff_show (RzCore *c, RzCore *c2, bool json)
static const char *	diff_color (RzAnalysisBlock *bbi)
static void	print_color_node (RzCore *core, RzAnalysisBlock *bbi)
static int	graph_construct_nodes (RzCore *core, RzCore *core2, RzAnalysisFunction *fcn, PJ *pj)
static int	graph_construct_edges (RzCore *core, RzAnalysisFunction *fcn)
static int	draw_graph_nodes (RzCore *core, RzCore *core2, RzAnalysisFunction *fcn, PJ *pj)
RZ_API bool	rz_core_diff_show_function (RzCore *core, RzCore *core2, ut64 addr1, bool json)
	Generate a json or dot output of the graph and its data. More...

Function Documentation

diff_color()

static const char* diff_color ( RzAnalysisBlock *  bbi )

static

Definition at line 334 of file gdiff.c.

                                                    {
    if (!bbi->diff) {
        return "white";
    }
 
    switch (bbi->diff->type) {
    case RZ_ANALYSIS_DIFF_TYPE_MATCH:
        return "lightgray";
    case RZ_ANALYSIS_DIFF_TYPE_UNMATCH:
        return bbi->diff->dist >= 0.5 ? "yellow" : "red";
    default:
        return "turquoise";
    }
}

References rz_analysis_bb_t::diff, rz_analysis_diff_t::dist, RZ_ANALYSIS_DIFF_TYPE_MATCH, RZ_ANALYSIS_DIFF_TYPE_UNMATCH, and rz_analysis_diff_t::type.

Referenced by graph_construct_nodes().

diffrow()

static void diffrow ( ut64  addr, const char *  name, ut32  size, int  maxnamelen, int  digits, ut64  addr2, const char *  name2, ut32  size2, double  dist, bool  bare, bool  color  )

static

Definition at line 124 of file gdiff.c.

                                        {
 
    const char *type = NULL;
    const char *prefix = NULL;
    const char *suffix = color ? Color_RESET : "";
 
    if (dist == 1.0) {
        prefix = color ? Color_BGREEN : "";
        type = color ? Color_BGREEN "MATCH  " Color_RESET : "MATCH  ";
    } else if (dist >= RZ_ANALYSIS_DIFF_THRESHOLD) {
        prefix = color ? Color_BYELLOW : "";
        type = color ? Color_BYELLOW "SIMILAR" Color_RESET : "SIMILAR";
    } else {
        prefix = color ? Color_BRED : "";
        type = color ? Color_BRED "UNMATCH" Color_RESET : "UNMATCH";
    }
 
    if (bare) {
        if (addr2 == UT64_MAX || !name2) {
            printf("0x%016" PFMT64x " | %7s (%s%f%s)\n", addr, type, prefix, dist, suffix);
        } else {
            printf("0x%016" PFMT64x " | %7s (%s%f%s) | 0x%016" PFMT64x "\n", addr, type, prefix, dist, suffix, addr2);
        }
    } else {
        if (addr2 == UT64_MAX || !name2) {
            printf("%*s %*d 0x%016" PFMT64x " | %7s (%s%f%s)\n",
                maxnamelen, name, digits, size, addr, type, prefix, dist, suffix);
        } else {
            printf("%*s %*d 0x%016" PFMT64x " | %7s (%s%f%s) | 0x%016" PFMT64x "  %*d %s\n",
                maxnamelen, name, digits, size, addr, type, prefix, dist, suffix, addr2,
                digits, size2, name2);
        }
    }
}

References addr, color, Color_BGREEN, Color_BRED, Color_BYELLOW, Color_RESET, NULL, PFMT64x, prefix, printf(), RZ_ANALYSIS_DIFF_THRESHOLD, suffix, type, and UT64_MAX.

Referenced by rz_core_diff_show().

draw_graph_nodes()

static int draw_graph_nodes ( RzCore *  core, RzCore *  core2, RzAnalysisFunction *  fcn, PJ *  pj  )

static

Definition at line 532 of file gdiff.c.

                                                                                          {
    rz_return_val_if_fail(fcn && fcn->bbs, -1);
    int nodes = 0;
 
    if (pj) {
        char *fcn_name_escaped = rz_str_escape_utf8_for_json(fcn->name, -1);
        pj_o(pj);
        pj_ks(pj, "name", rz_str_get_null(fcn_name_escaped));
        free(fcn_name_escaped);
        pj_kn(pj, "offset", fcn->addr);
        pj_ki(pj, "ninstr", fcn->ninstr);
        pj_ki(pj, "nargs",
            rz_analysis_var_count(core->analysis, fcn, 'r', 1) +
                rz_analysis_var_count(core->analysis, fcn, 's', 1) +
                rz_analysis_var_count(core->analysis, fcn, 'b', 1));
        pj_ki(pj, "nlocals",
            rz_analysis_var_count(core->analysis, fcn, 'r', 0) +
                rz_analysis_var_count(core->analysis, fcn, 's', 0) +
                rz_analysis_var_count(core->analysis, fcn, 'b', 0));
        pj_kn(pj, "size", rz_analysis_function_linear_size(fcn));
        pj_ki(pj, "stack", fcn->maxstack);
        pj_ks(pj, "type", rz_analysis_fcntype_tostring(fcn->type));
        pj_k(pj, "blocks");
        pj_a(pj);
    }
    nodes += graph_construct_nodes(core, core2, fcn, pj);
    if (!pj) {
        nodes += graph_construct_edges(core, fcn);
    }
    if (pj) {
        pj_end(pj);
        pj_end(pj);
    }
    return nodes;
}

References rz_analysis_function_t::addr, rz_core_t::analysis, rz_analysis_function_t::bbs, free(), graph_construct_edges(), graph_construct_nodes(), rz_analysis_function_t::maxstack, rz_analysis_function_t::name, rz_analysis_function_t::ninstr, pj_a(), pj_end(), pj_k(), pj_ki(), pj_kn(), pj_ks(), pj_o(), rz_analysis_fcntype_tostring(), rz_analysis_function_linear_size(), rz_analysis_var_count(), rz_return_val_if_fail, rz_str_escape_utf8_for_json(), rz_str_get_null(), and rz_analysis_function_t::type.

Referenced by rz_core_diff_show_function().

graph_construct_edges()

static int graph_construct_edges ( RzCore *  core, RzAnalysisFunction *  fcn  )

static

Definition at line 491 of file gdiff.c.

                                                                        {
    RzAnalysisBlock *bbi;
    RzListIter *iter;
    const char *pal_jump = "#0037da";
    const char *pal_fail = "#c50f1f";
    const char *pal_true = "#13a10e";
    int nodes = 0;
    rz_list_foreach (fcn->bbs, iter, bbi) {
        if (bbi->jump != UT64_MAX) {
            nodes++;
            printf("\t\"0x%08" PFMT64x "\" -> \"0x%08" PFMT64x "\" [color=\"%s\"];\n",
                bbi->addr, bbi->jump,
                bbi->fail != UT64_MAX ? pal_true : pal_jump);
            print_color_node(core, bbi);
        }
        if (bbi->fail != UT64_MAX) {
            nodes++;
            printf("\t\"0x%08" PFMT64x "\" -> \"0x%08" PFMT64x "\" [color=\"%s\"];\n",
                bbi->addr, bbi->fail, pal_fail);
            print_color_node(core, bbi);
        }
        if (bbi->switch_op) {
            RzAnalysisCaseOp *caseop;
            RzListIter *iter;
 
            if (bbi->fail != UT64_MAX) {
                printf("\t\"0x%08" PFMT64x "\" -> \"0x%08" PFMT64x "\" [color=\"%s\"];\n",
                    bbi->addr, bbi->fail, pal_fail);
                print_color_node(core, bbi);
            }
            rz_list_foreach (bbi->switch_op->cases, iter, caseop) {
                nodes++;
                printf("\t\"0x%08" PFMT64x "\" -> \"0x%08" PFMT64x "\" [color2=\"%s\"];\n",
                    caseop->addr, caseop->jump, pal_fail);
                print_color_node(core, bbi);
            }
        }
    }
    return nodes;
}

References rz_analysis_case_obj_t::addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, rz_analysis_switch_obj_t::cases, rz_analysis_bb_t::fail, rz_analysis_case_obj_t::jump, rz_analysis_bb_t::jump, PFMT64x, print_color_node(), printf(), rz_analysis_bb_t::switch_op, and UT64_MAX.

Referenced by draw_graph_nodes().

graph_construct_nodes()

static int graph_construct_nodes ( RzCore *  core, RzCore *  core2, RzAnalysisFunction *  fcn, PJ *  pj  )

static

Definition at line 358 of file gdiff.c.

                                                                                               {
    char addr_a[32], addr_b[32];
 
    RzAnalysisBlock *bbi;
    RzListIter *iter;
    int is_json = pj != NULL;
    const char *font = rz_config_get(core->config, "graph.font");
    int nodes = 0;
 
    snprintf(addr_a, sizeof(addr_a), "0x%08" PFMT64x, fcn->addr);
    snprintf(addr_b, sizeof(addr_b), "0x%08" PFMT64x, fcn->diff->addr);
 
    const char *norig = fcn->name ? fcn->name : addr_a;
    const char *nmodi = fcn->diff->name ? fcn->diff->name : addr_b;
 
    rz_list_foreach (fcn->bbs, iter, bbi) {
        if (is_json) {
            RzDebugTracepoint *t = rz_debug_trace_get(core->dbg, bbi->addr);
            ut8 *buf = malloc(bbi->size);
            pj_o(pj);
            pj_kn(pj, "offset", bbi->addr);
            pj_kn(pj, "size", bbi->size);
            if (bbi->jump != UT64_MAX) {
                pj_kn(pj, "jump", bbi->jump);
            }
            if (bbi->fail != -1) {
                pj_kn(pj, "fail", bbi->fail);
            }
            if (bbi->switch_op) {
                RzAnalysisSwitchOp *op = bbi->switch_op;
                pj_k(pj, "switchop");
                pj_o(pj);
                pj_kn(pj, "offset", op->addr);
                pj_kn(pj, "defval", op->def_val);
                pj_kn(pj, "maxval", op->max_val);
                pj_kn(pj, "minval", op->min_val);
                pj_k(pj, "cases");
                pj_a(pj);
                RzAnalysisCaseOp *case_op;
                RzListIter *case_iter;
                rz_list_foreach (op->cases, case_iter, case_op) {
                    pj_o(pj);
                    pj_kn(pj, "offset", case_op->addr);
                    pj_kn(pj, "value", case_op->value);
                    pj_kn(pj, "jump", case_op->jump);
                    pj_end(pj);
                }
                pj_end(pj);
                pj_end(pj);
            }
            if (t) {
                pj_k(pj, "trace");
                pj_o(pj);
                pj_ki(pj, "count", t->count);
                pj_ki(pj, "times", t->times);
                pj_end(pj);
            }
            pj_kn(pj, "colorize", bbi->colorize);
            pj_k(pj, "ops");
            pj_a(pj);
            if (buf) {
                rz_io_read_at(core->io, bbi->addr, buf, bbi->size);
                rz_core_print_disasm_json(core, bbi->addr, buf, bbi->size, 0, pj);
                free(buf);
            } else {
                eprintf("cannot allocate %" PFMT64u " byte(s)\n", bbi->size);
            }
            pj_end(pj);
            pj_end(pj);
            continue;
        } else {
            const char *fillcolor = diff_color(bbi);
            nodes++;
            RzConfigHold *hc = rz_config_hold_new(core->config);
            rz_config_hold_i(hc, "scr.color", "scr.utf8", "asm.offset", "asm.lines",
                "asm.cmt.right", "asm.lines.fcn", "asm.bytes", "asm.comments", NULL);
            rz_config_set_i(core->config, "scr.utf8", 0);
            rz_config_set_i(core->config, "asm.offset", 0);
            rz_config_set_i(core->config, "asm.lines", 0);
            rz_config_set_i(core->config, "asm.cmt.right", 0);
            rz_config_set_i(core->config, "asm.lines.fcn", 0);
            rz_config_set_i(core->config, "asm.bytes", 0);
            rz_config_set_i(core->config, "asm.comments", 0);
            rz_config_set_i(core->config, "scr.color", COLOR_MODE_DISABLED);
 
            char *original = rz_core_cmd_strf(core, "pdb @ 0x%08" PFMT64x, bbi->addr);
 
            if (bbi->diff && bbi->diff->type == RZ_ANALYSIS_DIFF_TYPE_UNMATCH) {
                RzConfig *oc = core2->config;
                core2->config = core->config;
 
                char *modified = rz_core_cmd_strf(core2, "pdb @ 0x%08" PFMT64x, bbi->diff->addr);
                if (!modified || !strcmp(original, modified)) {
                    // sometimes the mismatch is on a call value
                    // but the output is actually the same due sym./imp.
                    free(modified);
                    core2->config = oc;
                    goto graph_construct_nodes_is_same;
                }
 
                RzDiff *dff = rz_diff_lines_new(original, modified, NULL);
                char *diffstr = rz_diff_unified_text(dff, norig, nmodi, false, false);
                rz_diff_free(dff);
 
                rz_str_replace_char(diffstr, '"', '\'');
                diffstr = rz_str_replace(diffstr, "\n", "\\l", 1);
                printf("\t\"0x%08" PFMT64x "\" [fillcolor=\"%s\","
                       "color=\"black\", fontname=\"%s\","
                       " label=\"%s\", URL=\"%s/0x%08" PFMT64x "\"]\n",
                    bbi->addr, fillcolor, font, diffstr, fcn->name,
                    bbi->addr);
                free(diffstr);
                free(modified);
                core2->config = oc;
            } else {
            graph_construct_nodes_is_same:
 
                rz_str_replace_char(original, '"', '\'');
                original = rz_str_replace(original, "\n", "\\l", 1);
                printf("\t\"0x%08" PFMT64x "\" [fillcolor=\"%s\","
                       "color=\"black\", fontname=\"%s\","
                       " label=\"%s\", URL=\"%s/0x%08" PFMT64x "\"]\n",
                    bbi->addr, fillcolor, font, original, fcn->name, bbi->addr);
            }
            free(original);
            rz_config_set_i(core->config, "scr.color", 1);
            rz_config_hold_restore(hc);
            rz_config_hold_free(hc);
        }
    }
    return nodes;
}

References rz_analysis_diff_t::addr, rz_analysis_function_t::addr, rz_analysis_case_obj_t::addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, COLOR_MODE_DISABLED, rz_analysis_bb_t::colorize, rz_core_t::config, rz_debug_tracepoint_t::count, rz_core_t::dbg, rz_analysis_function_t::diff, rz_analysis_bb_t::diff, diff_color(), eprintf, rz_analysis_bb_t::fail, free(), rz_core_t::io, rz_analysis_case_obj_t::jump, rz_analysis_bb_t::jump, malloc(), rz_analysis_diff_t::name, rz_analysis_function_t::name, NULL, PFMT64u, PFMT64x, pj_a(), pj_end(), pj_k(), pj_ki(), pj_kn(), pj_o(), printf(), RZ_ANALYSIS_DIFF_TYPE_UNMATCH, rz_config_get(), rz_config_hold_free(), rz_config_hold_i(), rz_config_hold_new(), rz_config_hold_restore(), rz_config_set_i(), rz_core_cmd_strf(), rz_core_print_disasm_json(), rz_debug_trace_get(), rz_diff_free(), rz_diff_lines_new(), rz_diff_unified_text(), rz_io_read_at(), rz_str_replace(), rz_str_replace_char(), rz_analysis_bb_t::size, snprintf, rz_analysis_bb_t::switch_op, rz_debug_tracepoint_t::times, rz_analysis_diff_t::type, UT64_MAX, and rz_analysis_case_obj_t::value.

Referenced by draw_graph_nodes().

print_color_node()

static void print_color_node ( RzCore *  core, RzAnalysisBlock *  bbi  )

static

Definition at line 349 of file gdiff.c.

                                                                 {
    bool color_current = rz_config_get_i(core->config, "graph.gv.current");
    bool current = rz_analysis_block_contains(bbi, core->offset);
    if (current && color_current) {
        printf("\t\"0x%08" PFMT64x "\" ", bbi->addr);
        printf("\t[fillcolor=gray style=filled shape=box];\n");
    }
}

References rz_analysis_bb_t::addr, rz_core_t::config, rz_core_t::offset, PFMT64x, printf(), and rz_config_get_i().

Referenced by graph_construct_edges().

rz_core_diff_show()

RZ_API void rz_core_diff_show	(	RzCore *	c,
		RzCore *	c2,
		bool	json
	)

Definition at line 161 of file gdiff.c.

                                                                {
    rz_return_if_fail(c && c2);
    bool color = rz_config_get_i(c->config, "scr.color") > 0 || rz_config_get_i(c2->config, "scr.color") > 0;
    bool bare = rz_config_get_b(c->config, "diff.bare") || rz_config_get_b(c2->config, "diff.bare");
    bool ignore = false;
    RzList *fcns = rz_analysis_get_fcns(c->analysis);
    RzListIter *iter;
    RzAnalysisFunction *f;
    int maxnamelen = 0;
    ut64 maxsize = 0;
    int digits = 1;
    int len;
    PJ *pj = NULL;
 
    if (json) {
        pj = pj_new();
        if (!pj) {
            eprintf("cannot alocate json\n");
            return;
        }
        pj_a(pj);
    }
 
    rz_list_foreach (fcns, iter, f) {
        if (f->name && (len = strlen(f->name)) > maxnamelen) {
            maxnamelen = len;
        }
        if (rz_analysis_function_realsize(f) > maxsize) {
            maxsize = rz_analysis_function_realsize(f);
        }
    }
    fcns = rz_analysis_get_fcns(c2->analysis);
    rz_list_foreach (fcns, iter, f) {
        if (f->name && (len = strlen(f->name)) > maxnamelen) {
            maxnamelen = len;
        }
        if (rz_analysis_function_realsize(f) > maxsize) {
            maxsize = rz_analysis_function_realsize(f);
        }
    }
    while (maxsize > 9) {
        maxsize /= 10;
        digits++;
    }
 
    fcns = rz_analysis_get_fcns(c->analysis);
    if (rz_list_empty(fcns)) {
        eprintf("functions list is empty. analyze the binary first\n");
        pj_free(pj);
        return;
    }
    rz_list_sort(fcns, c->analysis->columnSort);
 
    rz_list_foreach (fcns, iter, f) {
        switch (f->type) {
        case RZ_ANALYSIS_FCN_TYPE_FCN:
        case RZ_ANALYSIS_FCN_TYPE_SYM:
            switch (f->diff->type) {
            case RZ_ANALYSIS_DIFF_TYPE_MATCH:
            case RZ_ANALYSIS_DIFF_TYPE_UNMATCH:
                ignore = false;
                break;
            default:
                ignore = true;
                break;
            }
            if (ignore) {
                continue;
            }
            if (json) {
                double dist = f->diff->dist;
                pj_o(pj);
                pj_kd(pj, "distance", f->diff->dist);
                pj_ks(pj, "type", dist >= 1.0 ? "MATCH" : (dist >= 0.5 ? "SIMILAR" : "UNMATCH"));
                if (f->name) {
                    pj_ko(pj, "original");
                    pj_ks(pj, "name", f->name);
                    pj_kn(pj, "addr", f->addr);
                    pj_kn(pj, "size", rz_analysis_function_realsize(f));
                    pj_end(pj);
                }
                if (f->diff->name) {
                    pj_ko(pj, "modified");
                    pj_ks(pj, "name", f->diff->name);
                    pj_kn(pj, "addr", f->diff->addr);
                    pj_kn(pj, "size", f->diff->size);
                    pj_end(pj);
                }
                pj_end(pj);
            } else {
                diffrow(f->addr, f->name, rz_analysis_function_realsize(f), maxnamelen, digits,
                    f->diff->addr, f->diff->name, f->diff->size,
                    f->diff->dist, bare, color);
            }
            break;
        }
    }
 
    ignore = true;
    rz_list_foreach (fcns, iter, f) {
        switch (f->type) {
        case RZ_ANALYSIS_FCN_TYPE_FCN:
        case RZ_ANALYSIS_FCN_TYPE_SYM:
            if (f->diff->type == RZ_ANALYSIS_DIFF_TYPE_NULL) {
                if (json) {
                    pj_o(pj);
                    pj_kd(pj, "distance", 0.0);
                    pj_ks(pj, "type", "NEW");
                    if (f->name) {
                        pj_ko(pj, "original");
                        pj_ks(pj, "name", f->name);
                        pj_kn(pj, "addr", f->addr);
                        pj_kn(pj, "size", rz_analysis_function_realsize(f));
                        pj_end(pj);
                    }
                    pj_end(pj);
                } else {
                    if (ignore) {
                        ignore = false;
                        printf("original not matched:");
                    }
                    printf(" %s", f->name);
                }
            }
            break;
        }
    }
    if (!json && !ignore) {
        printf("\n");
    }
 
    fcns = rz_analysis_get_fcns(c2->analysis);
    rz_list_sort(fcns, c2->analysis->columnSort);
 
    ignore = true;
    rz_list_foreach (fcns, iter, f) {
        switch (f->type) {
        case RZ_ANALYSIS_FCN_TYPE_FCN:
        case RZ_ANALYSIS_FCN_TYPE_SYM:
            if (f->diff->type == RZ_ANALYSIS_DIFF_TYPE_NULL) {
                if (json) {
                    pj_o(pj);
                    pj_kd(pj, "distance", 0.0);
                    pj_ks(pj, "type", "NEW");
                    if (f->name) {
                        pj_ko(pj, "modified");
                        pj_ks(pj, "name", f->name);
                        pj_kn(pj, "addr", f->addr);
                        pj_kn(pj, "size", rz_analysis_function_realsize(f));
                        pj_end(pj);
                    }
                    pj_end(pj);
                } else {
                    if (ignore) {
                        ignore = false;
                        printf("modified not matched:");
                    }
                    printf(" %s", f->name);
                }
            }
            break;
        }
    }
 
    if (json) {
        pj_end(pj);
        printf("%s\n", pj_string(pj));
        pj_free(pj);
    } else if (!ignore) {
        printf("\n");
    }
}

References c, c2, color, diffrow(), eprintf, f, len, NULL, pj_a(), pj_end(), pj_free(), pj_kd(), pj_kn(), pj_ko(), pj_ks(), pj_new(), pj_o(), pj_string(), printf(), RZ_ANALYSIS_DIFF_TYPE_MATCH, RZ_ANALYSIS_DIFF_TYPE_NULL, RZ_ANALYSIS_DIFF_TYPE_UNMATCH, RZ_ANALYSIS_FCN_TYPE_FCN, RZ_ANALYSIS_FCN_TYPE_SYM, rz_analysis_function_realsize(), rz_analysis_get_fcns(), rz_config_get_b(), rz_config_get_i(), rz_list_sort(), rz_return_if_fail, and ut64().

Referenced by rz_diff_graphs_files().

rz_core_diff_show_function()

RZ_API bool rz_core_diff_show_function	(	RzCore *	core,
		RzCore *	core2,
		ut64	addr1,
		bool	json
	)

Generate a json or dot output of the graph and its data.

Each node that doesn't match 100% with the other function will include a unified diff of the assembly of the same basic block.

Definition at line 574 of file gdiff.c.

                                                                                           {
    rz_return_val_if_fail(core && core2, false);
    const char *font = rz_config_get(core->config, "graph.font");
 
    int nodes = 0;
    PJ *pj = NULL;
    RzAnalysisFunction *fcn = rz_analysis_get_function_at(core->analysis, addr1);
    if (!fcn) {
        eprintf("cannot get functions at 0x%" PFMT64x "\n", addr1);
        return false;
    }
 
    if (!json) {
        const char *gv_edge = rz_config_get(core->config, "graph.gv.edge");
        const char *gv_node = rz_config_get(core->config, "graph.gv.node");
        const char *gv_spline = rz_config_get(core->config, "graph.gv.spline");
        if (!gv_edge || !*gv_edge) {
            gv_edge = "arrowhead=\"normal\"";
        }
        if (!gv_node || !*gv_node) {
            gv_node = "fillcolor=gray style=filled shape=box";
        }
        if (!gv_spline || !*gv_spline) {
            gv_spline = "splines=\"ortho\"";
        }
        printf("digraph code {\n"
               "\tgraph [bgcolor=azure fontsize=8 fontname=\"%s\" %s];\n"
               "\tnode [%s];\n"
               "\tedge [%s];\n",
            font, gv_spline, gv_node, gv_edge);
    } else {
        pj = pj_new();
        if (!pj) {
            return false;
        }
        pj_a(pj);
    }
    nodes += draw_graph_nodes(core, core2, fcn, pj);
    if (nodes < 1 && !json) {
        printf("\t\"0x%08" PFMT64x "\";\n", addr1);
    }
    if (json) {
        pj_end(pj);
        printf("%s\n", pj_string(pj));
        pj_free(pj);
    } else {
        printf("}\n");
    }
    return true;
}

References rz_core_t::analysis, rz_core_t::config, draw_graph_nodes(), eprintf, NULL, PFMT64x, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), printf(), rz_analysis_get_function_at(), rz_config_get(), and rz_return_val_if_fail.

Referenced by rz_diff_graphs_files().

rz_core_gdiff_2_files()

RZ_API bool rz_core_gdiff_2_files	(	RzCore *	c,
		RzCore *	c2
	)

Calculates basic block differences of all functions within 2 files.

Calculates basic block differences of all functions within 2 files.

Definition at line 89 of file gdiff.c.

                                                         {
    rz_return_val_if_fail(c && c2, false);
    RzCore *cores[2] = { c, c2 };
    RzAnalysisFunction *fcn;
    RzAnalysisBlock *bb;
    RzListIter *iter, *iter2;
    int i;
 
    if (!c || !c2) {
        return false;
    }
    for (i = 0; i < 2; i++) {
        /* remove strings */
        rz_list_foreach_safe (cores[i]->analysis->fcns, iter, iter2, fcn) {
            if (!strncmp(fcn->name, "str.", 4)) {
                rz_analysis_function_delete(fcn);
            }
        }
        /* Fingerprint fcn bbs (functions basic-blocks) */
        rz_list_foreach (cores[i]->analysis->fcns, iter, fcn) {
            rz_list_foreach (fcn->bbs, iter2, bb) {
                rz_analysis_diff_fingerprint_bb(cores[i]->analysis, bb);
            }
        }
        /* Fingerprint fcn */
        rz_list_foreach (cores[i]->analysis->fcns, iter, fcn) {
            rz_analysis_diff_fingerprint_fcn(cores[i]->analysis, fcn);
        }
    }
    /* Diff functions */
    rz_analysis_diff_fcn(cores[0]->analysis, cores[0]->analysis->fcns, cores[1]->analysis->fcns);
 
    return true;
}

References rz_core_t::analysis, rz_analysis_function_t::bbs, c, c2, rz_analysis_t::fcns, i, rz_analysis_function_t::name, rz_analysis_diff_fcn(), rz_analysis_diff_fingerprint_bb(), rz_analysis_diff_fingerprint_fcn(), rz_analysis_function_delete(), and rz_return_val_if_fail.

Referenced by rz_diff_graphs_files().

rz_core_gdiff_function_1_file()

RZ_API bool rz_core_gdiff_function_1_file	(	RzCore *	c,
		ut64	addr,
		ut64	addr2
	)

Calculates basic block differences of 2 functions within the same file.

Calculates basic block differences of 2 functions within the same file

Definition at line 17 of file gdiff.c.

                                                                            {
    RzList *la, *lb;
    RzAnalysisFunction *fa = rz_analysis_get_function_at(c->analysis, addr);
    RzAnalysisFunction *fb = rz_analysis_get_function_at(c->analysis, addr2);
    if (!fa || !fb) {
        return false;
    }
    RzAnalysisBlock *bb;
    RzListIter *iter;
    rz_list_foreach (fa->bbs, iter, bb) {
        rz_analysis_diff_fingerprint_bb(c->analysis, bb);
    }
    rz_list_foreach (fb->bbs, iter, bb) {
        rz_analysis_diff_fingerprint_bb(c->analysis, bb);
    }
    la = rz_list_new();
    rz_list_append(la, fa);
    lb = rz_list_new();
    rz_list_append(lb, fb);
    rz_analysis_diff_fcn(c->analysis, la, lb);
    rz_list_free(la);
    rz_list_free(lb);
    return true;
}

References addr, rz_analysis_function_t::bbs, c, rz_analysis_diff_fcn(), rz_analysis_diff_fingerprint_bb(), rz_analysis_get_function_at(), rz_list_append(), rz_list_free(), and rz_list_new().

Referenced by cmd_analysis_graph().

rz_core_gdiff_function_2_files()

RZ_API bool rz_core_gdiff_function_2_files	(	RzCore *	c,
		RzCore *	c2,
		ut64	addr,
		ut64	addr2
	)

Calculates basic block differences of 2 functions within 2 files.

Calculates basic block differences of 2 functions within 2 files

Definition at line 47 of file gdiff.c.

                                                                                         {
    rz_return_val_if_fail(c && c2, false);
    RzList *la, *lb;
    RzAnalysisFunction *fa = rz_analysis_get_function_at(c->analysis, addr);
    RzAnalysisFunction *fb = rz_analysis_get_function_at(c2->analysis, addr2);
    if (!fa || !fb) {
        eprintf("cannot get functions at 0x%" PFMT64x " or at 0x%" PFMT64x "\n", addr, addr2);
        return false;
    }
    RzAnalysisBlock *bb;
    RzListIter *iter;
    rz_list_foreach (fa->bbs, iter, bb) {
        if (rz_analysis_diff_fingerprint_bb(c->analysis, bb) < 0) {
            eprintf("cannot fingerprint 0x%" PFMT64x "\n", addr);
            return false;
        }
    }
    rz_list_foreach (fb->bbs, iter, bb) {
        if (rz_analysis_diff_fingerprint_bb(c2->analysis, bb) < 0) {
            eprintf("cannot fingerprint 0x%" PFMT64x "\n", addr2);
            return false;
        }
    }
 
    rz_analysis_diff_fingerprint_fcn(c->analysis, fa);
    rz_analysis_diff_fingerprint_fcn(c2->analysis, fb);
 
    la = rz_list_new();
    rz_list_append(la, fa);
    lb = rz_list_new();
    rz_list_append(lb, fb);
    rz_analysis_diff_fcn(c->analysis, la, lb);
    rz_list_free(la);
    rz_list_free(lb);
    return true;
}

References addr, rz_analysis_function_t::bbs, c, c2, eprintf, PFMT64x, rz_analysis_diff_fcn(), rz_analysis_diff_fingerprint_bb(), rz_analysis_diff_fingerprint_fcn(), rz_analysis_get_function_at(), rz_list_append(), rz_list_free(), rz_list_new(), and rz_return_val_if_fail.

Referenced by rz_diff_graphs_files().