cdwarf.c File Reference

#include <rz_core.h>

Go to the source code of this file.

Functions
RZ_API void	rz_core_bin_dwarf_print_abbrev_section (const RzBinDwarfDebugAbbrev *da)
RZ_API void	rz_core_bin_dwarf_print_attr_value (const RzBinDwarfAttrValue *val)
RZ_API void	rz_core_bin_dwarf_print_debug_info (const RzBinDwarfDebugInfo *inf)
static int	offset_comp (const void *a, const void *b)
static bool	sort_loclists (void *user, const ut64 key, const void *value)
RZ_API void	rz_core_bin_dwarf_print_loc (HtUP *loc_table, int addr_size)
RZ_API void	rz_core_bin_dwarf_print_aranges (RzList *aranges)
static void	print_line_op (RzBinDwarfLineOp *op, RzBinDwarfLineHeader *hdr, RZ_NULLABLE RzBinDwarfSMRegisters *regs)
RZ_API void	rz_core_bin_dwarf_print_line_units (RzList *lines)

Function Documentation

offset_comp()

static int offset_comp ( const void *  a, const void *  b  )

static

Definition at line 175 of file cdwarf.c.

                                                     {
    const RzBinDwarfLocList *f = a;
    const RzBinDwarfLocList *s = b;
    ut64 first = f->offset;
    ut64 second = s->offset;
    if (first < second) {
        return -1;
    }
    if (first > second) {
        return 1;
    }
    return 0;
}

References a, b, f, s, and ut64().

Referenced by sort_loclists().

print_line_op()

static void print_line_op ( RzBinDwarfLineOp *  op, RzBinDwarfLineHeader *  hdr, RZ_NULLABLE RzBinDwarfSMRegisters *  regs  )

static

Parameters

regs	optional, the state after op has been executed. If not null, some meaningful results from this context will be shown.

Definition at line 247 of file cdwarf.c.

                                                                                                                    {
    switch (op->type) {
    case RZ_BIN_DWARF_LINE_OP_TYPE_STD:
        switch (op->opcode) {
        case DW_LNS_copy:
            rz_cons_print("Copy");
            break;
        case DW_LNS_advance_pc:
            rz_cons_printf("Advance PC by %" PFMT64u, op->args.advance_pc * hdr->min_inst_len);
            if (regs) {
                rz_cons_printf(" to 0x%" PFMT64x, regs->address);
            }
            break;
        case DW_LNS_advance_line:
            rz_cons_printf("Advance line by %" PFMT64d, op->args.advance_line);
            if (regs) {
                rz_cons_printf(", to %" PFMT64d, regs->line);
            }
            break;
        case DW_LNS_set_file:
            rz_cons_printf("Set file to %" PFMT64d, op->args.set_file);
            break;
        case DW_LNS_set_column:
            rz_cons_printf("Set column to %" PFMT64d, op->args.set_column);
            break;
        case DW_LNS_negate_stmt:
            if (regs) {
                rz_cons_printf("Set is_stmt to %u", (unsigned int)regs->is_stmt);
            } else {
                rz_cons_print("Negate is_stmt");
            }
            break;
        case DW_LNS_set_basic_block:
            rz_cons_print("set_basic_block");
            break;
        case DW_LNS_const_add_pc:
            rz_cons_printf("Advance PC by constant %" PFMT64u, rz_bin_dwarf_line_header_get_spec_op_advance_pc(hdr, 255));
            if (regs) {
                rz_cons_printf(" to 0x%" PFMT64x, regs->address);
            }
            break;
        case DW_LNS_fixed_advance_pc:
            rz_cons_printf("Fixed advance pc by %" PFMT64u, op->args.fixed_advance_pc);
            rz_cons_printf(" to %" PFMT64d, regs->address);
            break;
        case DW_LNS_set_prologue_end:
            rz_cons_print("set_prologue_end");
            break;
        case DW_LNS_set_epilogue_begin:
            rz_cons_print("set_epilogue_begin");
            break;
        case DW_LNS_set_isa:
            rz_cons_printf("set_isa to %" PFMT64u, op->args.set_isa);
            break;
        default:
            rz_cons_printf("Unknown Standard Opcode %u", (unsigned int)op->opcode);
            break;
        }
        break;
    case RZ_BIN_DWARF_LINE_OP_TYPE_EXT:
        rz_cons_printf("Extended opcode %u: ", (unsigned int)op->opcode);
        switch (op->opcode) {
        case DW_LNE_end_sequence:
            rz_cons_print("End of Sequence");
            break;
        case DW_LNE_set_address:
            rz_cons_printf("set Address to 0x%" PFMT64x, op->args.set_address);
            break;
        case DW_LNE_define_file:
            rz_cons_printf("define_file \"%s\", dir_index %" PFMT64u ", ",
                op->args.define_file.filename,
                op->args.define_file.dir_index);
            break;
        case DW_LNE_set_discriminator:
            rz_cons_printf("set Discriminator to %" PFMT64u "\n", op->args.set_discriminator);
            break;
        default:
            rz_cons_printf("Unknown");
            break;
        }
        break;
    case RZ_BIN_DWARF_LINE_OP_TYPE_SPEC:
        rz_cons_printf("Special opcode %u: ", (unsigned int)rz_bin_dwarf_line_header_get_adj_opcode(hdr, op->opcode));
        rz_cons_printf("advance Address by %" PFMT64u, rz_bin_dwarf_line_header_get_spec_op_advance_pc(hdr, op->opcode));
        if (regs) {
            rz_cons_printf(" to 0x%" PFMT64x, regs->address);
        }
        rz_cons_printf(" and Line by %" PFMT64d, rz_bin_dwarf_line_header_get_spec_op_advance_line(hdr, op->opcode));
        if (regs) {
            rz_cons_printf(" to %" PFMT64u, regs->line);
        }
        break;
    }
    rz_cons_print("\n");
}

