dwarf_process.c File Reference

#include <rz_util.h>
#include <rz_type.h>
#include <sdb.h>
#include <rz_analysis.h>
#include <rz_bin_dwarf.h>
#include <string.h>

Go to the source code of this file.

Classes
struct	dwarf_parse_context_t
struct	dwarf_function_t
struct	dwarf_var_location_t
struct	dwarf_variable_t

Typedefs
typedef struct dwarf_parse_context_t	Context
typedef struct dwarf_function_t	Function
typedef enum dwarf_location_kind	VariableLocationKind
typedef struct dwarf_var_location_t	VariableLocation
typedef struct dwarf_variable_t	Variable

Enumerations
enum	dwarf_location_kind {   LOCATION_UNKNOWN = 0 , LOCATION_GLOBAL = 1 , LOCATION_BP = 2 , LOCATION_SP = 3 ,   LOCATION_REGISTER = 4 }

Functions
static void	variable_free (Variable *var)
static st32	find_attr_idx (const RzBinDwarfDie *die, st32 attr_name)
static RzBinDwarfAttrValue *	find_attr (const RzBinDwarfDie *die, st32 attr_name)
static bool	strbuf_rev_prepend_char (RzStrBuf *sb, const char *s, int c)
	Pasted from rz_strbuf_* Prepends string before a last occurence of character c Used to replicate proper C declaration for function pointers. More...
static bool	strbuf_rev_append_char (RzStrBuf *sb, const char *s, const char *needle)
	Pasted from rz_strbuf_* Appends string after a first occurence of character c Used to replicate proper C declaration for function pointers. More...
static char *	create_type_name_from_offset (ut64 offset)
static char *	get_die_name (const RzBinDwarfDie *die)
	Get the DIE name or create unique one from its offset. More...
static ut64	get_die_size (const RzBinDwarfDie *die)
	Get the DIE size in bits. More...
static st32	parse_array_type (Context *ctx, ut64 idx, RzStrBuf *strbuf)
	Parses array type entry signature into strbuf. More...
static st32	parse_type (Context *ctx, const ut64 offset, RzStrBuf *strbuf, ut64 *size, RZ_NONNULL SetU *visited)
	Recursively parses type entry of a certain offset into strbuf saves type size into *size. More...
static st32	parse_type_outer (Context *ctx, const ut64 offset, RzStrBuf *strbuf, ut64 *size)
	Convenience function for calling parse_type with an empty visited set See documentation of parse_type. More...
static RzTypeStructMember *	parse_struct_member (Context *ctx, ut64 idx, RzTypeStructMember *result)
	Parses structured entry into *result RzTypeStructMember http://www.dwarfstd.org/doc/DWARF4.pdf#page=102&zoom=100,0,0. More...
static RzTypeEnumCase *	parse_enumerator (Context *ctx, ut64 idx, RzTypeEnumCase *result)
	Parses enum entry into *result RzTypeEnumCase http://www.dwarfstd.org/doc/DWARF4.pdf#page=110&zoom=100,0,0. More...
static void	parse_structure_type (Context *ctx, ut64 idx)
	Parses a structured entry (structs, classes, unions) into RzBaseType and saves it using rz_analysis_save_base_type () More...
static void	parse_enum_type (Context *ctx, ut64 idx)
	Parses a enum entry into RzBaseType and saves it int Sdb using rz_analysis_save_base_type () More...
static void	parse_typedef (Context *ctx, ut64 idx)
	Parses a typedef entry into RzBaseType and saves it using rz_analysis_save_base_type () More...
static void	parse_atomic_type (Context *ctx, ut64 idx)
static const char *	get_specification_die_name (const RzBinDwarfDie *die)
static void	get_spec_die_type (Context *ctx, RzBinDwarfDie *die, RzStrBuf *ret_type)
static bool	prefer_linkage_name (char *lang)
static void	parse_abstract_origin (Context *ctx, ut64 offset, RzStrBuf *type, const char **name)
static const char *	map_dwarf_reg_to_x86_64_reg (ut64 reg_num, VariableLocationKind *kind)
static const char *	map_dwarf_reg_to_x86_reg (ut64 reg_num, VariableLocationKind *kind)
static const char *	map_dwarf_reg_to_ppc64_reg (ut64 reg_num, VariableLocationKind *kind)
static const char *	get_dwarf_reg_name (RZ_NONNULL char *arch, int reg_num, VariableLocationKind *kind, int bits)
static RzBinDwarfLocRange *	find_largest_loc_range (RzList *loc_list)
static VariableLocation *	parse_dwarf_location (Context *ctx, const RzBinDwarfAttrValue *loc, const RzBinDwarfAttrValue *frame_base)
static st32	parse_function_args_and_vars (Context *ctx, ut64 idx, RzStrBuf *args, RzList *variables)
static void	sdb_save_dwarf_function (Function *dwarf_fcn, RzList *variables, Sdb *sdb)
static void	parse_function (Context *ctx, ut64 idx)
	Parse function,it's arguments, variables and save the information into the Sdb. More...
static char *	parse_comp_unit_lang (const RzBinDwarfDie *die)
	Get's language from comp unit for demangling. More...
static void	parse_type_entry (Context *ctx, ut64 idx)
	Delegates DIE to it's proper parsing method. More...
RZ_API void	rz_analysis_dwarf_process_info (const RzAnalysis *analysis, RzAnalysisDwarfContext *ctx)
	Parses type and function information out of DWARF entries and stores them to the sdb for further use. More...
bool	filter_sdb_function_names (void *user, const char *k, const char *v)
RZ_API void	rz_analysis_dwarf_integrate_functions (RzAnalysis *analysis, RzFlag *flags, Sdb *dwarf_sdb)
	Use parsed DWARF function info from Sdb in the function analysis XXX right now we only save parsed name and variables, we can't use signature now XXX refactor to be more readable. More...

Typedef Documentation

Context

PCONTEXT Context

Definition at line 138 of file windows_debug.h.

Function

typedef struct dwarf_function_t Function

Variable

typedef struct dwarf_variable_t Variable

VariableLocation

typedef struct dwarf_var_location_t VariableLocation

VariableLocationKind

typedef enum dwarf_location_kind VariableLocationKind

Enumeration Type Documentation

dwarf_location_kind

enum dwarf_location_kind

Enumerator
LOCATION_UNKNOWN
LOCATION_GLOBAL
LOCATION_BP
LOCATION_SP
LOCATION_REGISTER

Definition at line 34 of file dwarf_process.c.

                                 {
    LOCATION_UNKNOWN = 0,
    LOCATION_GLOBAL = 1,
    LOCATION_BP = 2,
    LOCATION_SP = 3,
    LOCATION_REGISTER = 4,
} VariableLocationKind;

Function Documentation

create_type_name_from_offset()

static char* create_type_name_from_offset ( ut64  offset )

inlinestatic

Definition at line 157 of file dwarf_process.c.

                                                              {
    return rz_str_newf("type_0x%" PFMT64x, offset);
}

References PFMT64x, and rz_str_newf().

Referenced by get_die_name(), and parse_atomic_type().

filter_sdb_function_names()

bool filter_sdb_function_names	(	void *	user,
		const char *	k,
		const char *	v
	)

Definition at line 1624 of file dwarf_process.c.

                                                                         {
    (void)user;
    (void)k;
    return !strcmp(v, "fcn");
}

References k, and v.

Referenced by rz_analysis_dwarf_integrate_functions().

find_attr()

static RzBinDwarfAttrValue* find_attr ( const RzBinDwarfDie *  die, st32  attr_name  )

static

Definition at line 75 of file dwarf_process.c.

                                                                                {
    st32 i;
    rz_return_val_if_fail(die, NULL);
    for (i = 0; i < die->count; i++) {
        if (die->attr_values[i].attr_name == attr_name) {
            return &die->attr_values[i];
        }
    }
    return NULL;
}

References dwarf_attr_kind::attr_name, RzBinDwarfDie::attr_values, RzBinDwarfDie::count, i, NULL, rz_return_val_if_fail, and st32.

Referenced by parse_function_args_and_vars().

find_attr_idx()

static st32 find_attr_idx ( const RzBinDwarfDie *  die, st32  attr_name  )

inlinestatic

Definition at line 63 of file dwarf_process.c.

                                                                           {
    st32 i;
    rz_return_val_if_fail(die, -1);
    for (i = 0; i < die->count; i++) {
        if (die->attr_values[i].attr_name == attr_name) {
            return i;
        }
    }
    return -1;
}

References dwarf_attr_kind::attr_name, RzBinDwarfDie::attr_values, RzBinDwarfDie::count, i, rz_return_val_if_fail, and st32.

Referenced by get_die_name(), get_die_size(), get_spec_die_type(), get_specification_die_name(), parse_comp_unit_lang(), parse_enum_type(), parse_function(), parse_structure_type(), and parse_type().

find_largest_loc_range()

static RzBinDwarfLocRange* find_largest_loc_range ( RzList *  loc_list )

static

Definition at line 997 of file dwarf_process.c.

                                                                    {
    RzBinDwarfLocRange *largest = NULL;
    ut64 max_range_size = 0;
    RzListIter *iter;
    RzBinDwarfLocRange *range;
    rz_list_foreach (loc_list, iter, range) {
        ut64 diff = range->end - range->start;
        if (diff > max_range_size) {
            max_range_size = diff;
            largest = range;
        }
    }
    return largest;
}

References NULL, capstone::range, and ut64().

Referenced by parse_dwarf_location().

get_die_name()

static char* get_die_name ( const RzBinDwarfDie *  die )

static

Get the DIE name or create unique one from its offset.

Parameters

die

Returns

char* DIEs name or NULL if error

Definition at line 167 of file dwarf_process.c.

                                                    {
    char *name = NULL;
    st32 name_attr_idx = find_attr_idx(die, DW_AT_name);
    if (name_attr_idx != -1) {
        const char *s = rz_bin_dwarf_attr_value_get_string_content(&die->attr_values[name_attr_idx]);
        name = RZ_STR_DUP(s);
    }
    return name ? name : create_type_name_from_offset(die->offset);
}

References RzBinDwarfDie::attr_values, create_type_name_from_offset(), DW_AT_name, find_attr_idx(), name, NULL, RzBinDwarfDie::offset, rz_bin_dwarf_attr_value_get_string_content(), RZ_STR_DUP, s, and st32.