References DW_LNE_define_file, DW_LNE_end_sequence, DW_LNE_set_address, DW_LNE_set_discriminator, DW_LNS_advance_line, DW_LNS_advance_pc, DW_LNS_const_add_pc, DW_LNS_copy, DW_LNS_fixed_advance_pc, DW_LNS_negate_stmt, DW_LNS_set_basic_block, DW_LNS_set_column, DW_LNS_set_epilogue_begin, DW_LNS_set_file, DW_LNS_set_isa, DW_LNS_set_prologue_end, RzBinDwarfLineHeader::min_inst_len, PFMT64d, PFMT64u, PFMT64x, regs, rz_bin_dwarf_line_header_get_adj_opcode(), rz_bin_dwarf_line_header_get_spec_op_advance_line(), rz_bin_dwarf_line_header_get_spec_op_advance_pc(), RZ_BIN_DWARF_LINE_OP_TYPE_EXT, RZ_BIN_DWARF_LINE_OP_TYPE_SPEC, RZ_BIN_DWARF_LINE_OP_TYPE_STD, and rz_cons_printf().

Referenced by rz_core_bin_dwarf_print_line_units().

rz_core_bin_dwarf_print_abbrev_section()

RZ_API void rz_core_bin_dwarf_print_abbrev_section

(

const RzBinDwarfDebugAbbrev *

da

)

Definition at line 6 of file cdwarf.c.

                                                                                    {
    size_t i, j;
    if (!da) {
        return;
    }
    for (i = 0; i < da->count; i++) {
        rz_cons_printf("   %-4" PFMT64d " ", da->decls[i].code);
        const char *tagname = rz_bin_dwarf_get_tag_name(da->decls[i].tag);
        if (tagname) {
            rz_cons_printf("  %-25s ", tagname);
        }
        rz_cons_printf("[%s]", da->decls[i].has_children ? "has children" : "no children");
        rz_cons_printf(" (0x%" PFMT64x ")\n", da->decls[i].offset);
 
        if (da->decls[i].defs) {
            for (j = 0; j < da->decls[i].count; j++) {
                const char *attr_name = rz_bin_dwarf_get_attr_name(da->decls[i].defs[j].attr_name);
                const char *attr_form_name = rz_bin_dwarf_get_attr_form_name(da->decls[i].defs[j].attr_form);
                if (attr_name && attr_form_name) {
                    rz_cons_printf("    %-30s %-30s\n", attr_name, attr_form_name);
                }
            }
        }
    }
}

References RzBinDwarfAttrDef::attr_form, RzBinDwarfAttrDef::attr_name, RzBinDwarfAbbrevDecl::code, RzBinDwarfAbbrevDecl::count, RzBinDwarfDebugAbbrev::count, RzBinDwarfDebugAbbrev::decls, RzBinDwarfAbbrevDecl::defs, RzBinDwarfAbbrevDecl::has_children, i, RzBinDwarfAbbrevDecl::offset, PFMT64d, PFMT64x, rz_bin_dwarf_get_attr_form_name(), rz_bin_dwarf_get_attr_name(), rz_bin_dwarf_get_tag_name(), rz_cons_printf(), and RzBinDwarfAbbrevDecl::tag.

Referenced by bin_dwarf().

rz_core_bin_dwarf_print_aranges()

RZ_API void rz_core_bin_dwarf_print_aranges

(

RzList *

aranges

)

Definition at line 222 of file cdwarf.c.

                                                               {
    rz_return_if_fail(aranges);
    rz_cons_print("\nContents of the .debug_aranges section:\n");
    RzListIter *it;
    RzBinDwarfARangeSet *set;
    rz_list_foreach (aranges, it, set) {
        rz_cons_print("  Address Range Set\n");
        rz_cons_printf("   Unit Length:           0x%" PFMT64x "\n", set->unit_length);
        rz_cons_printf("   64bit:                 %s\n", rz_str_bool(set->is_64bit));
        rz_cons_printf("   Version:               %u\n", (unsigned int)set->version);
        rz_cons_printf("   Offset in .debug_info: 0x%" PFMT64x "\n", set->debug_info_offset);
        rz_cons_printf("   Address Size:          %u\n", (unsigned int)set->address_size);
        rz_cons_printf("   Segment Size:          %u\n", (unsigned int)set->segment_size);
        rz_cons_print("   Ranges:\n");
        rz_cons_print("    address            length\n");
        for (size_t i = 0; i < set->aranges_count; i++) {
            rz_cons_printf("    0x%016" PFMT64x " 0x%016" PFMT64x "\n", set->aranges[i].addr, set->aranges[i].length);
        }
    }
    rz_cons_print("\n");
}

References rz_bin_dwarf_arange_t::addr, rz_bin_dwarf_arange_set_t::address_size, rz_bin_dwarf_arange_set_t::aranges, rz_bin_dwarf_arange_set_t::aranges_count, rz_bin_dwarf_arange_set_t::debug_info_offset, i, rz_bin_dwarf_arange_set_t::is_64bit, rz_bin_dwarf_arange_t::length, PFMT64x, rz_cons_printf(), rz_return_if_fail, rz_str_bool(), rz_bin_dwarf_arange_set_t::segment_size, rz_bin_dwarf_arange_set_t::unit_length, and rz_bin_dwarf_arange_set_t::version.

Referenced by bin_dwarf().

rz_core_bin_dwarf_print_attr_value()

RZ_API void rz_core_bin_dwarf_print_attr_value

(

const RzBinDwarfAttrValue *

val

)

Definition at line 32 of file cdwarf.c.

                                                                               {
    size_t i;
    rz_return_if_fail(val);
 
    switch (val->attr_form) {
    case DW_FORM_block:
    case DW_FORM_block1:
    case DW_FORM_block2:
    case DW_FORM_block4:
    case DW_FORM_exprloc:
        rz_cons_printf("%" PFMT64u " byte block:", val->block.length);
        for (i = 0; i < val->block.length; i++) {
            rz_cons_printf(" 0x%02x", val->block.data[i]);
        }
        break;
    case DW_FORM_data1:
    case DW_FORM_data2:
    case DW_FORM_data4:
    case DW_FORM_data8:
    case DW_FORM_data16:
        rz_cons_printf("%" PFMT64u "", val->uconstant);
        if (val->attr_name == DW_AT_language) {
            const char *lang_name = rz_bin_dwarf_get_lang_name(val->uconstant);
            if (lang_name) {
                rz_cons_printf("   (%s)", lang_name);
            }
        }
        break;
    case DW_FORM_string:
        if (val->string.content) {
            rz_cons_printf("%s", val->string.content);
        } else {
            rz_cons_print("No string found");
        }
        break;
    case DW_FORM_flag:
        rz_cons_printf("%u", val->flag);
        break;
    case DW_FORM_sdata:
        rz_cons_printf("%" PFMT64d "", val->sconstant);
        break;
    case DW_FORM_udata:
        rz_cons_printf("%" PFMT64u "", val->uconstant);
        break;
    case DW_FORM_ref_addr:
    case DW_FORM_ref1:
    case DW_FORM_ref2:
    case DW_FORM_ref4:
    case DW_FORM_ref8:
    case DW_FORM_ref_sig8:
    case DW_FORM_ref_udata:
    case DW_FORM_ref_sup4:
    case DW_FORM_ref_sup8:
    case DW_FORM_sec_offset:
        rz_cons_printf("<0x%" PFMT64x ">", val->reference);
        break;
    case DW_FORM_flag_present:
        rz_cons_print("1");
        break;
    case DW_FORM_strx:
    case DW_FORM_strx1:
    case DW_FORM_strx2:
    case DW_FORM_strx3:
    case DW_FORM_strx4:
    case DW_FORM_line_ptr:
    case DW_FORM_strp_sup:
    case DW_FORM_strp:
        rz_cons_printf("(indirect string, offset: 0x%" PFMT64x "): %s",
            val->string.offset, val->string.content);
        break;
    case DW_FORM_addr:
    case DW_FORM_addrx:
    case DW_FORM_addrx1:
    case DW_FORM_addrx2:
    case DW_FORM_addrx3:
    case DW_FORM_addrx4:
    case DW_FORM_loclistx:
    case DW_FORM_rnglistx:
        rz_cons_printf("0x%" PFMT64x "", val->address);
        break;
    case DW_FORM_implicit_const:
        rz_cons_printf("0x%" PFMT64d "", val->uconstant);
        break;
    default:
        rz_cons_printf("Unknown attr value form %" PFMT64d "\n", val->attr_form);
        break;
    };
}