Referenced by parse_enum_type(), parse_enumerator(), parse_struct_member(), parse_structure_type(), parse_type(), and parse_typedef().

get_die_size()

static ut64 get_die_size ( const RzBinDwarfDie *  die )

static

Get the DIE size in bits.

Parameters

die

Returns

ut64 size in bits or 0 if not found

Definition at line 183 of file dwarf_process.c.

                                                   {
    ut64 size = 0;
    st32 byte_size_idx = find_attr_idx(die, DW_AT_byte_size);
 
    if (byte_size_idx != -1) {
        size = die->attr_values[byte_size_idx].uconstant * CHAR_BIT;
    } else {
        st32 bit_size_idx = find_attr_idx(die, DW_AT_bit_size);
 
        if (bit_size_idx != -1) {
            size = die->attr_values[bit_size_idx].uconstant;
        }
    }
    return size;
}

References RzBinDwarfDie::attr_values, CHAR_BIT, DW_AT_bit_size, DW_AT_byte_size, find_attr_idx(), st32, dwarf_attr_kind::uconstant, and ut64().

Referenced by parse_enum_type(), parse_structure_type(), and parse_type().

get_dwarf_reg_name()

static const char* get_dwarf_reg_name ( RZ_NONNULL char *  arch, int  reg_num, VariableLocationKind *  kind, int  bits  )

static

Definition at line 981 of file dwarf_process.c.

                                                                                                                {
    if (!strcmp(arch, "x86")) {
        if (bits == 64) {
            return map_dwarf_reg_to_x86_64_reg(reg_num, kind);
        } else {
            return map_dwarf_reg_to_x86_reg(reg_num, kind);
        }
    } else if (!strcmp(arch, "ppc")) {
        if (bits == 64) {
            return map_dwarf_reg_to_ppc64_reg(reg_num, kind);
        }
    }
    *kind = LOCATION_UNKNOWN;
    return "unsupported_reg";
}

References arch, bits(), LOCATION_UNKNOWN, map_dwarf_reg_to_ppc64_reg(), map_dwarf_reg_to_x86_64_reg(), and map_dwarf_reg_to_x86_reg().

Referenced by parse_dwarf_location().

get_spec_die_type()

static void get_spec_die_type ( Context *  ctx, RzBinDwarfDie *  die, RzStrBuf *  ret_type  )

static

Definition at line 788 of file dwarf_process.c.

                                                                                    {
    st32 attr_idx = find_attr_idx(die, DW_AT_type);
    if (attr_idx != -1) {
        ut64 size = 0;
        parse_type_outer(ctx, die->attr_values[attr_idx].reference, ret_type, &size);
    }
}

References RzBinDwarfDie::attr_values, DW_AT_type, find_attr_idx(), parse_type_outer(), dwarf_attr_kind::reference, st32, and ut64().

Referenced by parse_function().

get_specification_die_name()

static const char* get_specification_die_name ( const RzBinDwarfDie *  die )

static

Definition at line 770 of file dwarf_process.c.

                                                                        {
    st32 linkage_name_attr_idx = find_attr_idx(die, DW_AT_linkage_name);
    if (linkage_name_attr_idx != -1) {
        const char *s = rz_bin_dwarf_attr_value_get_string_content(&die->attr_values[linkage_name_attr_idx]);
        if (s) {
            return s;
        }
    }
    st32 name_attr_idx = find_attr_idx(die, DW_AT_name);
    if (name_attr_idx != -1) {
        const char *s = rz_bin_dwarf_attr_value_get_string_content(&die->attr_values[name_attr_idx]);
        if (s) {
            return s;
        }
    }
    return NULL;
}

References RzBinDwarfDie::attr_values, DW_AT_linkage_name, DW_AT_name, find_attr_idx(), NULL, rz_bin_dwarf_attr_value_get_string_content(), s, and st32.

Referenced by parse_function().

map_dwarf_reg_to_ppc64_reg()

static const char* map_dwarf_reg_to_ppc64_reg ( ut64  reg_num, VariableLocationKind *  kind  )

static

Definition at line 935 of file dwarf_process.c.

                                                                                        {
    *kind = LOCATION_REGISTER;
    switch (reg_num) {
    case 0: return "r0";
    case 1:
        *kind = LOCATION_SP;
        return "r1";
    case 2: return "r2";
    case 3: return "r3";
    case 4: return "r4";
    case 5: return "r5";
    case 6: return "r6";
    case 7: return "r7";
    case 8: return "r8";
    case 9: return "r9";
    case 10: return "r10";
    case 11: return "r11";
    case 12: return "r12";
    case 13: return "r13";
    case 14: return "r14";
    case 15: return "r15";
    case 16: return "r16";
    case 17: return "r17";
    case 18: return "r18";
    case 19: return "r19";
    case 20: return "r20";
    case 21: return "r21";
    case 22: return "r22";
    case 23: return "r23";
    case 24: return "r24";
    case 25: return "r25";
    case 26: return "r26";
    case 27: return "r27";
    case 28: return "r28";
    case 29: return "r29";
    case 30: return "r30";
    case 31: return "r31";
    default:
        rz_warn_if_reached();
        *kind = LOCATION_UNKNOWN;
        return "unsupported_reg";
    }
}

References LOCATION_REGISTER, LOCATION_SP, LOCATION_UNKNOWN, and rz_warn_if_reached.

Referenced by get_dwarf_reg_name().

map_dwarf_reg_to_x86_64_reg()

static const char* map_dwarf_reg_to_x86_64_reg ( ut64  reg_num, VariableLocationKind *  kind  )

static

Definition at line 841 of file dwarf_process.c.

                                                                                         {
    *kind = LOCATION_REGISTER;
    switch (reg_num) {
    case 0: return "rax";
    case 1: return "rdx";
    case 2: return "rcx";
    case 3: return "rbx";
    case 4: return "rsi";
    case 5: return "rdi";
    case 6:
        *kind = LOCATION_BP;
        return "rbp";
    case 7:
        *kind = LOCATION_SP;
        return "rsp";
    case 8: return "r8";
    case 9: return "r9";
    case 10: return "r10";
    case 11: return "r11";
    case 12: return "r12";
    case 13: return "r13";
    case 14: return "r14";
    case 15: return "r15";
    case 17: return "xmm0";
    case 18: return "xmm1";
    case 19: return "xmm2";
    case 20: return "xmm3";
    case 21: return "xmm4";
    case 22: return "xmm5";
    case 23: return "xmm6";
    case 24: return "xmm7";
    default:
        *kind = LOCATION_UNKNOWN;
        return "unsupported_reg";
    }
}

References LOCATION_BP, LOCATION_REGISTER, LOCATION_SP, and LOCATION_UNKNOWN.

Referenced by get_dwarf_reg_name().

map_dwarf_reg_to_x86_reg()

static const char* map_dwarf_reg_to_x86_reg ( ut64  reg_num, VariableLocationKind *  kind  )

static

Definition at line 879 of file dwarf_process.c.

                                                                                      {
    *kind = LOCATION_REGISTER;
    switch (reg_num) {
    case 0:
    case 8:
        return "eax";
    case 1: return "edx";
    case 2: return "ecx";
    case 3: return "ebx";
    case 4:
        *kind = LOCATION_SP;
        return "esp";
    case 5:
        *kind = LOCATION_BP;
        return "ebp";
    case 6: return "esi";
    case 7: return "edi";
    case 9: return "EFLAGS";
    case 11: return "st0";
    case 12: return "st1";
    case 13: return "st2";
    case 14: return "st3";
    case 15: return "st4";
    case 16: return "st5";
    case 17: return "st6";
    case 18: return "st7";
    case 21: return "xmm0";
    case 22: return "xmm1";
    case 23: return "xmm2";
    case 24: return "xmm3";
    case 25: return "xmm4";
    case 26: return "xmm5";
    case 27: return "xmm6";
    case 28: return "xmm7";
    case 29: return "mm0";
    case 30: return "mm1";
    case 31: return "mm2";
    case 32: return "mm3";
    case 33: return "mm4";
    case 34: return "mm5";
    case 35: return "mm6";
    case 36: return "mm7";
    case 40: return "es";
    case 41: return "cs";
    case 42: return "ss";
    case 43: return "ds";
    case 44: return "fs";
    case 45: return "gs";
    default:
        rz_warn_if_reached();
        *kind = LOCATION_UNKNOWN;
        return "unsupported_reg";
    }
}

References LOCATION_BP, LOCATION_REGISTER, LOCATION_SP, LOCATION_UNKNOWN, and rz_warn_if_reached.

Referenced by get_dwarf_reg_name().

parse_abstract_origin()

static void parse_abstract_origin ( Context *  ctx, ut64  offset, RzStrBuf *  type, const char **  name  )

static

Definition at line 810 of file dwarf_process.c.

                                                                                                {
    RzBinDwarfDie *die = ht_up_find(ctx->die_map, offset, NULL);
    if (die) {
        size_t i;
        ut64 size = 0;
        bool has_linkage_name = false;
        bool get_linkage_name = prefer_linkage_name(ctx->lang);
        for (i = 0; i < die->count; i++) {
            const RzBinDwarfAttrValue *val = &die->attr_values[i];
            switch (val->attr_name) {
            case DW_AT_name:
                if (!get_linkage_name || !has_linkage_name) {
                    *name = val->string.content;
                }
                break;
            case DW_AT_linkage_name:
            case DW_AT_MIPS_linkage_name:
                *name = val->string.content;
                has_linkage_name = true;
                break;
            case DW_AT_type:
                parse_type_outer(ctx, val->reference, type, &size);
                break;
            default:
                break;
            }
        }
    }
}

References RzBinDwarfDie::attr_values, RzBinDwarfDie::count, DW_AT_linkage_name, DW_AT_MIPS_linkage_name, DW_AT_name, DW_AT_type, i, NULL, parse_type_outer(), prefer_linkage_name(), type, ut64(), and val.

Referenced by parse_function_args_and_vars().

parse_array_type()

static st32 parse_array_type ( Context *  ctx, ut64  idx, RzStrBuf *  strbuf  )

static

Parses array type entry signature into strbuf.

Parameters

ctx
idx	index of the current entry
strbuf	strbuf to store the type into

Returns

st32 -1 if error else 0

Definition at line 207 of file dwarf_process.c.

                                                                       {
    const RzBinDwarfDie *die = &ctx->all_dies[idx++];
 
    if (die->has_children) {
        int child_depth = 1;
        size_t j;
        for (j = idx; child_depth > 0 && j < ctx->count; j++) {
            const RzBinDwarfDie *child_die = &ctx->all_dies[j];
            // right now we skip non direct descendats of the structure
            // can be also DW_TAG_suprogram for class methods or tag for templates
            if (child_depth == 1 && child_die->tag == DW_TAG_subrange_type) {
                size_t i;
                for (i = 0; i < child_die->count; i++) {
                    const RzBinDwarfAttrValue *value = &child_die->attr_values[i];
                    switch (value->attr_name) {
                    case DW_AT_upper_bound:
                    case DW_AT_count:
                        rz_strbuf_appendf(strbuf, "[%" PFMT64d "]", value->uconstant + 1);
                        break;
 
                    default:
                        break;
                    }
                }
            }
            if (child_die->has_children) {
                child_depth++;
            }
            // sibling list is terminated by null entry
            if (child_die->abbrev_code == 0) {
                child_depth--;
            }
        }
    }
    return 0;
}

References RzBinDwarfDie::abbrev_code, RzBinDwarfDie::attr_values, RzBinDwarfDie::count, DW_AT_count, DW_AT_upper_bound, DW_TAG_subrange_type, RzBinDwarfDie::has_children, i, setup::idx, PFMT64d, rz_strbuf_appendf(), RzBinDwarfDie::tag, and value.

Referenced by parse_type().

parse_atomic_type()

static void parse_atomic_type ( Context *  ctx, ut64  idx  )

static

Definition at line 723 of file dwarf_process.c.

                                                      {
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
 
    char *name = NULL;
    ut64 size = 0;
    size_t i;
    // TODO support endiannity and encoding in future?
    for (i = 0; i < die->count; i++) {
        RzBinDwarfAttrValue *value = &die->attr_values[i];
        switch (die->attr_values[i].attr_name) {
        case DW_AT_name: {
            free(name);
            const char *s = rz_bin_dwarf_attr_value_get_string_content(&die->attr_values[i]);
            if (s) {
                name = strdup(s);
            } else {
                name = create_type_name_from_offset(die->offset);
            }
            if (!name) {
                return;
            }
            break;
        }
        case DW_AT_byte_size:
            size = value->uconstant * CHAR_BIT;
            break;
        case DW_AT_bit_size:
            size = value->uconstant;
            break;
        case DW_AT_encoding:
        default:
            break;
        }
    }
    if (!name) { // type has to have a name for now
        return;
    }
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ATOMIC);
    if (!base_type) {
        free(name);
        return;
    }
    base_type->name = name;
    base_type->size = size;
    rz_type_db_save_base_type(ctx->analysis->typedb, base_type);
}

References dwarf_attr_kind::attr_name, RzBinDwarfDie::attr_values, CHAR_BIT, RzBinDwarfDie::count, create_type_name_from_offset(), DW_AT_bit_size, DW_AT_byte_size, DW_AT_encoding, DW_AT_name, free(), i, setup::idx, name, rz_base_type_t::name, NULL, RzBinDwarfDie::offset, RZ_BASE_TYPE_KIND_ATOMIC, rz_bin_dwarf_attr_value_get_string_content(), rz_type_base_type_new(), rz_type_db_save_base_type(), s, rz_base_type_t::size, strdup(), ut64(), and value.

Referenced by parse_type_entry().

parse_comp_unit_lang()

static char* parse_comp_unit_lang ( const RzBinDwarfDie *  die )

static

Get's language from comp unit for demangling.

Parameters

die

Returns

char* string literal language represantation for demangling BinDemangle

Definition at line 1506 of file dwarf_process.c.

                                                            {
    rz_return_val_if_fail(die, NULL);
 
    int idx = find_attr_idx(die, DW_AT_language);
    char *lang = "cxx"; // default fallback
    if (idx == -1) {
        /* What to do now, it should have  one?, just assume C++ */
        return lang;
    }
    const RzBinDwarfAttrValue *val = &die->attr_values[idx];
    rz_warn_if_fail(val->kind == DW_AT_KIND_CONSTANT);
 
    switch (val->uconstant) {
    case DW_LANG_Java:
        return "java";
    case DW_LANG_ObjC:
    /* subideal, TODO research if dwarf gives me enough info to properly separate C++ and ObjC mangling */
    case DW_LANG_ObjC_plus_plus:
        return "objc";
    case DW_LANG_D:
        return "dlang";
    case DW_LANG_Rust:
        return "rust";
    case DW_LANG_C_plus_plus:
    case DW_LANG_C_plus_plus_14:
    /* no demangling available */
    case DW_LANG_Ada83:
    case DW_LANG_Cobol74:
    case DW_LANG_Cobol85:
    case DW_LANG_Fortran77:
    case DW_LANG_Fortran90:
    case DW_LANG_Pascal83:
    case DW_LANG_Modula2:
    case DW_LANG_Ada95:
    case DW_LANG_Fortran95:
    case DW_LANG_PLI:
    case DW_LANG_Python:
    case DW_LANG_Swift:
    case DW_LANG_Julia:
    case DW_LANG_Dylan:
    case DW_LANG_Fortran03:
    case DW_LANG_Fortran08:
    case DW_LANG_UPC:
    case DW_LANG_C:
    case DW_LANG_C89:
    case DW_LANG_C99:
    case DW_LANG_C11:
    default:
        return lang;
    }
    return lang;
}

References RzBinDwarfDie::attr_values, DW_AT_KIND_CONSTANT, DW_AT_language, DW_LANG_Ada83, DW_LANG_Ada95, DW_LANG_C, DW_LANG_C11, DW_LANG_C89, DW_LANG_C99, DW_LANG_C_plus_plus, DW_LANG_C_plus_plus_14, DW_LANG_Cobol74, DW_LANG_Cobol85, DW_LANG_D, DW_LANG_Dylan, DW_LANG_Fortran03, DW_LANG_Fortran08, DW_LANG_Fortran77, DW_LANG_Fortran90, DW_LANG_Fortran95, DW_LANG_Java, DW_LANG_Julia, DW_LANG_Modula2, DW_LANG_ObjC, DW_LANG_ObjC_plus_plus, DW_LANG_Pascal83, DW_LANG_PLI, DW_LANG_Python, DW_LANG_Rust, DW_LANG_Swift, DW_LANG_UPC, find_attr_idx(), setup::idx, NULL, rz_return_val_if_fail, rz_warn_if_fail, and val.

Referenced by parse_type_entry().

parse_dwarf_location()

static VariableLocation* parse_dwarf_location ( Context *  ctx, const RzBinDwarfAttrValue *  loc, const RzBinDwarfAttrValue *  frame_base  )

static