References DW_AT_language, DW_FORM_addr, DW_FORM_addrx, DW_FORM_addrx1, DW_FORM_addrx2, DW_FORM_addrx3, DW_FORM_addrx4, DW_FORM_block, DW_FORM_block1, DW_FORM_block2, DW_FORM_block4, DW_FORM_data1, DW_FORM_data16, DW_FORM_data2, DW_FORM_data4, DW_FORM_data8, DW_FORM_exprloc, DW_FORM_flag, DW_FORM_flag_present, DW_FORM_implicit_const, DW_FORM_line_ptr, DW_FORM_loclistx, DW_FORM_ref1, DW_FORM_ref2, DW_FORM_ref4, DW_FORM_ref8, DW_FORM_ref_addr, DW_FORM_ref_sig8, DW_FORM_ref_sup4, DW_FORM_ref_sup8, DW_FORM_ref_udata, DW_FORM_rnglistx, DW_FORM_sdata, DW_FORM_sec_offset, DW_FORM_string, DW_FORM_strp, DW_FORM_strp_sup, DW_FORM_strx, DW_FORM_strx1, DW_FORM_strx2, DW_FORM_strx3, DW_FORM_strx4, DW_FORM_udata, i, PFMT64d, PFMT64u, PFMT64x, rz_bin_dwarf_get_lang_name(), rz_cons_printf(), rz_return_if_fail, and val.

Referenced by rz_core_bin_dwarf_print_debug_info().

rz_core_bin_dwarf_print_debug_info()

RZ_API void rz_core_bin_dwarf_print_debug_info

(

const RzBinDwarfDebugInfo *

inf

)

Definition at line 121 of file cdwarf.c.

                                                                               {
    size_t i, j, k;
    RzBinDwarfDie *dies;
    RzBinDwarfAttrValue *values;
 
    rz_return_if_fail(inf);
 
    for (i = 0; i < inf->count; i++) {
        rz_cons_print("\n");
        rz_cons_printf("  Compilation Unit @ offset 0x%" PFMT64x ":\n", inf->comp_units[i].offset);
        rz_cons_printf("   Length:        0x%" PFMT64x "\n", inf->comp_units[i].hdr.length);
        rz_cons_printf("   Version:       %d\n", inf->comp_units[i].hdr.version);
        rz_cons_printf("   Abbrev Offset: 0x%" PFMT64x "\n", inf->comp_units[i].hdr.abbrev_offset);
        rz_cons_printf("   Pointer Size:  %d\n", inf->comp_units[i].hdr.address_size);
        const char *unit_type_name = rz_bin_dwarf_get_unit_type_name(inf->comp_units[i].hdr.unit_type);
        if (unit_type_name) {
            rz_cons_printf("   Unit Type:     %s\n", unit_type_name);
        }
        rz_cons_print("\n");
 
        dies = inf->comp_units[i].dies;
 
        for (j = 0; j < inf->comp_units[i].count; j++) {
            rz_cons_printf("<0x%" PFMT64x ">: Abbrev Number: %-4" PFMT64u " ", dies[j].offset, dies[j].abbrev_code);
 
            const char *tag_name = rz_bin_dwarf_get_tag_name(dies[j].tag);
            if (tag_name) {
                rz_cons_printf("(%s)\n", tag_name);
            } else {
                rz_cons_print("(Unknown abbrev tag)\n");
            }
 
            if (!dies[j].abbrev_code) {
                continue;
            }
            values = dies[j].attr_values;
 
            for (k = 0; k < dies[j].count; k++) {
                if (!values[k].attr_name) {
                    continue;
                }
                const char *attr_name = rz_bin_dwarf_get_attr_name(values[k].attr_name);
                if (attr_name) {
                    rz_cons_printf("     %-25s : ", attr_name);
                } else {
                    rz_cons_printf("     AT_UNKWN [0x%-3" PFMT64x "]\t : ", values[k].attr_name);
                }
                rz_core_bin_dwarf_print_attr_value(&values[k]);
                rz_cons_printf("\n");
            }
        }
    }
}