Definition at line 1013 of file dwarf_process.c.

                                                                                                                                   {
    /* reg5 - val is in register 5
    fbreg <leb> - offset from frame base
    regx <leb> - contents is in register X
    addr <addr> - contents is in at addr
    bregXX <leb> - contents is at offset from specified register
    - we now support 3 options: SP, BP and register based arguments */
 
    /* Loclist offset is usually CONSTANT or REFERENCE at older DWARF versions, new one has LocListPtr for that */
    if (loc->kind != DW_AT_KIND_BLOCK && loc->kind != DW_AT_KIND_LOCLISTPTR && loc->kind != DW_AT_KIND_REFERENCE && loc->kind != DW_AT_KIND_CONSTANT) {
        return NULL;
    }
    RzBinDwarfBlock block;
    if (loc->kind == DW_AT_KIND_LOCLISTPTR || loc->kind == DW_AT_KIND_REFERENCE || loc->kind == DW_AT_KIND_CONSTANT) {
        ut64 offset = loc->reference;
        RzBinDwarfLocList *range_list = ht_up_find(ctx->locations, offset, NULL);
        if (!range_list) { /* for some reason offset isn't there, wrong parsing or malformed dwarf */
            return NULL;
        }
        /* use the largest range as a variable */
        RzBinDwarfLocRange *range = find_largest_loc_range(range_list->list);
        if (!range) {
            return NULL;
        }
        /* Very rough and sloppy, refactor this hacked up stuff */
        block = *range->expression;
        // range->expression... etc
    } else {
        block = loc->block;
    }
    VariableLocationKind kind = LOCATION_UNKNOWN;
    st64 offset = 0;
    ut64 address = 0;
    ut64 reg_num = -1;
    const char *reg_name = NULL; /* literal */
    size_t i;
    for (i = 0; i < block.length; i++) {
        switch (block.data[i]) {
        case DW_OP_fbreg: {
            /* TODO sometimes CFA is referenced, but we don't parse that yet
           just an offset involving framebase of a function*/
            if (i == block.length - 1) {
                return NULL;
            }
            const ut8 *dump = &block.data[++i];
            offset = rz_sleb128(&dump, &block.data[loc->block.length]);
            if (frame_base) {
                /* recursive parsing, but frame_base should be only one, but someone
                   could make malicious resource exhaustion attack, so a depth counter might be cool? */
                VariableLocation *location = parse_dwarf_location(ctx, frame_base, NULL);
                if (location) {
                    location->offset += offset;
                    return location;
                }
                return NULL;
            } else {
                /* Might happen if frame_base has a frame_base reference? I don't think it can tho */
                return NULL;
            }
        } break;
        case DW_OP_reg0:
        case DW_OP_reg1:
        case DW_OP_reg2:
        case DW_OP_reg3:
        case DW_OP_reg4:
        case DW_OP_reg5:
        case DW_OP_reg6:
        case DW_OP_reg7:
        case DW_OP_reg8:
        case DW_OP_reg9:
        case DW_OP_reg10:
        case DW_OP_reg11:
        case DW_OP_reg12:
        case DW_OP_reg13:
        case DW_OP_reg14:
        case DW_OP_reg15:
        case DW_OP_reg16:
        case DW_OP_reg17:
        case DW_OP_reg18:
        case DW_OP_reg19:
        case DW_OP_reg20:
        case DW_OP_reg21:
        case DW_OP_reg22:
        case DW_OP_reg23:
        case DW_OP_reg24:
        case DW_OP_reg25:
        case DW_OP_reg26:
        case DW_OP_reg27:
        case DW_OP_reg28:
        case DW_OP_reg29:
        case DW_OP_reg30:
        case DW_OP_reg31: {
            /* Will mostly be used for SP based arguments */
            /* TODO I need to find binaries that uses this so I can test it out*/
            reg_num = block.data[i] - DW_OP_reg0; // get the reg number
            reg_name = get_dwarf_reg_name(ctx->analysis->cpu, reg_num, &kind, ctx->analysis->bits);
        } break;
        case DW_OP_breg0:
        case DW_OP_breg1:
        case DW_OP_breg2:
        case DW_OP_breg3:
        case DW_OP_breg4:
        case DW_OP_breg5:
        case DW_OP_breg6:
        case DW_OP_breg7:
        case DW_OP_breg8:
        case DW_OP_breg9:
        case DW_OP_breg10:
        case DW_OP_breg11:
        case DW_OP_breg12:
        case DW_OP_breg13:
        case DW_OP_breg14:
        case DW_OP_breg15:
        case DW_OP_breg16:
        case DW_OP_breg17:
        case DW_OP_breg18:
        case DW_OP_breg19:
        case DW_OP_breg20:
        case DW_OP_breg21:
        case DW_OP_breg22:
        case DW_OP_breg23:
        case DW_OP_breg24:
        case DW_OP_breg25:
        case DW_OP_breg26:
        case DW_OP_breg27:
        case DW_OP_breg28:
        case DW_OP_breg29:
        case DW_OP_breg30:
        case DW_OP_breg31: {
            if (i == block.length - 1) {
                return NULL;
            }
            /* The single operand of the DW_OP_bregn operations provides
            signed LEB128 offset from the specified register.  */
            reg_num = block.data[i] - DW_OP_breg0; // get the reg number
            const ut8 *buffer = &block.data[++i];
            offset = rz_sleb128(&buffer, &block.data[block.length]);
            /* TODO do a proper expression parsing, move by the amount of bytes sleb reads */
            i += buffer - &block.data[0];
            reg_name = get_dwarf_reg_name(ctx->analysis->cpu, reg_num, &kind, ctx->analysis->bits);
        } break;
        case DW_OP_bregx: {
            if (i == block.length - 1) {
                return NULL;
            }
            /* 2 operands, reg_number, offset*/
            /* I need to find binaries that uses this so I can test it out*/
            const ut8 *buffer = &block.data[++i];
            const ut8 *buf_end = &block.data[block.length];
            buffer = rz_uleb128(buffer, buf_end - buffer, &reg_num, NULL);
            if (buffer == buf_end) {
                return NULL;
            }
            offset = rz_sleb128(&buffer, buf_end);
            reg_name = get_dwarf_reg_name(ctx->analysis->cpu, reg_num, &kind, ctx->analysis->bits);
        } break;
        case DW_OP_addr: {
            /* The DW_OP_addr operation has a single operand that encodes a machine address and whose
            size is the size of an address on the target machine.  */
            const int addr_size = ctx->analysis->bits / 8;
            const ut8 *dump = &block.data[++i];
            /* malformed, not enough bytes to represent address */
            if (block.length - i < addr_size) {
                return NULL;
            }
            switch (addr_size) {
            case 1:
                address = rz_read_ble8(dump);
                break;
            case 2:
                address = rz_read_ble16(dump, ctx->analysis->big_endian);
                break;
            case 4:
                address = rz_read_ble32(dump, ctx->analysis->big_endian);
                break;
            case 8:
                address = rz_read_ble64(dump, ctx->analysis->big_endian);
                break;
            default:
                rz_warn_if_reached(); /* weird addr_size */
                return NULL;
            }
            kind = LOCATION_GLOBAL; // address
        } break;
        case DW_OP_call_frame_cfa: {
            // REMOVE XXX
            kind = LOCATION_BP;
            offset += 16;
        } break;
        default:
            break;
        }
    }
    if (kind == LOCATION_UNKNOWN) {
        return NULL;
    }
    VariableLocation *location = RZ_NEW0(VariableLocation);
    if (location) {
        location->reg_name = reg_name;
        location->reg_num = reg_num;
        location->kind = kind;
        location->offset = offset;
        location->address = address;
    }
    return location;
}

References dwarf_var_location_t::address, dwarf_attr_kind::block, RzBinDwarfBlock::data, DW_AT_KIND_BLOCK, DW_AT_KIND_CONSTANT, DW_AT_KIND_LOCLISTPTR, DW_AT_KIND_REFERENCE, DW_OP_addr, DW_OP_breg0, DW_OP_breg1, DW_OP_breg10, DW_OP_breg11, DW_OP_breg12, DW_OP_breg13, DW_OP_breg14, DW_OP_breg15, DW_OP_breg16, DW_OP_breg17, DW_OP_breg18, DW_OP_breg19, DW_OP_breg2, DW_OP_breg20, DW_OP_breg21, DW_OP_breg22, DW_OP_breg23, DW_OP_breg24, DW_OP_breg25, DW_OP_breg26, DW_OP_breg27, DW_OP_breg28, DW_OP_breg29, DW_OP_breg3, DW_OP_breg30, DW_OP_breg31, DW_OP_breg4, DW_OP_breg5, DW_OP_breg6, DW_OP_breg7, DW_OP_breg8, DW_OP_breg9, DW_OP_bregx, DW_OP_call_frame_cfa, DW_OP_fbreg, DW_OP_reg0, DW_OP_reg1, DW_OP_reg10, DW_OP_reg11, DW_OP_reg12, DW_OP_reg13, DW_OP_reg14, DW_OP_reg15, DW_OP_reg16, DW_OP_reg17, DW_OP_reg18, DW_OP_reg19, DW_OP_reg2, DW_OP_reg20, DW_OP_reg21, DW_OP_reg22, DW_OP_reg23, DW_OP_reg24, DW_OP_reg25, DW_OP_reg26, DW_OP_reg27, DW_OP_reg28, DW_OP_reg29, DW_OP_reg3, DW_OP_reg30, DW_OP_reg31, DW_OP_reg4, DW_OP_reg5, DW_OP_reg6, DW_OP_reg7, DW_OP_reg8, DW_OP_reg9, find_largest_loc_range(), get_dwarf_reg_name(), i, dwarf_var_location_t::kind, dwarf_attr_kind::kind, RzBinDwarfBlock::length, rz_bin_dwarf_loc_list_t::list, LOCATION_BP, LOCATION_GLOBAL, LOCATION_UNKNOWN, NULL, dwarf_var_location_t::offset, capstone::range, dwarf_attr_kind::reference, dwarf_var_location_t::reg_name, dwarf_var_location_t::reg_num, RZ_NEW0, rz_read_ble16(), rz_read_ble32(), rz_read_ble64(), rz_read_ble8(), rz_sleb128(), rz_uleb128(), rz_warn_if_reached, st64, and ut64().

Referenced by parse_function_args_and_vars().

parse_enum_type()

static void parse_enum_type ( Context *  ctx, ut64  idx  )

static

Parses a enum entry into RzBaseType and saves it int Sdb using rz_analysis_save_base_type ()

Parameters

ctx
idx	index of the current entry

Definition at line 600 of file dwarf_process.c.

                                                    {
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
 
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ENUM);
    if (!base_type) {
        return;
    }
 
    base_type->name = get_die_name(die);
    if (!base_type->name) {
        rz_type_base_type_free(base_type);
        return;
    }
    base_type->size = get_die_size(die);
 
    st32 type_attr_idx = find_attr_idx(die, DW_AT_type);
    if (type_attr_idx != -1) {
        RzStrBuf strbuf;
        rz_strbuf_init(&strbuf);
        parse_type_outer(ctx, die->attr_values[type_attr_idx].reference, &strbuf, &base_type->size);
        char *type = rz_strbuf_drain_nofree(&strbuf);
        base_type->type = rz_type_parse_string_single(ctx->analysis->typedb->parser, type, NULL);
        free(type);
        if (!base_type->type) {
            rz_type_base_type_free(base_type);
            return;
        }
    }
 
    RzTypeEnumCase cas;
    if (die->has_children) {
        int child_depth = 1; // Direct children of the node
        size_t j;
        idx++; // Move to the first children node
        for (j = idx; child_depth > 0 && j < ctx->count; j++) {
            const RzBinDwarfDie *child_die = &ctx->all_dies[j];
            // we take only direct descendats of the structure
            if (child_depth == 1 && child_die->tag == DW_TAG_enumerator) {
                RzTypeEnumCase *result = parse_enumerator(ctx, j, &cas);
                if (!result) {
                    rz_type_base_type_free(base_type);
                    return;
                } else {
                    void *element = rz_vector_push(&base_type->enum_data.cases, &cas);
                    if (!element) {
                        rz_type_base_enum_case_free(result, NULL);
                        rz_type_base_type_free(base_type);
                        return;
                    }
                }
            }
            if (child_die->has_children) {
                child_depth++;
            }
            // sibling list is terminated by null entry
            if (child_die->abbrev_code == 0) {
                child_depth--;
            }
        }
    }
    rz_type_db_save_base_type(ctx->analysis->typedb, base_type);
}

References RzBinDwarfDie::abbrev_code, RzBinDwarfDie::attr_values, rz_base_type_enum_t::cases, DW_AT_type, DW_TAG_enumerator, rz_base_type_t::enum_data, find_attr_idx(), free(), get_die_name(), get_die_size(), RzBinDwarfDie::has_children, setup::idx, rz_base_type_t::name, NULL, parse_enumerator(), parse_type_outer(), dwarf_attr_kind::reference, RZ_BASE_TYPE_KIND_ENUM, rz_strbuf_drain_nofree(), rz_strbuf_init(), rz_type_base_enum_case_free(), rz_type_base_type_free(), rz_type_base_type_new(), rz_type_db_save_base_type(), rz_type_parse_string_single(), rz_vector_push(), rz_base_type_t::size, st32, RzBinDwarfDie::tag, type, and rz_base_type_t::type.

Referenced by parse_type_entry().

parse_enumerator()

static RzTypeEnumCase* parse_enumerator ( Context *  ctx, ut64  idx, RzTypeEnumCase *  result  )

static

Parses enum entry into *result RzTypeEnumCase http://www.dwarfstd.org/doc/DWARF4.pdf#page=110&zoom=100,0,0.

Parameters

ctx
idx	index of the current entry
result	ptr to result case to fill up

Returns

RzTypeEnumCase* Ptr to parsed enum case

Definition at line 478 of file dwarf_process.c.

                                                                                        {
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
 
    char *name = NULL;
    int val = 0;
    size_t i;
 
    // Enumerator has DW_AT_name and DW_AT_const_value
    for (i = 0; i < die->count; i++) {
        RzBinDwarfAttrValue *value = &die->attr_values[i];
        switch (die->attr_values[i].attr_name) {
        case DW_AT_name:
            free(name);
            name = get_die_name(die);
            if (!name) {
                goto cleanup;
            }
            break;
        case DW_AT_const_value:
            // ?? can be block, sdata, data, string w/e
            val = value->uconstant; // TODO solve the encoding, I don't know in which union member is it store
            break;
        default:
            break;
        }
    }
 
    result->name = name;
    result->val = (int)val;
    return result;
cleanup:
    free(name);
    return NULL;
}

References dwarf_attr_kind::attr_name, RzBinDwarfDie::attr_values, cleanup(), RzBinDwarfDie::count, DW_AT_const_value, DW_AT_name, free(), get_die_name(), i, setup::idx, int, name, rz_type_enum_case_t::name, NULL, val, rz_type_enum_case_t::val, and value.

Referenced by parse_enum_type().

parse_function()

static void parse_function ( Context *  ctx, ut64  idx  )

static

Parse function,it's arguments, variables and save the information into the Sdb.

Parameters

ctx
idx	Current entry index

Definition at line 1400 of file dwarf_process.c.

                                                   {
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
 
    Function fcn = { 0 };
    bool has_linkage_name = false;
    bool get_linkage_name = prefer_linkage_name(ctx->lang);
    RzStrBuf ret_type;
    rz_strbuf_init(&ret_type);
    if (find_attr_idx(die, DW_AT_declaration) != -1) {
        return; /* just declaration skip */
    }
    size_t i;
    /* For rust binaries prefer regular name not linkage TODO */
    for (i = 0; i < die->count; i++) {
        RzBinDwarfAttrValue *val = &die->attr_values[i];
        switch (die->attr_values[i].attr_name) {
        case DW_AT_name:
            if (!get_linkage_name || !has_linkage_name) {
                fcn.name = val->kind == DW_AT_KIND_STRING ? val->string.content : fcn.name;
            }
            break;
        case DW_AT_linkage_name:
        case DW_AT_MIPS_linkage_name:
            fcn.name = val->kind == DW_AT_KIND_STRING ? val->string.content : fcn.name;
            has_linkage_name = true;
            break;
        case DW_AT_low_pc:
        case DW_AT_entry_pc:
            fcn.addr = val->kind == DW_AT_KIND_ADDRESS ? val->address : fcn.addr;
            break;
        case DW_AT_specification: /* reference to declaration DIE with more info */
        {
            RzBinDwarfDie *spec_die = ht_up_find(ctx->die_map, val->reference, NULL);
            if (spec_die) {
                fcn.name = get_specification_die_name(spec_die); /* I assume that if specification has a name, this DIE hasn't */
                get_spec_die_type(ctx, spec_die, &ret_type);
            }
        } break;
        case DW_AT_type:
            parse_type_outer(ctx, val->reference, &ret_type, NULL);
            break;
        case DW_AT_virtuality:
            fcn.is_method = true; /* method specific attr */
            fcn.is_virtual = true;
            break;
        case DW_AT_object_pointer:
            fcn.is_method = true;
            break;
        case DW_AT_vtable_elem_location:
            fcn.is_method = true;
            fcn.vtable_addr = 0; /* TODO we might use this information */
            break;
        case DW_AT_accessibility:
            fcn.is_method = true;
            fcn.access = (ut8)val->uconstant;
            break;
        case DW_AT_external:
            fcn.is_external = true;
            break;
        case DW_AT_trampoline:
            fcn.is_trampoline = true;
            break;
        case DW_AT_ranges:
        case DW_AT_high_pc:
        default:
            break;
        }
    }
    if (!fcn.name || !fcn.addr) { /* we need a name, faddr */
        goto cleanup;
    }
    RzStrBuf args;
    rz_strbuf_init(&args);
    /* TODO do the same for arguments in future so we can use their location */
    RzList /*<Variable*>*/ *variables = rz_list_new();
    parse_function_args_and_vars(ctx, idx, &args, variables);
 
    if (ret_type.len == 0) { /* DW_AT_type is omitted in case of `void` ret type */
        rz_strbuf_append(&ret_type, "void");
    }
    rz_warn_if_fail(ctx->lang);
    char *new_name = ctx->analysis->binb.demangle(NULL, ctx->lang, fcn.name, fcn.addr, false);
    fcn.name = new_name ? new_name : strdup(fcn.name);
    fcn.signature = rz_str_newf("%s %s(%s);", rz_strbuf_get(&ret_type), fcn.name, rz_strbuf_get(&args));
    sdb_save_dwarf_function(&fcn, variables, ctx->sdb);
 
    free((char *)fcn.signature);
    free((char *)fcn.name);
 
    RzListIter *iter;
    Variable *var;
    rz_list_foreach (variables, iter, var) {
        variable_free(var);
    }
    rz_list_free(variables);
    rz_strbuf_fini(&args);
cleanup:
    rz_strbuf_fini(&ret_type);
}