References RzBinDwarfDie::attr_values, RzBinDwarfDie::count, i, inf(), k, PFMT64u, PFMT64x, rz_bin_dwarf_get_attr_name(), rz_bin_dwarf_get_tag_name(), rz_bin_dwarf_get_unit_type_name(), rz_cons_printf(), rz_core_bin_dwarf_print_attr_value(), rz_return_if_fail, and test-lz4-versions::tag.

Referenced by bin_dwarf().

rz_core_bin_dwarf_print_line_units()

RZ_API void rz_core_bin_dwarf_print_line_units

(

RzList *

lines

)

Definition at line 343 of file cdwarf.c.

                                                                {
    rz_return_if_fail(lines);
    rz_cons_print("Raw dump of debug contents of section .debug_line:\n\n");
    RzListIter *it;
    RzBinDwarfLineUnit *unit;
    bool first = true;
    rz_list_foreach (lines, it, unit) {
        if (first) {
            first = false;
        } else {
            rz_cons_print("\n");
        }
        rz_cons_print(" Header information:\n");
        rz_cons_printf("  Length:                             %" PFMT64u "\n", unit->header.unit_length);
        rz_cons_printf("  DWARF Version:                      %d\n", unit->header.version);
        rz_cons_printf("  Header Length:                      %" PFMT64d "\n", unit->header.header_length);
        rz_cons_printf("  Minimum Instruction Length:         %d\n", unit->header.min_inst_len);
        rz_cons_printf("  Maximum Operations per Instruction: %d\n", unit->header.max_ops_per_inst);
        rz_cons_printf("  Initial value of 'is_stmt':         %d\n", unit->header.default_is_stmt);
        rz_cons_printf("  Line Base:                          %d\n", unit->header.line_base);
        rz_cons_printf("  Line Range:                         %d\n", unit->header.line_range);
        rz_cons_printf("  Opcode Base:                        %d\n\n", unit->header.opcode_base);
        rz_cons_print(" Opcodes:\n");
        for (size_t i = 1; i < unit->header.opcode_base; i++) {
            rz_cons_printf("  Opcode %zu has %d arg\n", i, unit->header.std_opcode_lengths[i - 1]);
        }
        rz_cons_print("\n");
        if (unit->header.include_dirs_count && unit->header.include_dirs) {
            rz_cons_printf(" The Directory Table:\n");
            for (size_t i = 0; i < unit->header.include_dirs_count; i++) {
                rz_cons_printf("  %u     %s\n", (unsigned int)i + 1, unit->header.include_dirs[i]);
            }
        }
        if (unit->header.file_names_count && unit->header.file_names) {
            rz_cons_print("\n");
            rz_cons_print(" The File Name Table:\n");
            rz_cons_print("  Entry Dir     Time      Size       Name\n");
            for (size_t i = 0; i < unit->header.file_names_count; i++) {
                RzBinDwarfLineFileEntry *f = &unit->header.file_names[i];
                rz_cons_printf("  %u     %" PFMT32u "       %" PFMT32u "         %" PFMT32u "          %s\n",
                    (unsigned int)i + 1, f->id_idx, f->mod_time, f->file_len, f->name);
            }
            rz_cons_print("\n");
        }
        if (unit->ops_count && unit->ops) {
            // also execute all ops simultaneously which gives us nice intermediate value printing
            RzBinDwarfSMRegisters regs;
            rz_bin_dwarf_line_header_reset_regs(&unit->header, &regs);
            rz_cons_print(" Line Number Statements:\n");
            for (size_t i = 0; i < unit->ops_count; i++) {
                rz_bin_dwarf_line_op_run(&unit->header, &regs, &unit->ops[i], NULL, NULL, NULL);
                rz_cons_print("  ");
                RzBinDwarfLineOp *op = &unit->ops[i];
                print_line_op(op, &unit->header, &regs);
                if (op->type == RZ_BIN_DWARF_LINE_OP_TYPE_EXT && op->opcode == DW_LNE_end_sequence && i + 1 < unit->ops_count) {
                    // extra newline for nice sequence separation
                    rz_cons_print("\n");
                }
            }
        }
    }
    rz_cons_print("\n");
}