References dwarf_function_t::access, dwarf_function_t::addr, args, dwarf_attr_kind::attr_name, RzBinDwarfDie::attr_values, cleanup(), RzBinDwarfDie::count, DW_AT_accessibility, DW_AT_declaration, DW_AT_entry_pc, DW_AT_external, DW_AT_high_pc, DW_AT_KIND_ADDRESS, DW_AT_KIND_STRING, DW_AT_linkage_name, DW_AT_low_pc, DW_AT_MIPS_linkage_name, DW_AT_name, DW_AT_object_pointer, DW_AT_ranges, DW_AT_specification, DW_AT_trampoline, DW_AT_type, DW_AT_virtuality, DW_AT_vtable_elem_location, find_attr_idx(), free(), get_spec_die_type(), get_specification_die_name(), i, setup::idx, dwarf_function_t::is_external, dwarf_function_t::is_method, dwarf_function_t::is_trampoline, dwarf_function_t::is_virtual, RzStrBuf::len, dwarf_function_t::name, NULL, parse_function_args_and_vars(), parse_type_outer(), prefer_linkage_name(), rz_list_free(), rz_list_new(), rz_str_newf(), rz_strbuf_append(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_warn_if_fail, sdb_save_dwarf_function(), dwarf_function_t::signature, strdup(), ut8, val, variable_free(), and dwarf_function_t::vtable_addr.

Referenced by parse_type_entry().

parse_function_args_and_vars()

static st32 parse_function_args_and_vars ( Context *  ctx, ut64  idx, RzStrBuf *  args, RzList *  variables  )

static

Definition at line 1220 of file dwarf_process.c.

                                                                                                      {
    const RzBinDwarfDie *die = &ctx->all_dies[idx++];
 
    if (die->has_children) {
        int child_depth = 1;
 
        bool get_linkage_name = prefer_linkage_name(ctx->lang);
        bool has_linkage_name = false;
        int argNumber = 1;
        size_t j;
        for (j = idx; child_depth > 0 && j < ctx->count; j++) {
            const RzBinDwarfDie *child_die = &ctx->all_dies[j];
            RzStrBuf type;
            rz_strbuf_init(&type);
            const char *name = NULL;
            if (child_die->tag == DW_TAG_formal_parameter || child_die->tag == DW_TAG_variable) {
                Variable *var = RZ_NEW0(Variable);
                size_t i;
                for (i = 0; i < child_die->count; i++) {
                    const RzBinDwarfAttrValue *val = &child_die->attr_values[i];
                    switch (val->attr_name) {
                    case DW_AT_name:
                        if (!get_linkage_name || !has_linkage_name) {
                            name = val->string.content;
                        }
                        break;
                    case DW_AT_linkage_name:
                    case DW_AT_MIPS_linkage_name:
                        name = val->string.content;
                        has_linkage_name = true;
                        break;
                    case DW_AT_type:
                        parse_type_outer(ctx, val->reference, &type, NULL);
                        break;
                    // abstract origin is supposed to have omitted information
                    case DW_AT_abstract_origin:
                        parse_abstract_origin(ctx, val->reference, &type, &name);
                        break;
                    case DW_AT_location:
                        var->location = parse_dwarf_location(ctx, val, find_attr(die, DW_AT_frame_base));
                        break;
                    default:
                        break;
                    }
                }
                if (child_die->tag == DW_TAG_formal_parameter && child_depth == 1) {
                    /* arguments sometimes have only type, create generic argX */
                    if (type.len) {
                        if (!name) {
                            var->name = rz_str_newf("arg%d", argNumber);
                        } else {
                            var->name = strdup(name);
                        }
                        rz_strbuf_appendf(args, "%s %s,", rz_strbuf_get(&type), var->name);
                        var->type = strdup(rz_strbuf_get(&type));
                        rz_list_append(variables, var);
                    } else {
                        variable_free(var);
                    }
                    argNumber++;
                } else { /* DW_TAG_variable */
                    if (name && type.len) {
                        var->name = strdup(name);
                        var->type = strdup(rz_strbuf_get(&type));
                        rz_list_append(variables, var);
                    } else {
                        variable_free(var);
                    }
                    rz_strbuf_fini(&type);
                }
            } else if (child_depth == 1 && child_die->tag == DW_TAG_unspecified_parameters) {
                rz_strbuf_appendf(args, "va_args ...,");
            }
            if (child_die->has_children) {
                child_depth++;
            }
            if (child_die->abbrev_code == 0) { /* sibling list is terminated by null entry */
                child_depth--;
            }
            rz_strbuf_fini(&type);
        }
        if (args->len > 0) {
            rz_strbuf_slice(args, 0, args->len - 1);
        }
    }
    return 0;
}

References RzBinDwarfDie::abbrev_code, args, RzBinDwarfDie::attr_values, RzBinDwarfDie::count, DW_AT_abstract_origin, DW_AT_frame_base, DW_AT_linkage_name, DW_AT_location, DW_AT_MIPS_linkage_name, DW_AT_name, DW_AT_type, DW_TAG_formal_parameter, DW_TAG_unspecified_parameters, DW_TAG_variable, find_attr(), RzBinDwarfDie::has_children, i, setup::idx, dwarf_variable_t::location, dwarf_variable_t::name, NULL, parse_abstract_origin(), parse_dwarf_location(), parse_type_outer(), prefer_linkage_name(), rz_list_append(), RZ_NEW0, rz_str_newf(), rz_strbuf_appendf(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_slice(), strdup(), RzBinDwarfDie::tag, dwarf_variable_t::type, type, val, and variable_free().

Referenced by parse_function().

parse_struct_member()

static RzTypeStructMember* parse_struct_member ( Context *  ctx, ut64  idx, RzTypeStructMember *  result  )

static

Parses structured entry into *result RzTypeStructMember http://www.dwarfstd.org/doc/DWARF4.pdf#page=102&zoom=100,0,0.

Parameters

ctx
idx	index of the current entry
result	ptr to result member to fill up

Returns

RzTypeStructMember* ptr to parsed Member

Definition at line 392 of file dwarf_process.c.

                                                                                                   {
    rz_return_val_if_fail(result, NULL);
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
 
    char *name = NULL;
    char *type = NULL;
    ut64 offset = 0;
    ut64 size = 0;
    RzStrBuf strbuf;
    rz_strbuf_init(&strbuf);
    size_t i;
    for (i = 0; i < die->count; i++) {
        RzBinDwarfAttrValue *value = &die->attr_values[i];
        switch (die->attr_values[i].attr_name) {
        case DW_AT_name:
            free(name);
            name = get_die_name(die);
            if (!name) {
                goto cleanup;
            }
            break;
        case DW_AT_type:
            parse_type_outer(ctx, value->reference, &strbuf, &size);
            free(type);
            type = rz_strbuf_drain_nofree(&strbuf);
            if (!type || !*type) {
                goto cleanup;
            }
            break;
        case DW_AT_data_member_location:
            /*
                2 cases, 1.: If val is integer, it offset in bytes from
                the beginning of containing entity. If containing entity has
                a bit offset, member has that bit offset aswell
                2.: value is a location description
                http://www.dwarfstd.org/doc/DWARF4.pdf#page=39&zoom=100,0,0
            */
            offset = value->uconstant;
            break;
        case DW_AT_accessibility: // private, public etc.
        case DW_AT_mutable: // flag is it is mutable
        case DW_AT_data_bit_offset:
            /*
                int that specifies the number of bits from beginning
                of containing entity to the beginning of the data member
            */
            break;
        // If the size of a data member is not the same as the
        //  size of the type given for the data member
        case DW_AT_byte_size:
            size = value->uconstant * CHAR_BIT;
            break;
        case DW_AT_bit_size:
            size = value->uconstant;
            break;
        case DW_AT_containing_type:
        default:
            break;
        }
    }
 
    result->name = name;
    result->type = rz_type_parse_string_single(ctx->analysis->typedb->parser, type, NULL);
    if (!result->type) {
        goto cleanup;
    }
    result->offset = offset;
    result->size = size;
    free(type);
    return result;
 
cleanup:
    free(name);
    free(type);
    return NULL;
}

References dwarf_attr_kind::attr_name, RzBinDwarfDie::attr_values, CHAR_BIT, cleanup(), RzBinDwarfDie::count, DW_AT_accessibility, DW_AT_bit_size, DW_AT_byte_size, DW_AT_containing_type, DW_AT_data_bit_offset, DW_AT_data_member_location, DW_AT_mutable, DW_AT_name, DW_AT_type, free(), get_die_name(), i, setup::idx, name, rz_type_struct_member_t::name, NULL, rz_type_struct_member_t::offset, parse_type_outer(), rz_return_val_if_fail, rz_strbuf_drain_nofree(), rz_strbuf_init(), rz_type_parse_string_single(), rz_type_struct_member_t::size, type, rz_type_struct_member_t::type, ut64(), and value.

Referenced by parse_structure_type().

parse_structure_type()

static void parse_structure_type ( Context *  ctx, ut64  idx  )

static

Parses a structured entry (structs, classes, unions) into RzBaseType and saves it using rz_analysis_save_base_type ()

Parameters

ctx
idx	index of the current entry

Definition at line 521 of file dwarf_process.c.

                                                         {
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
 
    RzBaseTypeKind kind;
    if (die->tag == DW_TAG_union_type) {
        kind = RZ_BASE_TYPE_KIND_UNION;
    } else {
        kind = RZ_BASE_TYPE_KIND_STRUCT;
    }
 
    RzBaseType *base_type = rz_type_base_type_new(kind);
    if (!base_type) {
        return;
    }
 
    base_type->name = get_die_name(die);
    if (!base_type->name) {
        rz_type_base_type_free(base_type);
        return;
    }
 
    // if it is definition of previous declaration (TODO Fix, big ugly hotfix addition)
    st32 spec_attr_idx = find_attr_idx(die, DW_AT_specification);
    if (spec_attr_idx != -1) {
        RzBinDwarfDie *decl_die = ht_up_find(ctx->die_map, die->attr_values[spec_attr_idx].reference, NULL);
        if (!decl_die) {
            rz_type_base_type_free(base_type);
            return;
        }
        st32 name_attr_idx = find_attr_idx(decl_die, DW_AT_name);
        if (name_attr_idx != -1) {
            free(base_type->name);
            base_type->name = get_die_name(decl_die);
        }
    }
 
    base_type->size = get_die_size(die);
 
    RzTypeStructMember member = { 0 };
    // Parse out all members, can this in someway be extracted to a function?
    if (die->has_children) {
        int child_depth = 1; // Direct children of the node
        size_t j;
        idx++; // Move to the first children node
        for (j = idx; child_depth > 0 && j < ctx->count; j++) {
            const RzBinDwarfDie *child_die = &ctx->all_dies[j];
            // we take only direct descendats of the structure
            // can be also DW_TAG_suprogram for class methods or tag for templates
            if (child_depth == 1 && child_die->tag == DW_TAG_member) {
                RzTypeStructMember *result = parse_struct_member(ctx, j, &member);
                if (!result) {
                    rz_type_base_type_free(base_type);
                    return;
                } else {
                    void *element = rz_vector_push(&base_type->struct_data.members, &member);
                    if (!element) {
                        rz_type_base_type_free(base_type);
                        return;
                    }
                }
            }
            if (child_die->has_children) {
                child_depth++;
            }
            if (child_die->abbrev_code == 0) { // siblings terminator
                child_depth--;
            }
        }
    }
    rz_type_db_save_base_type(ctx->analysis->typedb, base_type);
}

References RzBinDwarfDie::abbrev_code, RzBinDwarfDie::attr_values, DW_AT_name, DW_AT_specification, DW_TAG_member, DW_TAG_union_type, find_attr_idx(), free(), get_die_name(), get_die_size(), RzBinDwarfDie::has_children, setup::idx, rz_base_type_struct_t::members, rz_base_type_t::name, NULL, parse_struct_member(), dwarf_attr_kind::reference, RZ_BASE_TYPE_KIND_STRUCT, RZ_BASE_TYPE_KIND_UNION, rz_type_base_type_free(), rz_type_base_type_new(), rz_type_db_save_base_type(), rz_vector_push(), rz_base_type_t::size, st32, rz_base_type_t::struct_data, and RzBinDwarfDie::tag.

Referenced by parse_type_entry().

parse_type()

static st32 parse_type ( Context *  ctx, const ut64  offset, RzStrBuf *  strbuf, ut64 *  size, RZ_NONNULL SetU *  visited  )

static

Recursively parses type entry of a certain offset into strbuf saves type size into *size.

Parameters

ctx
offset	offset of the type entry
strbuf	string to store the type into
size	ptr to size of a type to fill up (can be NULL if unwanted)
set	of visited die offsets, to prevent infinite recursion

Returns

st32 -1 if error else DW_TAG of the entry

TODO make cache for type entries, one type is usually referenced multiple times which means it's parsed multiple times instead of once

Definition at line 258 of file dwarf_process.c.

                                                                                                                {
    rz_return_val_if_fail(strbuf && visited, -1);
    if (set_u_contains(visited, offset)) {
        return -1;
    }
    set_u_add(visited, offset);
    RzBinDwarfDie *die = ht_up_find(ctx->die_map, offset, NULL);
    if (!die) {
        return -1;
    }
 
    st32 type_idx;
    st32 tag;
    char *name = NULL;
    // get size of first type DIE that has size
    if (size && *size == 0) {
        *size = get_die_size(die);
    }
    switch (die->tag) {
    // this should be recursive search for the type until you find base/user defined type
    case DW_TAG_pointer_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx == -1) {
            rz_strbuf_append(strbuf, "void");
            rz_strbuf_append(strbuf, " *");
        } else {
            tag = parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
            if (tag == DW_TAG_subroutine_type) {
                strbuf_rev_prepend_char(strbuf, "(*)", '(');
            } else if (tag == DW_TAG_pointer_type) {
                if (!strbuf_rev_append_char(strbuf, "*", "(*")) {
                    strbuf_rev_prepend_char(strbuf, "*", '*');
                }
            } else {
                rz_strbuf_append(strbuf, " *");
            }
        }
        break;
    // We won't parse them as a complete type, because that will already be done
    // so just a name now
    case DW_TAG_typedef:
    case DW_TAG_base_type:
    case DW_TAG_structure_type:
    case DW_TAG_enumeration_type:
    case DW_TAG_union_type:
    case DW_TAG_class_type:
        name = get_die_name(die);
        rz_strbuf_append(strbuf, name);
        free(name);
        break;
    case DW_TAG_subroutine_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx == -1) {
            rz_strbuf_append(strbuf, "void");
        } else {
            parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
        }
        rz_strbuf_append(strbuf, " (");
        if (die->has_children) { // has parameters
        }
        rz_strbuf_append(strbuf, ")");
        break;
    case DW_TAG_array_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx != -1) {
            parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
        }
        parse_array_type(ctx, die - ctx->all_dies, strbuf);
        break;
    case DW_TAG_const_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx != -1) {
            parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
        }
        rz_strbuf_append(strbuf, " const");
        break;
    case DW_TAG_volatile_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx != -1) {
            parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
        }
        rz_strbuf_append(strbuf, " volatile");
        break;
    case DW_TAG_restrict_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx != -1) {
            parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
        }
        rz_strbuf_append(strbuf, " restrict");
        break;
    case DW_TAG_rvalue_reference_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx != -1) {
            parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
        }
        rz_strbuf_append(strbuf, " &&");
        break;
    case DW_TAG_reference_type:
        type_idx = find_attr_idx(die, DW_AT_type);
        if (type_idx != -1) {
            parse_type(ctx, die->attr_values[type_idx].reference, strbuf, size, visited);
        }
        rz_strbuf_append(strbuf, " &");
        break;
    default:
        break;
    }
    set_u_delete(visited, offset);
    return (st32)die->tag;
}

References RzBinDwarfDie::attr_values, DW_AT_type, DW_TAG_array_type, DW_TAG_base_type, DW_TAG_class_type, DW_TAG_const_type, DW_TAG_enumeration_type, DW_TAG_pointer_type, DW_TAG_reference_type, DW_TAG_restrict_type, DW_TAG_rvalue_reference_type, DW_TAG_structure_type, DW_TAG_subroutine_type, DW_TAG_typedef, DW_TAG_union_type, DW_TAG_volatile_type, find_attr_idx(), free(), get_die_name(), get_die_size(), RzBinDwarfDie::has_children, NULL, parse_array_type(), dwarf_attr_kind::reference, rz_return_val_if_fail, rz_strbuf_append(), set_u_add(), set_u_contains(), set_u_delete(), st32, strbuf_rev_append_char(), strbuf_rev_prepend_char(), RzBinDwarfDie::tag, and test-lz4-versions::tag.

Referenced by parse_type_outer().

parse_type_entry()

static void parse_type_entry ( Context *  ctx, ut64  idx  )

static

Delegates DIE to it's proper parsing method.

Parameters

ctx
idx	index of the current entry

Definition at line 1565 of file dwarf_process.c.

                                                     {
    rz_return_if_fail(ctx);
 
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
    switch (die->tag) {
    case DW_TAG_structure_type:
    case DW_TAG_union_type:
    case DW_TAG_class_type:
        parse_structure_type(ctx, idx);
        break;
    case DW_TAG_enumeration_type:
        parse_enum_type(ctx, idx);
        break;
    case DW_TAG_typedef:
        parse_typedef(ctx, idx);
        break;
    case DW_TAG_base_type:
        parse_atomic_type(ctx, idx);
        break;
    case DW_TAG_subprogram:
        parse_function(ctx, idx);
        break;
    case DW_TAG_compile_unit:
        /* used for name demangling */
        ctx->lang = parse_comp_unit_lang(die);
    default:
        break;
    }
}

References DW_TAG_base_type, DW_TAG_class_type, DW_TAG_compile_unit, DW_TAG_enumeration_type, DW_TAG_structure_type, DW_TAG_subprogram, DW_TAG_typedef, DW_TAG_union_type, setup::idx, parse_atomic_type(), parse_comp_unit_lang(), parse_enum_type(), parse_function(), parse_structure_type(), parse_typedef(), rz_return_if_fail, and RzBinDwarfDie::tag.

Referenced by rz_analysis_dwarf_process_info().

parse_type_outer()

static st32 parse_type_outer ( Context *  ctx, const ut64  offset, RzStrBuf *  strbuf, ut64 *  size  )

static

Convenience function for calling parse_type with an empty visited set See documentation of parse_type.

Definition at line 373 of file dwarf_process.c.

                                                                                            {
    SetU *visited = set_u_new();
    if (!visited) {
        return -1;
    }
    st32 r = parse_type(ctx, offset, strbuf, size, visited);
    set_u_free(visited);
    return r;
}

References parse_type(), r, set_u_free(), set_u_new(), and st32.

Referenced by get_spec_die_type(), parse_abstract_origin(), parse_enum_type(), parse_function(), parse_function_args_and_vars(), parse_struct_member(), and parse_typedef().

parse_typedef()

static void parse_typedef ( Context *  ctx, ut64  idx  )

static

Parses a typedef entry into RzBaseType and saves it using rz_analysis_save_base_type ()

http://www.dwarfstd.org/doc/DWARF4.pdf#page=96&zoom=100,0,0

Parameters

ctx
idx	index of the current entry

Definition at line 672 of file dwarf_process.c.

                                                  {
    const RzBinDwarfDie *die = &ctx->all_dies[idx];
 
    char *name = NULL;
    char *type = NULL;
    ut64 size = 0;
    RzStrBuf strbuf;
    rz_strbuf_init(&strbuf);
    size_t i;
 
    for (i = 0; i < die->count; i++) {
        RzBinDwarfAttrValue *value = &die->attr_values[i];
        switch (die->attr_values[i].attr_name) {
        case DW_AT_name:
            name = get_die_name(die);
            if (!name) {
                goto cleanup;
            }
            break;
        case DW_AT_type:
            parse_type_outer(ctx, value->reference, &strbuf, &size);
            type = rz_strbuf_drain_nofree(&strbuf);
            if (!type) {
                goto cleanup;
            }
            break;
        default:
            break;
        }
    }
    if (!name || !type) { // type has to have a name for now
        goto cleanup;
    }
    RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_TYPEDEF);
    if (!base_type) {
        goto cleanup;
    }
    base_type->name = name;
    base_type->type = rz_type_parse_string_single(ctx->analysis->typedb->parser, type, NULL);
    if (!base_type->type) {
        rz_type_base_type_free(base_type);
        goto cleanup;
    }
    rz_type_db_save_base_type(ctx->analysis->typedb, base_type);
 
cleanup:
    free(type);
    rz_strbuf_fini(&strbuf);
    return;
}

References dwarf_attr_kind::attr_name, RzBinDwarfDie::attr_values, cleanup(), RzBinDwarfDie::count, DW_AT_name, DW_AT_type, free(), get_die_name(), i, setup::idx, name, rz_base_type_t::name, NULL, parse_type_outer(), RZ_BASE_TYPE_KIND_TYPEDEF, rz_strbuf_drain_nofree(), rz_strbuf_fini(), rz_strbuf_init(), rz_type_base_type_free(), rz_type_base_type_new(), rz_type_db_save_base_type(), rz_type_parse_string_single(), type, rz_base_type_t::type, ut64(), and value.

Referenced by parse_type_entry().

prefer_linkage_name()

static bool prefer_linkage_name ( char *  lang )

static

Definition at line 798 of file dwarf_process.c.

                                            {
    if (!lang) {
        return false;
    }
    if (!strcmp(lang, "rust")) {
        return false;
    } else if (!strcmp(lang, "ada")) {
        return false;
    }
    return true;
}

Referenced by parse_abstract_origin(), parse_function(), and parse_function_args_and_vars().

rz_analysis_dwarf_integrate_functions()

RZ_API void rz_analysis_dwarf_integrate_functions	(	RzAnalysis *	analysis,
		RzFlag *	flags,
		Sdb *	dwarf_sdb
	)

Use parsed DWARF function info from Sdb in the function analysis XXX right now we only save parsed name and variables, we can't use signature now XXX refactor to be more readable.

Parameters

analysis
dwarf_sdb

Definition at line 1637 of file dwarf_process.c.

                                                                                                       {
    rz_return_if_fail(analysis && dwarf_sdb);
 
    /* get all entries with value == func */
    SdbList *sdb_list = sdb_foreach_list_filter(dwarf_sdb, filter_sdb_function_names, false);
    SdbListIter *it;
    SdbKv *kv;
    /* iterate all function entries */
    ls_foreach (sdb_list, it, kv) {
        char *func_sname = kv->base.key;
 
        char *addr_key = rz_str_newf("fcn.%s.addr", func_sname);
        ut64 faddr = sdb_num_get(dwarf_sdb, addr_key, 0);
        free(addr_key);
 
        /* if the function is analyzed so we can edit */
        RzAnalysisFunction *fcn = rz_analysis_get_function_at(analysis, faddr);
        if (fcn) {
            /* prepend dwarf debug info stuff with dbg. */
            char *real_name_key = rz_str_newf("fcn.%s.name", func_sname);
            char *real_name = sdb_get(dwarf_sdb, real_name_key, 0);
            free(real_name_key);
 
            char *dwf_name = rz_str_newf("dbg.%s", real_name);
            free(real_name);
 
            rz_analysis_function_rename(fcn, dwf_name);
            free(dwf_name);
 
            char *tmp = rz_str_newf("fcn.%s.sig", func_sname);
            char *fcnstr = sdb_get(dwarf_sdb, tmp, 0);
            free(tmp);
            /* Apply signature as a comment at a function address */
            rz_meta_set_string(analysis, RZ_META_TYPE_COMMENT, faddr, fcnstr);
            free(fcnstr);
        }
        char *var_names_key = rz_str_newf("fcn.%s.vars", func_sname);
        char *vars = sdb_get(dwarf_sdb, var_names_key, NULL);
        char *var_name;
        sdb_aforeach(var_name, vars) {
            char *var_key = rz_str_newf("fcn.%s.var.%s", func_sname, var_name);
            char *var_data = sdb_get(dwarf_sdb, var_key, NULL);
            if (!var_data) {
                goto loop_end;
            }
            char *extra = NULL;
            char *kind = sdb_anext(var_data, &extra);
            char *type = NULL;
            extra = sdb_anext(extra, &type);
            RzType *ttype = rz_type_parse_string_single(analysis->typedb->parser, type, NULL);
            if (!ttype) {
                goto loop_end;
            }
            st64 offset = 0;
            if (*kind != 'r') {
                offset = strtol(extra, NULL, 10);
            }
            if (*kind == 'g') { /* global, fixed addr TODO add size to variables? */
                char *global_name = rz_str_newf("global_%s", var_name);
                rz_flag_unset_off(flags, offset);
                rz_flag_set_next(flags, global_name, offset, 4);
                free(global_name);
            } else if (*kind == 's' && fcn) {
                rz_analysis_function_set_var(fcn, offset - fcn->maxstack, *kind, ttype, 4, false, var_name);
            } else if (*kind == 'r' && fcn) {
                RzRegItem *i = rz_reg_get(analysis->reg, extra, -1);
                if (!i) {
                    goto loop_end;
                }
                rz_analysis_function_set_var(fcn, i->index, *kind, ttype, 4, false, var_name);
            } else if (fcn) { /* kind == 'b' */
                rz_analysis_function_set_var(fcn, offset - fcn->bp_off, *kind, ttype, 4, false, var_name);
            }
            rz_type_free(ttype);
            free(var_key);
            free(var_data);
        loop_end:
            sdb_aforeach_next(var_name);
        }
        free(var_names_key);
        free(vars);
    }
    ls_free(sdb_list);
}