References RzBinDwarfLineHeader::default_is_stmt, DW_LNE_end_sequence, f, RzBinDwarfLineHeader::file_names, RzBinDwarfLineHeader::file_names_count, RzBinDwarfLineUnit::header, RzBinDwarfLineHeader::header_length, i, RzBinDwarfLineHeader::include_dirs, RzBinDwarfLineHeader::include_dirs_count, RzBinDwarfLineHeader::line_base, RzBinDwarfLineHeader::line_range, lines(), RzBinDwarfLineHeader::max_ops_per_inst, RzBinDwarfLineHeader::min_inst_len, NULL, RzBinDwarfLineHeader::opcode_base, RzBinDwarfLineUnit::ops, RzBinDwarfLineUnit::ops_count, PFMT32u, PFMT64d, PFMT64u, print_line_op(), regs, rz_bin_dwarf_line_header_reset_regs(), rz_bin_dwarf_line_op_run(), RZ_BIN_DWARF_LINE_OP_TYPE_EXT, rz_cons_printf(), rz_return_if_fail, RzBinDwarfLineHeader::std_opcode_lengths, RzBinDwarfLineHeader::unit_length, and RzBinDwarfLineHeader::version.

Referenced by bin_dwarf().

rz_core_bin_dwarf_print_loc()

RZ_API void rz_core_bin_dwarf_print_loc	(	HtUP *	loc_table,
		int	addr_size
	)

Definition at line 196 of file cdwarf.c.

                                                                          {
    rz_return_if_fail(loc_table);
    rz_cons_print("\nContents of the .debug_loc section:\n");
    RzList /*<RzBinDwarfLocList *>*/ *sort_list = rz_list_new();
    /* sort the table contents by offset and print sorted
       a bit ugly, but I wanted to decouple the parsing and printing */
    ht_up_foreach(loc_table, sort_loclists, sort_list);
    RzListIter *i;
    RzBinDwarfLocList *loc_list;
    rz_list_foreach (sort_list, i, loc_list) {
        RzListIter *j;
        RzBinDwarfLocRange *range;
        ut64 base_offset = loc_list->offset;
        rz_list_foreach (loc_list->list, j, range) {
            rz_cons_printf("0x%" PFMT64x " 0x%" PFMT64x " 0x%" PFMT64x "\n", base_offset, range->start, range->end);
            base_offset += addr_size * 2;
            if (range->expression) {
                base_offset += 2 + range->expression->length; /* 2 bytes for expr length */
            }
        }
        rz_cons_printf("0x%" PFMT64x " <End of list>\n", base_offset);
    }
    rz_cons_print("\n");
    rz_list_free(sort_list);
}

References i, rz_bin_dwarf_loc_list_t::list, rz_bin_dwarf_loc_list_t::offset, PFMT64x, capstone::range, rz_cons_printf(), rz_list_free(), rz_list_new(), rz_return_if_fail, sort_loclists(), and ut64().

Referenced by bin_dwarf().

sort_loclists()

static bool sort_loclists ( void *  user, const ut64  key, const void *  value  )

static

Definition at line 189 of file cdwarf.c.

                                                                         {
    RzBinDwarfLocList *loc_list = (RzBinDwarfLocList *)value;
    RzList *sort_list = user;
    rz_list_add_sorted(sort_list, loc_list, offset_comp);
    return true;
}

References offset_comp(), rz_list_add_sorted(), and value.

Referenced by rz_core_bin_dwarf_print_loc().