References sdb_kv::base, rz_analysis_function_t::bp_off, filter_sdb_function_names(), flags, free(), i, ls_foreach, ls_free(), rz_analysis_function_t::maxstack, NULL, rz_type_db_t::parser, rz_analysis_t::reg, rz_analysis_function_rename(), rz_analysis_function_set_var(), rz_analysis_get_function_at(), rz_flag_set_next(), rz_flag_unset_off(), rz_meta_set_string(), RZ_META_TYPE_COMMENT, rz_reg_get(), rz_return_if_fail, rz_str_newf(), rz_type_free(), rz_type_parse_string_single(), sdb_aforeach, sdb_aforeach_next, sdb_anext(), sdb_foreach_list_filter(), sdb_get(), sdb_num_get(), st64, autogen_x86imm::tmp, type, rz_analysis_t::typedb, and ut64().

Referenced by rz_core_analysis_everything().

rz_analysis_dwarf_process_info()

RZ_API void rz_analysis_dwarf_process_info	(	const RzAnalysis *	analysis,
		RzAnalysisDwarfContext *	ctx
	)

Parses type and function information out of DWARF entries and stores them to the sdb for further use.

Parameters

analysis
ctx

Definition at line 1602 of file dwarf_process.c.

                                                                                                    {
    rz_return_if_fail(ctx && analysis);
    Sdb *dwarf_sdb = sdb_ns(analysis->sdb, "dwarf", 1);
    size_t i, j;
    const RzBinDwarfDebugInfo *info = ctx->info;
    for (i = 0; i < info->count; i++) {
        RzBinDwarfCompUnit *unit = &info->comp_units[i];
        Context dw_context = { // context per unit?
            .analysis = analysis,
            .all_dies = unit->dies,
            .count = unit->count,
            .die_map = info->lookup_table,
            .sdb = dwarf_sdb,
            .locations = ctx->loc,
            .lang = NULL
        };
        for (j = 0; j < unit->count; j++) {
            parse_type_entry(&dw_context, j);
        }
    }
}

References dwarf_parse_context_t::analysis, RzBinDwarfDie::count, RzBinDwarfCompUnit::count, RzBinDwarfCompUnit::dies, i, info(), NULL, parse_type_entry(), rz_return_if_fail, rz_analysis_t::sdb, and sdb_ns().

Referenced by rz_core_bin_apply_dwarf().

sdb_save_dwarf_function()

static void sdb_save_dwarf_function ( Function *  dwarf_fcn, RzList *  variables, Sdb *  sdb  )

static

Definition at line 1308 of file dwarf_process.c.

                                                                                        {
    char *sname = rz_str_sanitize_sdb_key(dwarf_fcn->name);
    sdb_set(sdb, sname, "fcn", 0);
 
    char *addr_key = rz_str_newf("fcn.%s.addr", sname);
    char *addr_val = rz_str_newf("0x%" PFMT64x "", dwarf_fcn->addr);
    sdb_set(sdb, addr_key, addr_val, 0);
    free(addr_key);
    free(addr_val);
 
    /* so we can have name without sanitization */
    char *name_key = rz_str_newf("fcn.%s.name", sname);
    char *name_val = rz_str_newf("%s", dwarf_fcn->name);
    sdb_set(sdb, name_key, name_val, 0);
    free(name_key);
    free(name_val);
 
    char *signature_key = rz_str_newf("fcn.%s.sig", sname);
    sdb_set(sdb, signature_key, dwarf_fcn->signature, 0);
    free(signature_key);
 
    RzStrBuf vars;
    rz_strbuf_init(&vars);
    RzListIter *iter;
    Variable *var;
    rz_list_foreach (variables, iter, var) {
        if (!var->location) {
            /* NULL location probably means optimized out, maybe put a comment there */
            continue;
        }
        char *key = NULL;
        char *val = NULL;
        switch (var->location->kind) {
        case LOCATION_BP: {
            /* value = "type, storage, additional info based on storage (offset)" */
 
            rz_strbuf_appendf(&vars, "%s,", var->name);
            key = rz_str_newf("fcn.%s.var.%s", sname, var->name);
            val = rz_str_newf("%s,%" PFMT64d ",%s", "b", var->location->offset, var->type);
            sdb_set(sdb, key, val, 0);
        } break;
        case LOCATION_SP: {
            /* value = "type, storage, additional info based on storage (offset)" */
 
            rz_strbuf_appendf(&vars, "%s,", var->name);
            key = rz_str_newf("fcn.%s.var.%s", sname, var->name);
            val = rz_str_newf("%s,%" PFMT64d ",%s", "s", var->location->offset, var->type);
            sdb_set(sdb, key, val, 0);
        } break;
        case LOCATION_GLOBAL: {
            /* value = "type, storage, additional info based on storage (address)" */
 
            rz_strbuf_appendf(&vars, "%s,", var->name);
            key = rz_str_newf("fcn.%s.var.%s", sname, var->name);
            val = rz_str_newf("%s,%" PFMT64u ",%s", "g", var->location->address, var->type);
            sdb_set(sdb, key, val, 0);
        } break;
        case LOCATION_REGISTER: {
            /* value = "type, storage, additional info based on storage (register name)" */
 
            rz_strbuf_appendf(&vars, "%s,", var->name);
            key = rz_str_newf("fcn.%s.var.%s", sname, var->name);
            val = rz_str_newf("%s,%s,%s", "r", var->location->reg_name, var->type);
            sdb_set(sdb, key, val, 0);
        } break;
 
        default:
            /* else location is unknown (optimized out), skip the var */
            break;
        }
        free(key);
        free(val);
    }
    if (vars.len > 0) { /* remove the extra , */
        rz_strbuf_slice(&vars, 0, vars.len - 1); /* leaks? */
    }
    char *vars_key = rz_str_newf("fcn.%s.vars", sname);
    char *vars_val = rz_str_newf("%s", rz_strbuf_get(&vars));
    sdb_set(sdb, vars_key, vars_val, 0);
    free(vars_key);
    free(vars_val);
    rz_strbuf_fini(&vars);
    free(sname);
}

References dwarf_function_t::addr, dwarf_var_location_t::address, free(), key, dwarf_var_location_t::kind, RzStrBuf::len, dwarf_variable_t::location, LOCATION_BP, LOCATION_GLOBAL, LOCATION_REGISTER, LOCATION_SP, dwarf_function_t::name, dwarf_variable_t::name, NULL, dwarf_var_location_t::offset, PFMT64d, PFMT64u, PFMT64x, dwarf_var_location_t::reg_name, rz_str_newf(), rz_str_sanitize_sdb_key(), rz_strbuf_appendf(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_slice(), sdb_set(), dwarf_function_t::signature, dwarf_variable_t::type, and val.

Referenced by parse_function().

strbuf_rev_append_char()

static bool strbuf_rev_append_char ( RzStrBuf *  sb, const char *  s, const char *  needle  )

static

Pasted from rz_strbuf_* Appends string after a first occurence of character c Used to replicate proper C declaration for function pointers.

Parameters

sb
s
needle

Definition at line 129 of file dwarf_process.c.

                                                                                    {
    rz_return_val_if_fail(sb && s, false);
    size_t l = strlen(s);
    // fast path if no chars to append
    if (l == 0) {
        return true;
    }
    bool ret = false;
    char *sb_str = sb->ptr ? sb->ptr : sb->buf;
    char *pivot = strstr(sb_str, needle);
    if (!pivot) {
        return false;
    }
    pivot += strlen(needle);
    size_t idx = pivot - sb_str;
    size_t newlen = l + sb->len;
    char *ns = malloc(newlen + 1);
    if (ns) {
        memcpy(ns, sb_str, idx);
        memcpy(ns + idx, s, l);
        memcpy(ns + idx + l, sb_str + idx, sb->len - idx);
        ns[newlen] = 0;
        ret = rz_strbuf_set(sb, ns) != NULL;
        free(ns);
    }
    return ret;
}

References free(), setup::idx, malloc(), memcpy(), NULL, rz_return_val_if_fail, rz_strbuf_set(), s, and sb.

Referenced by parse_type().

strbuf_rev_prepend_char()

static bool strbuf_rev_prepend_char ( RzStrBuf *  sb, const char *  s, int  c  )

static

Pasted from rz_strbuf_* Prepends string before a last occurence of character c Used to replicate proper C declaration for function pointers.

Parameters

sb
s
c

Definition at line 94 of file dwarf_process.c.

                                                                        {
    rz_return_val_if_fail(sb && s, false);
    size_t l = strlen(s);
    // fast path if no chars to append
    if (l == 0) {
        return true;
    }
    size_t newlen = l + sb->len;
    char *ns = malloc(newlen + 1);
    bool ret = false;
    char *sb_str = sb->ptr ? sb->ptr : sb->buf;
    char *pivot = strrchr(sb_str, c);
    if (!pivot) {
        free(ns);
        return false;
    }
    size_t idx = pivot - sb_str;
    if (ns) {
        memcpy(ns, sb_str, idx);
        memcpy(ns + idx, s, l);
        memcpy(ns + idx + l, sb_str + idx, sb->len - idx);
        ns[newlen] = 0;
        ret = rz_strbuf_set(sb, ns) != NULL;
        free(ns);
    }
    return ret;
}

References c, free(), setup::idx, malloc(), memcpy(), NULL, rz_return_val_if_fail, rz_strbuf_set(), s, and sb.

Referenced by parse_type().

variable_free()

static void variable_free ( Variable *  var )

static

Definition at line 55 of file dwarf_process.c.

                                         {
    free(var->name);
    free(var->location);
    free(var->type);
    free(var);
}

References free(), dwarf_variable_t::location, dwarf_variable_t::name, and dwarf_variable_t::type.

Referenced by parse_function(), and parse_function_args_and_vars().