rtti_itanium.c File Reference

#include <rz_analysis.h>
#include <rz_core.h>
#include <rz_flag.h>
#include <rz_cons.h>
#include <rz_cmd.h>

Go to the source code of this file.

Classes
struct	class_type_info_t
struct	base_class_type_info_t
struct	si_class_type_info_t
struct	vmi_class_type_info_t

Macros
#define	VMI_CLASS_TYPE_INFO_NAME   "__vmi_class_type_info"
#define	SI_CLASS_TYPE_INFO_NAME   "__si_class_type_info"
#define	CLASS_TYPE_INFO_NAME   "__class_type_info"
#define	NAME_BUF_SIZE   256
#define	VT_WORD_SIZE(ctx)    (ctx->word_size)

Typedefs
typedef struct class_type_info_t	class_type_info
typedef struct base_class_type_info_t	base_class_type_info
typedef struct si_class_type_info_t	si_class_type_info
typedef struct vmi_class_type_info_t	vmi_class_type_info

Enumerations
enum	RTypeInfoType { RZ_TYPEINFO_TYPE_UNKNOWN , RZ_TYPEINFO_TYPE_CLASS , RZ_TYPEINFO_TYPE_SI_CLASS , RZ_TYPEINFO_TYPE_VMI_CLASS }

Functions
static bool	rtti_itanium_read_type_name (RVTableContext *context, ut64 addr, class_type_info *cti)
static char *	rtti_itanium_read_type_name_custom (RVTableContext *context, ut64 addr, ut64 *str_addr, bool *unique_name)
static void	rtti_itanium_class_type_info_fini (class_type_info *cti)
static void	rtti_itanium_class_type_info_free (class_type_info *cti)
static bool	rtti_itanium_class_type_info_init (RVTableContext *context, ut64 addr, class_type_info *cti)
static class_type_info *	rtti_itanium_class_type_info_new (RVTableContext *context, ut64 addr, ut64 source_vtable)
static void	rtti_itanium_vmi_class_type_info_fini (vmi_class_type_info *vmi_cti)
static void	rtti_itanium_vmi_class_type_info_free (vmi_class_type_info *cti)
static bool	rtti_itanium_vmi_class_type_info_init (RVTableContext *context, ut64 addr, vmi_class_type_info *vmi_cti)
static vmi_class_type_info *	rtti_itanium_vmi_class_type_info_new (RVTableContext *context, ut64 addr, ut64 source_vtable)
static void	rtti_itanium_si_class_type_info_fini (si_class_type_info *si_cti)
static void	rtti_itanium_si_class_type_info_free (si_class_type_info *cti)
static bool	rtti_itanium_si_class_type_info_init (RVTableContext *context, ut64 addr, si_class_type_info *si_cti)
static si_class_type_info *	rtti_itanium_si_class_type_info_new (RVTableContext *context, ut64 addr, ut64 source_vtable)
static const char *	type_to_string (RTypeInfoType type)
static void	rtti_itanium_print_class_type_info (class_type_info *cti, const char *prefix)
static void	rtti_itanium_print_class_type_info_json (class_type_info *cti)
static void	rtti_itanium_print_vmi_class_type_info (vmi_class_type_info *vmi_cti, const char *prefix)
static void	rtti_itanium_print_vmi_class_type_info_json (vmi_class_type_info *vmi_cti)
static void	rtti_itanium_print_si_class_type_info (si_class_type_info *si_cti, const char *prefix)
static void	rtti_itanium_print_si_class_type_info_json (si_class_type_info *si_cti)
static RTypeInfoType	rtti_itanium_type_info_type_from_flag (RVTableContext *context, ut64 atAddress)
static bool	can_section_contain_rtti_vpointer (RzBinSection *section)
static class_type_info *	create_class_type (ut64 vtable_addr, char *name, ut64 name_addr, bool unique_name, ut64 typeinfo_addr, ut64 source_vtable)
static si_class_type_info *	create_si_class_type (ut64 vtable_addr, char *name, ut64 name_addr, bool unique_name, ut64 basetype_addr, ut64 typeinfo_addr, ut64 source_vtable)
static vmi_class_type_info *	create_vmi_class_type (ut64 vtable_addr, char *name, ut64 name_addr, bool unique_name, ut32 flags, ut32 base_count, base_class_type_info *bases, ut64 typeinfo_addr, ut64 source_vtable)
static class_type_info *	raw_rtti_parse (RVTableContext *context, ut64 vtable_addr, ut64 rtti_addr)
	Try to parse as much valid looking RTTI as you can. More...
static class_type_info *	rtti_itanium_type_info_new (RVTableContext *context, ut64 vtable_addr)
static void	rtti_itanium_type_info_free (void *info)
RZ_API bool	rz_analysis_rtti_itanium_print_at_vtable (RVTableContext *context, ut64 addr, RzOutputMode mode)
RZ_API char *	rz_analysis_rtti_itanium_demangle_class_name (RVTableContext *context, const char *name)
static void	recovery_apply_vtable (RVTableContext *context, const char *class_name, RVTableInfo *vtable_info)
static void	add_class_bases (RVTableContext *context, const class_type_info *cti)
	Add any base class information about the type into analysis/classes. More...
static void	detect_constructor_destructor (RzAnalysis *analysis, class_type_info *cti)
RZ_API void	rz_analysis_rtti_itanium_recover_all (RVTableContext *context, RzList *vtables)

Macro Definition Documentation

CLASS_TYPE_INFO_NAME

#define CLASS_TYPE_INFO_NAME   "__class_type_info"

Definition at line 13 of file rtti_itanium.c.

NAME_BUF_SIZE

#define NAME_BUF_SIZE   256

Definition at line 14 of file rtti_itanium.c.

SI_CLASS_TYPE_INFO_NAME

#define SI_CLASS_TYPE_INFO_NAME   "__si_class_type_info"

Definition at line 12 of file rtti_itanium.c.

VMI_CLASS_TYPE_INFO_NAME

#define VMI_CLASS_TYPE_INFO_NAME   "__vmi_class_type_info"

Definition at line 11 of file rtti_itanium.c.

VT_WORD_SIZE

#define VT_WORD_SIZE

(

ctx

)

(ctx->word_size)

Definition at line 16 of file rtti_itanium.c.

Typedef Documentation

base_class_type_info

typedef struct base_class_type_info_t base_class_type_info

class_type_info

typedef struct class_type_info_t class_type_info

si_class_type_info

typedef struct si_class_type_info_t si_class_type_info

vmi_class_type_info

typedef struct vmi_class_type_info_t vmi_class_type_info

Enumeration Type Documentation

RTypeInfoType

enum RTypeInfoType

Enumerator
RZ_TYPEINFO_TYPE_UNKNOWN
RZ_TYPEINFO_TYPE_CLASS
RZ_TYPEINFO_TYPE_SI_CLASS
RZ_TYPEINFO_TYPE_VMI_CLASS

Definition at line 19 of file rtti_itanium.c.

             {
    RZ_TYPEINFO_TYPE_UNKNOWN,
    RZ_TYPEINFO_TYPE_CLASS,
    RZ_TYPEINFO_TYPE_SI_CLASS,
    RZ_TYPEINFO_TYPE_VMI_CLASS
} RTypeInfoType;

Function Documentation

add_class_bases()

static void add_class_bases ( RVTableContext *  context, const class_type_info *  cti  )

static

Add any base class information about the type into analysis/classes.

Parameters

context
cti

Definition at line 805 of file rtti_itanium.c.

                                                                                 {
    class_type_info base_info;
    int i;
 
    switch (cti->type) {
    case RZ_TYPEINFO_TYPE_SI_CLASS: {
        si_class_type_info *si_class = (void *)cti;
        ut64 base_addr = si_class->base_class_addr;
        base_addr += VT_WORD_SIZE(context); // offset to name
        if (rtti_itanium_read_type_name(context, base_addr, &base_info)) {
            // TODO in future, store the RTTI offset from vtable and use it
            RzAnalysisBaseClass base = { .class_name = base_info.name, .offset = 0 };
            rz_analysis_class_base_set(context->analysis, cti->name, &base);
            rz_analysis_class_base_fini(&base);
        }
    } break;
    case RZ_TYPEINFO_TYPE_VMI_CLASS: {
        vmi_class_type_info *vmi_class = (void *)cti;
        for (i = 0; i < vmi_class->vmi_base_count; i++) {
            base_class_type_info *base_class_info = vmi_class->vmi_bases + i;
            ut64 base_addr = base_class_info->base_class_addr + VT_WORD_SIZE(context); // offset to name
            if (rtti_itanium_read_type_name(context, base_addr, &base_info)) {
                // TODO in future, store the RTTI offset from vtable and use it
                RzAnalysisBaseClass base = { .class_name = base_info.name, .offset = 0 };
                rz_analysis_class_base_set(context->analysis, cti->name, &base);
                rz_analysis_class_base_fini(&base);
            }
        }
    } break;
    default: // other types have no parent classes
        break;
    }
}

References base_class_type_info_t::base_class_addr, si_class_type_info_t::base_class_addr, i, class_type_info_t::name, rtti_itanium_read_type_name(), rz_analysis_class_base_fini(), rz_analysis_class_base_set(), RZ_TYPEINFO_TYPE_SI_CLASS, RZ_TYPEINFO_TYPE_VMI_CLASS, class_type_info_t::type, ut64(), vmi_class_type_info_t::vmi_base_count, vmi_class_type_info_t::vmi_bases, and VT_WORD_SIZE.

Referenced by rz_analysis_rtti_itanium_recover_all().

can_section_contain_rtti_vpointer()

static bool can_section_contain_rtti_vpointer ( RzBinSection *  section )

static

Definition at line 474 of file rtti_itanium.c.

                                                                     {
    if (!section) {
        return false;
    }
    if (section->is_data) {
        return true;
    }
    return !strcmp(section->name, ".data.rel.ro") ||
        !strcmp(section->name, ".data.rel.ro.local") ||
        rz_str_endswith(section->name, "__const");
}

References rz_str_endswith().

Referenced by raw_rtti_parse().

create_class_type()

static class_type_info* create_class_type ( ut64  vtable_addr, char *  name, ut64  name_addr, bool  unique_name, ut64  typeinfo_addr, ut64  source_vtable  )

static

Definition at line 486 of file rtti_itanium.c.

                                                                                                                                                  {
    class_type_info *result = RZ_NEW0(class_type_info);
    if (!result) {
        return NULL;
    }
    result->type = RZ_TYPEINFO_TYPE_CLASS;
 
    result->vtable_addr = vtable_addr;
    result->name_addr = name_addr;
    result->name = name;
    result->name_unique = unique_name;
    result->typeinfo_addr = typeinfo_addr;
    result->class_vtable_addr = source_vtable;
    return result;
}

References class_type_info_t::class_vtable_addr, name, class_type_info_t::name, class_type_info_t::name_addr, class_type_info_t::name_unique, NULL, RZ_NEW0, RZ_TYPEINFO_TYPE_CLASS, class_type_info_t::type, class_type_info_t::typeinfo_addr, and class_type_info_t::vtable_addr.

Referenced by raw_rtti_parse().

create_si_class_type()

static si_class_type_info* create_si_class_type ( ut64  vtable_addr, char *  name, ut64  name_addr, bool  unique_name, ut64  basetype_addr, ut64  typeinfo_addr, ut64  source_vtable  )

static

Definition at line 502 of file rtti_itanium.c.

                                                                                                                                                                            {
    si_class_type_info *result = RZ_NEW0(si_class_type_info);
    if (!result) {
        return NULL;
    }
    result->type = RZ_TYPEINFO_TYPE_SI_CLASS;
    result->base_class_addr = basetype_addr;
    result->vtable_addr = vtable_addr;
    result->name_addr = name_addr;
    result->name = name;
    result->name_unique = unique_name;
    result->typeinfo_addr = typeinfo_addr;
    result->class_vtable_addr = source_vtable;
    return result;
}

References si_class_type_info_t::base_class_addr, si_class_type_info_t::class_vtable_addr, name, si_class_type_info_t::name, si_class_type_info_t::name_addr, si_class_type_info_t::name_unique, NULL, RZ_NEW0, RZ_TYPEINFO_TYPE_SI_CLASS, si_class_type_info_t::type, si_class_type_info_t::typeinfo_addr, and si_class_type_info_t::vtable_addr.

Referenced by raw_rtti_parse().

create_vmi_class_type()

static vmi_class_type_info* create_vmi_class_type ( ut64  vtable_addr, char *  name, ut64  name_addr, bool  unique_name, ut32  flags, ut32  base_count, base_class_type_info *  bases, ut64  typeinfo_addr, ut64  source_vtable  )

static

Definition at line 518 of file rtti_itanium.c.

                                                                                                                                                                                                                    {
    vmi_class_type_info *result = RZ_NEW0(vmi_class_type_info);
    if (!result) {
        return NULL;
    }
    result->type = RZ_TYPEINFO_TYPE_VMI_CLASS;
    result->vmi_bases = bases;
    result->vmi_base_count = base_count;
    result->vmi_flags = flags;
    result->vtable_addr = vtable_addr;
    result->name_addr = name_addr;
    result->name = name;
    result->name_unique = unique_name;
    result->typeinfo_addr = typeinfo_addr;
    result->class_vtable_addr = source_vtable;
    return result;
}

References vmi_class_type_info_t::class_vtable_addr, flags, name, vmi_class_type_info_t::name, vmi_class_type_info_t::name_addr, vmi_class_type_info_t::name_unique, NULL, RZ_NEW0, RZ_TYPEINFO_TYPE_VMI_CLASS, vmi_class_type_info_t::type, vmi_class_type_info_t::typeinfo_addr, vmi_class_type_info_t::vmi_base_count, vmi_class_type_info_t::vmi_bases, vmi_class_type_info_t::vmi_flags, and vmi_class_type_info_t::vtable_addr.

Referenced by raw_rtti_parse().

detect_constructor_destructor()

static void detect_constructor_destructor ( RzAnalysis *  analysis, class_type_info *  cti  )

static

Definition at line 839 of file rtti_itanium.c.

                                                                                      {
    RzVector *vec = rz_analysis_class_method_get_all(analysis, cti->name);
    RzAnalysisMethod *meth;
    rz_vector_foreach(vec, meth) {
        if (!rz_str_cmp(meth->real_name, cti->name, -1)) {
            meth->method_type = RZ_ANALYSIS_CLASS_METHOD_CONSTRUCTOR;
            rz_analysis_class_method_set(analysis, cti->name, meth);
            continue;
        } else if (rz_str_startswith(meth->real_name, "~") && !rz_str_cmp(meth->real_name + 1, cti->name, -1)) {
            if (meth->method_type == RZ_ANALYSIS_CLASS_METHOD_VIRTUAL) {
                meth->method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL_DESTRUCTOR;
            } else {
                meth->method_type = RZ_ANALYSIS_CLASS_METHOD_DESTRUCTOR;
            }
            rz_analysis_class_method_set(analysis, cti->name, meth);
            continue;
        }
    }
    rz_vector_free(vec);
}

References class_type_info_t::name, rz_analysis_class_method_get_all(), rz_analysis_class_method_set(), rz_str_cmp(), rz_str_startswith(), rz_vector_foreach, and rz_vector_free().

Referenced by rz_analysis_rtti_itanium_recover_all().

raw_rtti_parse()

static class_type_info* raw_rtti_parse ( RVTableContext *  context, ut64  vtable_addr, ut64  rtti_addr  )

static

Try to parse as much valid looking RTTI as you can.

Parameters

context
vtable_addr
rtti_addr

Returns

class_type_info* NULL if not even default class RTTI could be parsed or error

Definition at line 544 of file rtti_itanium.c.

                                                                                                  {
    /*
        rtti_ptr   ----->  |                  vptr                |
                   |--------------------------------------|
                   |               type_name              |
                   |--------------------------------------| --- enough for __class_type_info
                   |  __class_type_info *base_type        |
                   |--------------------------------------| --- enough for __si_class_type_info
                   |              uint flags              | --- must be atleast 16bits, it's 32 bit for 64-bit Itanium ABI
                   |--------------------------------------|
                   |           uint base_count            |
                   |--------------------------------------|
                   |  __base_class_type_info base_info[]  |
                   |--------------------------------------|
                   |---------       ARRAY         --------|
                   |-----__class_type_info *base_type-----|
                   |--------- long __offset_flags --------| ----- enough for __vmi_class_type_info
        */
    ut64 rtti_vptr = 0;
    ut64 addr = rtti_addr;
    if (!context->read_addr(context->analysis, addr, &rtti_vptr)) {
        return NULL;
    }
    RzBinSection *rtti_section = context->analysis->binb.get_vsect_at(context->analysis->binb.bin, rtti_vptr);
    if (rtti_vptr && !can_section_contain_rtti_vpointer(rtti_section)) {
        ;
        ;
        ; // Right now ignore, seems that some binaries have some weird values inside there....
    }
    addr += VT_WORD_SIZE(context); // Move to the next member
 
    ut64 name_addr = 0;
    bool name_unique = false;
    char *type_name = rtti_itanium_read_type_name_custom(context, addr, &name_addr, &name_unique);
    if (!type_name) {
        return NULL;
    }
 
    addr += VT_WORD_SIZE(context); // Move to the next member
 
    // Right now we already have atleast __class_type_info;
 
    ut64 base_type_rtti = 0;
    if (!context->read_addr(context->analysis, addr, &base_type_rtti)) {
        return create_class_type(rtti_vptr, type_name, name_addr, name_unique, rtti_addr, vtable_addr);
    }
 
    RzBinSection *base_type_rtti_section = context->analysis->binb.get_vsect_at(context->analysis->binb.bin, base_type_rtti);
    if (can_section_contain_rtti_vpointer(base_type_rtti_section)) {
        return (class_type_info *)create_si_class_type(rtti_vptr, type_name, name_addr, name_unique, base_type_rtti, rtti_addr, vtable_addr);
    }
 
    // if it's not a valid base_type_rtti ptr, it might be flags for VMI
    // assume uint are 32bit
    ut64 integers = 0;
    if (!context->read_addr(context->analysis, addr, &integers)) {
        return create_class_type(rtti_vptr, type_name, name_addr, name_unique, rtti_addr, vtable_addr);
    }
    ut32 vmi_flags = integers & 0xffffffff;
    addr += 0x4;
    if (!context->read_addr(context->analysis, addr, &integers)) {
        return create_class_type(rtti_vptr, type_name, name_addr, name_unique, rtti_addr, vtable_addr);
    }
    integers = integers & 0xffffffff;
    if (integers < 1 || integers > 0xfffff) {
        return create_class_type(rtti_vptr, type_name, name_addr, name_unique, rtti_addr, vtable_addr);
    }
    ut32 vmi_base_count = integers;
 
    base_class_type_info *vmi_bases = calloc(sizeof(base_class_type_info), vmi_base_count);
    if (!vmi_bases) {
        return create_class_type(rtti_vptr, type_name, name_addr, name_unique, rtti_addr, vtable_addr);
    }
    ut64 tmp_addr = addr + 0x4;
 
    int i;
    for (i = 0; i < vmi_base_count; i++) {
        if (!context->read_addr(context->analysis, tmp_addr, &integers)) {
            free(vmi_bases);
            return create_class_type(rtti_vptr, type_name, name_addr, name_unique, rtti_addr, vtable_addr);
        }
        vmi_bases[i].base_class_addr = integers;
        tmp_addr += VT_WORD_SIZE(context);
        if (!context->read_addr(context->analysis, tmp_addr, &integers)) {
            free(vmi_bases);
            return create_class_type(rtti_vptr, type_name, name_addr, name_unique, rtti_addr, vtable_addr);
        }
        vmi_bases[i].flags = integers;
        tmp_addr += VT_WORD_SIZE(context);
    }
    return (class_type_info *)create_vmi_class_type(rtti_vptr, type_name, name_addr, name_unique, vmi_flags, vmi_base_count, vmi_bases, rtti_addr, vtable_addr);
}

References addr, base_class_type_info_t::base_class_addr, calloc(), can_section_contain_rtti_vpointer(), create_class_type(), create_si_class_type(), create_vmi_class_type(), base_class_type_info_t::flags, free(), i, NULL, rtti_itanium_read_type_name_custom(), ut64(), and VT_WORD_SIZE.

Referenced by rtti_itanium_type_info_new().

recovery_apply_vtable()

static void recovery_apply_vtable ( RVTableContext *  context, const char *  class_name, RVTableInfo *  vtable_info  )

static

Definition at line 761 of file rtti_itanium.c.

                                                                                                             {
    if (!vtable_info) {
        return;
    }
 
    ut64 size = rz_analysis_vtable_info_get_size(context, vtable_info);
 
    RzAnalysisVTable vtable = { .id = NULL, .offset = 0, .size = size, .addr = vtable_info->saddr };
    rz_analysis_class_vtable_set(context->analysis, class_name, &vtable);
    rz_analysis_class_vtable_fini(&vtable);
 
    RVTableMethodInfo *vmeth;
    rz_vector_foreach(&vtable_info->methods, vmeth) {
        RzAnalysisMethod meth;
        if (!rz_analysis_class_method_exists_by_addr(context->analysis, class_name, vmeth->addr)) {
            meth.addr = vmeth->addr;
            meth.vtable_offset = vmeth->vtable_offset;
            RzAnalysisFunction *fcn = rz_analysis_get_function_at(context->analysis, vmeth->addr);
            meth.name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset);
            // Temporarily set as attr name
            meth.real_name = fcn ? rz_str_new(fcn->name) : rz_str_newf("virtual_%" PFMT64d, meth.vtable_offset);
            meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL;
        } else {
            RzAnalysisMethod exist_meth;
            if (rz_analysis_class_method_get_by_addr(context->analysis, class_name, vmeth->addr, &exist_meth) == RZ_ANALYSIS_CLASS_ERR_SUCCESS) {
                meth.addr = vmeth->addr;
                meth.name = rz_str_new(exist_meth.name);
                meth.real_name = rz_str_new(exist_meth.real_name);
                meth.vtable_offset = vmeth->vtable_offset;
                meth.method_type = RZ_ANALYSIS_CLASS_METHOD_VIRTUAL;
                rz_analysis_class_method_fini(&exist_meth);
            }
        }
        rz_analysis_class_method_set(context->analysis, class_name, &meth);
        rz_analysis_class_method_fini(&meth);
    }
}

References rz_analysis_function_t::name, NULL, PFMT64d, rz_analysis_class_method_exists_by_addr(), rz_analysis_class_method_fini(), rz_analysis_class_method_get_by_addr(), rz_analysis_class_method_set(), rz_analysis_class_vtable_fini(), rz_analysis_class_vtable_set(), rz_analysis_get_function_at(), rz_analysis_vtable_info_get_size(), rz_str_new(), rz_str_newf(), rz_vector_foreach, and ut64().

Referenced by rz_analysis_rtti_itanium_recover_all().

rtti_itanium_class_type_info_fini()

static void rtti_itanium_class_type_info_fini ( class_type_info *  cti )

static

Definition at line 116 of file rtti_itanium.c.

                                                                    {
    if (cti) {
        free(cti->name);
    }
}

References free(), and class_type_info_t::name.

Referenced by rtti_itanium_class_type_info_free().

rtti_itanium_class_type_info_free()

static void rtti_itanium_class_type_info_free ( class_type_info *  cti )

static

Definition at line 122 of file rtti_itanium.c.

                                                                    {
    if (cti == NULL) {
        return;
    }
 
    rtti_itanium_class_type_info_fini(cti);
    free(cti);
}

References free(), NULL, and rtti_itanium_class_type_info_fini().

Referenced by rtti_itanium_class_type_info_new(), rtti_itanium_type_info_free(), and rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_class_type_info_init()

static bool rtti_itanium_class_type_info_init ( RVTableContext *  context, ut64  addr, class_type_info *  cti  )

static

Definition at line 131 of file rtti_itanium.c.

                                                                                                        {
    cti->type = RZ_TYPEINFO_TYPE_CLASS;
    ut64 at;
    if (addr == UT64_MAX) {
        return false;
    }
    if (!context->read_addr(context->analysis, addr, &at)) {
        return false;
    }
    cti->vtable_addr = at;
    return rtti_itanium_read_type_name(context, addr + VT_WORD_SIZE(context), cti);
}

References addr, rtti_itanium_read_type_name(), RZ_TYPEINFO_TYPE_CLASS, class_type_info_t::type, ut64(), UT64_MAX, VT_WORD_SIZE, and class_type_info_t::vtable_addr.

Referenced by rtti_itanium_class_type_info_new().

rtti_itanium_class_type_info_new()

static class_type_info* rtti_itanium_class_type_info_new ( RVTableContext *  context, ut64  addr, ut64  source_vtable  )

static

Definition at line 144 of file rtti_itanium.c.

                                                                                                                 {
    class_type_info *result = RZ_NEW0(class_type_info);
    if (!result) {
        return NULL;
    }
 
    if (!rtti_itanium_class_type_info_init(context, addr, result)) {
        rtti_itanium_class_type_info_free(result);
        return NULL;
    }
 
    result->class_vtable_addr = source_vtable;
    result->typeinfo_addr = addr;
 
    return result;
}

References addr, class_type_info_t::class_vtable_addr, NULL, rtti_itanium_class_type_info_free(), rtti_itanium_class_type_info_init(), RZ_NEW0, and class_type_info_t::typeinfo_addr.

Referenced by rtti_itanium_type_info_new().

rtti_itanium_print_class_type_info()

static void rtti_itanium_print_class_type_info ( class_type_info *  cti, const char *  prefix  )

static

Definition at line 309 of file rtti_itanium.c.

                                                                                         {
    rz_cons_printf("%sType Info at 0x%08" PFMT64x ":\n"
               "%s  Type Info type: %s\n"
               "%s  Belongs to class vtable: 0x%08" PFMT64x "\n"
               "%s  Reference to RTTI's type class: 0x%08" PFMT64x "\n"
               "%s  Reference to type's name: 0x%08" PFMT64x "\n"
               "%s  Type Name: %s\n"
               "%s  Name unique: %s\n",
        prefix, cti->typeinfo_addr,
        prefix, type_to_string(cti->type),
        prefix, cti->class_vtable_addr,
        prefix, cti->vtable_addr,
        prefix, cti->name_addr,
        prefix, cti->name,
        prefix, cti->name_unique ? "true" : "false");
}

References class_type_info_t::class_vtable_addr, class_type_info_t::name, class_type_info_t::name_addr, class_type_info_t::name_unique, PFMT64x, prefix, rz_cons_printf(), class_type_info_t::type, type_to_string(), class_type_info_t::typeinfo_addr, and class_type_info_t::vtable_addr.

Referenced by rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_print_class_type_info_json()

static void rtti_itanium_print_class_type_info_json ( class_type_info *  cti )

static

Definition at line 326 of file rtti_itanium.c.

                                                                          {
    PJ *pj = pj_new();
    if (!pj) {
        return;
    }
 
    pj_o(pj);
    pj_ks(pj, "type", type_to_string(cti->type));
    pj_kn(pj, "found_at", cti->typeinfo_addr);
    pj_kn(pj, "class_vtable", cti->class_vtable_addr);
    pj_kn(pj, "ref_to_type_class", cti->vtable_addr);
    pj_kn(pj, "ref_to_type_name", cti->name_addr);
    pj_ks(pj, "name", cti->name);
    pj_kb(pj, "name_unique", cti->name_unique);
    pj_end(pj);
 
    rz_cons_print(pj_string(pj));
    pj_free(pj);
}

References class_type_info_t::class_vtable_addr, class_type_info_t::name, class_type_info_t::name_addr, class_type_info_t::name_unique, pj_end(), pj_free(), pj_kb(), pj_kn(), pj_ks(), pj_new(), pj_o(), pj_string(), class_type_info_t::type, type_to_string(), class_type_info_t::typeinfo_addr, and class_type_info_t::vtable_addr.

Referenced by rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_print_si_class_type_info()

static void rtti_itanium_print_si_class_type_info ( si_class_type_info *  si_cti, const char *  prefix  )

static

Definition at line 408 of file rtti_itanium.c.

                                                                                                  {
    rz_cons_printf("%sType Info at 0x%08" PFMT64x ":\n"
               "%s  Type Info type: %s\n"
               "%s  Belongs to class vtable: 0x%08" PFMT64x "\n"
               "%s  Reference to RTTI's type class: 0x%08" PFMT64x "\n"
               "%s  Reference to type's name: 0x%08" PFMT64x "\n"
               "%s  Type Name: %s\n"
               "%s  Name unique: %s\n"
               "%s  Reference to parent's type info: 0x%08" PFMT64x "\n",
        prefix, si_cti->typeinfo_addr,
        prefix, type_to_string(si_cti->type),
        prefix, si_cti->class_vtable_addr,
        prefix, si_cti->vtable_addr,
        prefix, si_cti->name_addr,
        prefix, si_cti->name,
        prefix, si_cti->name_unique ? "true" : "false",
        prefix, si_cti->base_class_addr);
}

References si_class_type_info_t::base_class_addr, si_class_type_info_t::class_vtable_addr, si_class_type_info_t::name, si_class_type_info_t::name_addr, si_class_type_info_t::name_unique, PFMT64x, prefix, rz_cons_printf(), si_class_type_info_t::type, type_to_string(), si_class_type_info_t::typeinfo_addr, and si_class_type_info_t::vtable_addr.

Referenced by rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_print_si_class_type_info_json()

static void rtti_itanium_print_si_class_type_info_json ( si_class_type_info *  si_cti )

static

Definition at line 427 of file rtti_itanium.c.

                                                                                   {
    PJ *pj = pj_new();
    if (!pj) {
        return;
    }
 
    pj_o(pj);
    pj_ks(pj, "type", type_to_string(si_cti->type));
    pj_kn(pj, "found_at", si_cti->typeinfo_addr);
    pj_kn(pj, "class_vtable", si_cti->class_vtable_addr);
    pj_kn(pj, "ref_to_type_class", si_cti->vtable_addr);
    pj_kn(pj, "ref_to_type_name", si_cti->name_addr);
    pj_ks(pj, "name", si_cti->name);
    pj_kb(pj, "name_unique", si_cti->name_unique);
    pj_kn(pj, "ref_to_parent_type", si_cti->base_class_addr);
    pj_end(pj);
 
    rz_cons_print(pj_string(pj));
    pj_free(pj);
}

References si_class_type_info_t::base_class_addr, si_class_type_info_t::class_vtable_addr, si_class_type_info_t::name, si_class_type_info_t::name_addr, si_class_type_info_t::name_unique, pj_end(), pj_free(), pj_kb(), pj_kn(), pj_ks(), pj_new(), pj_o(), pj_string(), si_class_type_info_t::type, type_to_string(), si_class_type_info_t::typeinfo_addr, and si_class_type_info_t::vtable_addr.

Referenced by rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_print_vmi_class_type_info()

static void rtti_itanium_print_vmi_class_type_info ( vmi_class_type_info *  vmi_cti, const char *  prefix  )

static

Definition at line 346 of file rtti_itanium.c.

                                                                                                     {
    rz_cons_printf("%sType Info at 0x%08" PFMT64x ":\n"
               "%s  Type Info type: %s\n"
               "%s  Belongs to class vtable: 0x%08" PFMT64x "\n"
               "%s  Reference to RTTI's type class: 0x%08" PFMT64x "\n"
               "%s  Reference to type's name: 0x%08" PFMT64x "\n"
               "%s  Type Name: %s\n"
               "%s  Name unique: %s\n"
               "%s  Flags: 0x%x\n"
               "%s  Count of base classes: 0x%x"
               "\n",
        prefix, vmi_cti->typeinfo_addr,
        prefix, type_to_string(vmi_cti->type),
        prefix, vmi_cti->class_vtable_addr,
        prefix, vmi_cti->vtable_addr,
        prefix, vmi_cti->name_addr,
        prefix, vmi_cti->name,
        prefix, vmi_cti->name_unique ? "true" : "false",
        prefix, vmi_cti->vmi_flags,
        prefix, vmi_cti->vmi_base_count);
 
    int i;
    for (i = 0; i < vmi_cti->vmi_base_count; i++) {
        rz_cons_printf("%s    Base class type descriptor address: 0x%08" PFMT64x "\n"
                   "%s    Base class flags: 0x%" PFMT64x
                   "\n",
            prefix, vmi_cti->vmi_bases[i].base_class_addr,
            prefix, vmi_cti->vmi_bases[i].flags);
    }
}

References base_class_type_info_t::base_class_addr, vmi_class_type_info_t::class_vtable_addr, base_class_type_info_t::flags, i, vmi_class_type_info_t::name, vmi_class_type_info_t::name_addr, vmi_class_type_info_t::name_unique, PFMT64x, prefix, rz_cons_printf(), vmi_class_type_info_t::type, type_to_string(), vmi_class_type_info_t::typeinfo_addr, vmi_class_type_info_t::vmi_base_count, vmi_class_type_info_t::vmi_bases, vmi_class_type_info_t::vmi_flags, and vmi_class_type_info_t::vtable_addr.

Referenced by rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_print_vmi_class_type_info_json()

static void rtti_itanium_print_vmi_class_type_info_json ( vmi_class_type_info *  vmi_cti )

static

Definition at line 377 of file rtti_itanium.c.

                                                                                      {
    PJ *pj = pj_new();
    if (!pj) {
        return;
    }
 
    pj_o(pj);
    pj_ks(pj, "type", type_to_string(vmi_cti->type));
    pj_kn(pj, "found_at", vmi_cti->typeinfo_addr);
    pj_kn(pj, "class_vtable", vmi_cti->class_vtable_addr);
    pj_kn(pj, "ref_to_type_class", vmi_cti->vtable_addr);
    pj_kn(pj, "ref_to_type_name", vmi_cti->name_addr);
    pj_ks(pj, "name", vmi_cti->name);
    pj_kb(pj, "name_unique", vmi_cti->name_unique);
    pj_kn(pj, "flags", vmi_cti->vmi_flags);
    pj_k(pj, "base_classes");
    pj_a(pj);
    int i;
    for (i = 0; i < vmi_cti->vmi_base_count; i++) {
        pj_o(pj);
        pj_kn(pj, "type_desc_addr", vmi_cti->vmi_bases[i].base_class_addr);
        pj_kN(pj, "flags", vmi_cti->vmi_bases[i].flags);
        pj_end(pj);
    }
    pj_end(pj);
    pj_end(pj);
 
    rz_cons_print(pj_string(pj));
    pj_free(pj);
}

References base_class_type_info_t::base_class_addr, vmi_class_type_info_t::class_vtable_addr, base_class_type_info_t::flags, i, vmi_class_type_info_t::name, vmi_class_type_info_t::name_addr, vmi_class_type_info_t::name_unique, pj_a(), pj_end(), pj_free(), pj_k(), pj_kb(), pj_kN(), pj_kn(), pj_ks(), pj_new(), pj_o(), pj_string(), vmi_class_type_info_t::type, type_to_string(), vmi_class_type_info_t::typeinfo_addr, vmi_class_type_info_t::vmi_base_count, vmi_class_type_info_t::vmi_bases, vmi_class_type_info_t::vmi_flags, and vmi_class_type_info_t::vtable_addr.

Referenced by rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_read_type_name()

static bool rtti_itanium_read_type_name ( RVTableContext *  context, ut64  addr, class_type_info *  cti  )

static

Definition at line 75 of file rtti_itanium.c.

                                                                                                  {
    ut64 at;
    if (!context->read_addr(context->analysis, addr, &at)) {
        return false;
    }
    ut64 unique_mask = 1ULL << (VT_WORD_SIZE(context) * 8 - 1);
    cti->name_unique = (at & unique_mask) == 0;
    at &= ~unique_mask;
    cti->name_addr = at;
    ut8 buf[NAME_BUF_SIZE];
    if (!context->analysis->iob.read_at(context->analysis->iob.io, at, buf, sizeof(buf))) {
        return false;
    }
    buf[NAME_BUF_SIZE - 1] = 0;
    cti->name = rz_analysis_rtti_itanium_demangle_class_name(context, (char *)buf);
    if (!cti->name) {
        return false;
    }
    return true;
}

References addr, class_type_info_t::name, class_type_info_t::name_addr, NAME_BUF_SIZE, class_type_info_t::name_unique, rz_analysis_rtti_itanium_demangle_class_name(), ut64(), and VT_WORD_SIZE.

Referenced by add_class_bases(), rtti_itanium_class_type_info_init(), rtti_itanium_si_class_type_info_init(), and rtti_itanium_vmi_class_type_info_init().

rtti_itanium_read_type_name_custom()

static char* rtti_itanium_read_type_name_custom ( RVTableContext *  context, ut64  addr, ut64 *  str_addr, bool *  unique_name  )

static

Definition at line 97 of file rtti_itanium.c.

                                                                                                                       {
    ut64 at;
    if (!context->read_addr(context->analysis, addr, &at)) {
        return NULL;
    }
    ut64 unique_mask = 1ULL << (VT_WORD_SIZE(context) * 8 - 1);
    *unique_name = (at & unique_mask) == 0;
    at &= ~unique_mask;
    *str_addr = at;
    ut8 buf[NAME_BUF_SIZE];
    if (!context->analysis->iob.read_at(context->analysis->iob.io, at, buf, sizeof(buf))) {
        return NULL;
    }
    buf[NAME_BUF_SIZE - 1] = 0;
    char *name = rz_analysis_rtti_itanium_demangle_class_name(context, (char *)buf);
 
    return name;
}

References addr, name, NAME_BUF_SIZE, NULL, rz_analysis_rtti_itanium_demangle_class_name(), ut64(), and VT_WORD_SIZE.

Referenced by raw_rtti_parse().

rtti_itanium_si_class_type_info_fini()

static void rtti_itanium_si_class_type_info_fini ( si_class_type_info *  si_cti )

static

Definition at line 245 of file rtti_itanium.c.

                                                                             {
    if (si_cti) {
        free(si_cti->name);
    }
}

References free(), and si_class_type_info_t::name.

Referenced by rtti_itanium_si_class_type_info_free().

rtti_itanium_si_class_type_info_free()

static void rtti_itanium_si_class_type_info_free ( si_class_type_info *  cti )

static

Definition at line 251 of file rtti_itanium.c.

                                                                          {
    if (cti == NULL) {
        return;
    }
 
    rtti_itanium_si_class_type_info_fini(cti);
    free(cti);
}

References free(), NULL, and rtti_itanium_si_class_type_info_fini().

Referenced by rtti_itanium_si_class_type_info_new(), rtti_itanium_type_info_free(), and rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_si_class_type_info_init()

static bool rtti_itanium_si_class_type_info_init ( RVTableContext *  context, ut64  addr, si_class_type_info *  si_cti  )

static

Definition at line 260 of file rtti_itanium.c.

                                                                                                                 {
    si_cti->type = RZ_TYPEINFO_TYPE_SI_CLASS;
    ut64 at;
    if (addr == UT64_MAX) {
        return false;
    }
    if (!context->read_addr(context->analysis, addr, &at)) {
        return false;
    }
    si_cti->vtable_addr = at;
    if (!rtti_itanium_read_type_name(context, addr + VT_WORD_SIZE(context), (class_type_info *)si_cti)) {
        return false;
    }
    if (!context->read_addr(context->analysis, addr + 2 * VT_WORD_SIZE(context), &at)) {
        return false;
    }
    si_cti->base_class_addr = at;
    return true;
}

References addr, si_class_type_info_t::base_class_addr, rtti_itanium_read_type_name(), RZ_TYPEINFO_TYPE_SI_CLASS, si_class_type_info_t::type, ut64(), UT64_MAX, VT_WORD_SIZE, and si_class_type_info_t::vtable_addr.

Referenced by rtti_itanium_si_class_type_info_new().

rtti_itanium_si_class_type_info_new()

static si_class_type_info* rtti_itanium_si_class_type_info_new ( RVTableContext *  context, ut64  addr, ut64  source_vtable  )

static

Definition at line 280 of file rtti_itanium.c.

                                                                                                                       {
    si_class_type_info *result = RZ_NEW0(si_class_type_info);
    if (!result) {
        return NULL;
    }
 
    if (!rtti_itanium_si_class_type_info_init(context, addr, result)) {
        rtti_itanium_si_class_type_info_free(result);
        return NULL;
    }
 
    result->class_vtable_addr = source_vtable;
    result->typeinfo_addr = addr;
 
    return result;
}

References addr, si_class_type_info_t::class_vtable_addr, NULL, rtti_itanium_si_class_type_info_free(), rtti_itanium_si_class_type_info_init(), RZ_NEW0, and si_class_type_info_t::typeinfo_addr.

Referenced by rtti_itanium_type_info_new().

rtti_itanium_type_info_free()

static void rtti_itanium_type_info_free ( void *  info )

static

Definition at line 679 of file rtti_itanium.c.

                                                    {
    class_type_info *cti = info;
    if (!cti) {
        return;
    }
 
    switch (cti->type) {
    case RZ_TYPEINFO_TYPE_VMI_CLASS:
        rtti_itanium_vmi_class_type_info_free((vmi_class_type_info *)cti);
        return;
    case RZ_TYPEINFO_TYPE_SI_CLASS:
        rtti_itanium_si_class_type_info_free((si_class_type_info *)cti);
        return;
    case RZ_TYPEINFO_TYPE_CLASS:
        rtti_itanium_class_type_info_free(cti);
        return;
    default:
        rz_return_if_reached();
    }
}

References info(), rtti_itanium_class_type_info_free(), rtti_itanium_si_class_type_info_free(), rtti_itanium_vmi_class_type_info_free(), rz_return_if_reached, RZ_TYPEINFO_TYPE_CLASS, RZ_TYPEINFO_TYPE_SI_CLASS, RZ_TYPEINFO_TYPE_VMI_CLASS, and class_type_info_t::type.

Referenced by rz_analysis_rtti_itanium_recover_all().

rtti_itanium_type_info_new()

static class_type_info* rtti_itanium_type_info_new ( RVTableContext *  context, ut64  vtable_addr  )

static

Definition at line 637 of file rtti_itanium.c.

                                                                                              {
    /*
        vpointer - 2 words | offset to top |
                   |---------------|
        vpointer - word    | RTTI pointer  |
                   |---------------|
        vpointer   ----->  |  virt_func_0  |
    */
    ut64 rtti_ptr = vtable_addr - VT_WORD_SIZE(context); // RTTI pointer
    ut64 rtti_addr; // RTTI address
 
    if (!context->read_addr(context->analysis, rtti_ptr, &rtti_addr)) {
        return NULL;
    }
 
    RTypeInfoType type = rtti_itanium_type_info_type_from_flag(context, rtti_addr);
    // If there isn't flag telling us the type of TypeInfo
    // try to find the flag in it's vtable
    if (type == RZ_TYPEINFO_TYPE_UNKNOWN) {
        ut64 follow;
        if (!context->read_addr(context->analysis, rtti_addr, &follow)) {
            return NULL;
        }
        follow -= 2 * context->word_size;
        type = rtti_itanium_type_info_type_from_flag(context, follow);
    }
 
    if (type == RZ_TYPEINFO_TYPE_UNKNOWN) {
        return raw_rtti_parse(context, vtable_addr, rtti_addr);
    }
    switch (type) {
    case RZ_TYPEINFO_TYPE_VMI_CLASS:
        return (class_type_info *)rtti_itanium_vmi_class_type_info_new(context, rtti_addr, vtable_addr);
    case RZ_TYPEINFO_TYPE_SI_CLASS:
        return (class_type_info *)rtti_itanium_si_class_type_info_new(context, rtti_addr, vtable_addr);
    case RZ_TYPEINFO_TYPE_CLASS:
        return rtti_itanium_class_type_info_new(context, rtti_addr, vtable_addr);
    default:
        rz_return_val_if_reached(NULL);
    }
}

References NULL, raw_rtti_parse(), rtti_itanium_class_type_info_new(), rtti_itanium_si_class_type_info_new(), rtti_itanium_type_info_type_from_flag(), rtti_itanium_vmi_class_type_info_new(), rz_return_val_if_reached, RZ_TYPEINFO_TYPE_CLASS, RZ_TYPEINFO_TYPE_SI_CLASS, RZ_TYPEINFO_TYPE_UNKNOWN, RZ_TYPEINFO_TYPE_VMI_CLASS, type, ut64(), and VT_WORD_SIZE.

Referenced by rz_analysis_rtti_itanium_print_at_vtable(), and rz_analysis_rtti_itanium_recover_all().

rtti_itanium_type_info_type_from_flag()

static RTypeInfoType rtti_itanium_type_info_type_from_flag ( RVTableContext *  context, ut64  atAddress  )

static

Definition at line 448 of file rtti_itanium.c.

                                                                                                    {
    RzCore *core = context->analysis->coreb.core;
    rz_return_val_if_fail(core, RZ_TYPEINFO_TYPE_CLASS);
 
    // get the reloc flags
    const RzList *flags = context->analysis->flb.get_list(core->flags, atAddress);
    if (!flags) {
        return RZ_TYPEINFO_TYPE_UNKNOWN;
    }
 
    RzListIter *iter;
    RzFlagItem *flag;
    rz_list_foreach (flags, iter, flag) {
        if (strstr(flag->name, VMI_CLASS_TYPE_INFO_NAME)) {
            return RZ_TYPEINFO_TYPE_VMI_CLASS;
        } else if (strstr(flag->name, SI_CLASS_TYPE_INFO_NAME)) {
            return RZ_TYPEINFO_TYPE_SI_CLASS;
        } else if (strstr(flag->name, CLASS_TYPE_INFO_NAME)) {
            return RZ_TYPEINFO_TYPE_CLASS;
        }
    }
 
    return RZ_TYPEINFO_TYPE_UNKNOWN;
}

References CLASS_TYPE_INFO_NAME, rz_core_t::flags, flags, rz_flag_item_t::name, rz_return_val_if_fail, RZ_TYPEINFO_TYPE_CLASS, RZ_TYPEINFO_TYPE_SI_CLASS, RZ_TYPEINFO_TYPE_UNKNOWN, RZ_TYPEINFO_TYPE_VMI_CLASS, SI_CLASS_TYPE_INFO_NAME, and VMI_CLASS_TYPE_INFO_NAME.

Referenced by rtti_itanium_type_info_new().

rtti_itanium_vmi_class_type_info_fini()

static void rtti_itanium_vmi_class_type_info_fini ( vmi_class_type_info *  vmi_cti )

static

Definition at line 161 of file rtti_itanium.c.

                                                                                {
    if (vmi_cti) {
        free(vmi_cti->vmi_bases);
        free(vmi_cti->name);
    }
}

References free(), vmi_class_type_info_t::name, and vmi_class_type_info_t::vmi_bases.

Referenced by rtti_itanium_vmi_class_type_info_free().

rtti_itanium_vmi_class_type_info_free()

static void rtti_itanium_vmi_class_type_info_free ( vmi_class_type_info *  cti )

static

Definition at line 168 of file rtti_itanium.c.

                                                                            {
    if (cti == NULL) {
        return;
    }
 
    rtti_itanium_vmi_class_type_info_fini(cti);
    free(cti);
}

References free(), NULL, and rtti_itanium_vmi_class_type_info_fini().

Referenced by rtti_itanium_type_info_free(), rtti_itanium_vmi_class_type_info_new(), and rz_analysis_rtti_itanium_print_at_vtable().

rtti_itanium_vmi_class_type_info_init()

static bool rtti_itanium_vmi_class_type_info_init ( RVTableContext *  context, ut64  addr, vmi_class_type_info *  vmi_cti  )

static

Definition at line 177 of file rtti_itanium.c.

                                                                                                                    {
    vmi_cti->type = RZ_TYPEINFO_TYPE_VMI_CLASS;
    ut64 at;
    if (addr == UT64_MAX) {
        return false;
    }
    if (!context->read_addr(context->analysis, addr, &at)) {
        return false;
    }
    vmi_cti->vtable_addr = at;
    addr += VT_WORD_SIZE(context);
    if (!rtti_itanium_read_type_name(context, addr, (class_type_info *)vmi_cti)) {
        return false;
    }
    addr += VT_WORD_SIZE(context);
    if (!context->read_addr(context->analysis, addr, &at)) {
        return false;
    }
    vmi_cti->vmi_flags = at & 0xffffffff;
    addr += 0x4;
    if (!context->read_addr(context->analysis, addr, &at)) {
        return false;
    }
    at = at & 0xffffffff;
    if (at < 1 || at > 0xfffff) {
        RZ_LOG_ERROR("Cannot read vmi_base_count\n");
        return false;
    }
    vmi_cti->vmi_base_count = at;
    vmi_cti->vmi_bases = calloc(sizeof(base_class_type_info), vmi_cti->vmi_base_count);
    if (!vmi_cti->vmi_bases) {
        return false;
    }
    ut64 tmp_addr = addr + 0x4;
 
    int i;
    for (i = 0; i < vmi_cti->vmi_base_count; i++) {
        if (!context->read_addr(context->analysis, tmp_addr, &at)) {
            return false;
        }
        vmi_cti->vmi_bases[i].base_class_addr = at;
        tmp_addr += VT_WORD_SIZE(context);
        if (!context->read_addr(context->analysis, tmp_addr, &at)) {
            return false;
        }
        vmi_cti->vmi_bases[i].flags = at;
        tmp_addr += VT_WORD_SIZE(context);
    }
    return true;
}

References addr, base_class_type_info_t::base_class_addr, calloc(), base_class_type_info_t::flags, i, rtti_itanium_read_type_name(), RZ_LOG_ERROR, RZ_TYPEINFO_TYPE_VMI_CLASS, vmi_class_type_info_t::type, ut64(), UT64_MAX, vmi_class_type_info_t::vmi_base_count, vmi_class_type_info_t::vmi_bases, vmi_class_type_info_t::vmi_flags, VT_WORD_SIZE, and vmi_class_type_info_t::vtable_addr.

Referenced by rtti_itanium_vmi_class_type_info_new().

rtti_itanium_vmi_class_type_info_new()

static vmi_class_type_info* rtti_itanium_vmi_class_type_info_new ( RVTableContext *  context, ut64  addr, ut64  source_vtable  )

static

Definition at line 228 of file rtti_itanium.c.

                                                                                                                         {
    vmi_class_type_info *result = RZ_NEW0(vmi_class_type_info);
    if (!result) {
        return NULL;
    }
 
    if (!rtti_itanium_vmi_class_type_info_init(context, addr, result)) {
        rtti_itanium_vmi_class_type_info_free(result);
        return NULL;
    }
 
    result->class_vtable_addr = source_vtable;
    result->typeinfo_addr = addr;
 
    return result;
}

References addr, vmi_class_type_info_t::class_vtable_addr, NULL, rtti_itanium_vmi_class_type_info_free(), rtti_itanium_vmi_class_type_info_init(), RZ_NEW0, and vmi_class_type_info_t::typeinfo_addr.

Referenced by rtti_itanium_type_info_new().

rz_analysis_rtti_itanium_demangle_class_name()

RZ_API char* rz_analysis_rtti_itanium_demangle_class_name	(	RVTableContext *	context,
		const char *	name
	)

Definition at line 743 of file rtti_itanium.c.

                                                                                                     {
    if (!name || !*name) {
        return NULL;
    }
 
    char *result = NULL;
 
    if (name[0] != '_') {
        char *to_demangle = rz_str_newf("_Z%s", name);
        result = context->analysis->binb.demangle(NULL, "cxx", to_demangle, 0, false);
        free(to_demangle);
    } else {
        result = context->analysis->binb.demangle(NULL, "cxx", name, 0, false);
    }
 
    return result;
}

References free(), NULL, and rz_str_newf().

Referenced by rtti_itanium_read_type_name(), rtti_itanium_read_type_name_custom(), and rz_analysis_rtti_demangle_class_name().

rz_analysis_rtti_itanium_print_at_vtable()

RZ_API bool rz_analysis_rtti_itanium_print_at_vtable	(	RVTableContext *	context,
		ut64	addr,
		RzOutputMode	mode
	)

Definition at line 700 of file rtti_itanium.c.

                                                                                                            {
    bool use_json = mode == RZ_OUTPUT_MODE_JSON;
    class_type_info *cti = rtti_itanium_type_info_new(context, addr);
    if (!cti) {
        return false;
    }
 
    switch (cti->type) {
    case RZ_TYPEINFO_TYPE_VMI_CLASS: {
        vmi_class_type_info *vmi_cti = (vmi_class_type_info *)cti;
        if (use_json) {
            rtti_itanium_print_vmi_class_type_info_json(vmi_cti);
        } else {
            rtti_itanium_print_vmi_class_type_info(vmi_cti, "");
        }
        rtti_itanium_vmi_class_type_info_free(vmi_cti);
    }
        return true;
    case RZ_TYPEINFO_TYPE_SI_CLASS: {
        si_class_type_info *si_cti = (si_class_type_info *)cti;
        if (use_json) {
            rtti_itanium_print_si_class_type_info_json(si_cti);
        } else {
            rtti_itanium_print_si_class_type_info(si_cti, "");
        }
        rtti_itanium_si_class_type_info_free(si_cti);
    }
        return true;
    case RZ_TYPEINFO_TYPE_CLASS: {
        if (use_json) {
            rtti_itanium_print_class_type_info_json(cti);
        } else {
            rtti_itanium_print_class_type_info(cti, "");
        }
        rtti_itanium_class_type_info_free(cti);
    }
        return true;
    default:
        rtti_itanium_class_type_info_free(cti);
        rz_return_val_if_reached(false);
    }
}

References addr, rtti_itanium_class_type_info_free(), rtti_itanium_print_class_type_info(), rtti_itanium_print_class_type_info_json(), rtti_itanium_print_si_class_type_info(), rtti_itanium_print_si_class_type_info_json(), rtti_itanium_print_vmi_class_type_info(), rtti_itanium_print_vmi_class_type_info_json(), rtti_itanium_si_class_type_info_free(), rtti_itanium_type_info_new(), rtti_itanium_vmi_class_type_info_free(), RZ_OUTPUT_MODE_JSON, rz_return_val_if_reached, RZ_TYPEINFO_TYPE_CLASS, RZ_TYPEINFO_TYPE_SI_CLASS, RZ_TYPEINFO_TYPE_VMI_CLASS, and class_type_info_t::type.

Referenced by rz_analysis_rtti_print_all(), and rz_analysis_rtti_print_at_vtable().

rz_analysis_rtti_itanium_recover_all()

RZ_API void rz_analysis_rtti_itanium_recover_all	(	RVTableContext *	context,
		RzList *	vtables
	)

Definition at line 860 of file rtti_itanium.c.

                                                                                             {
    RzList /*<class_type_info>*/ *rtti_list = rz_list_new();
    rtti_list->free = rtti_itanium_type_info_free;
    // to escape multiple same infos from multiple inheritance
    SetU *unique_rttis = set_u_new();
 
    RzListIter *iter;
    RVTableInfo *vtable;
    rz_list_foreach (vtables, iter, vtable) {
        class_type_info *cti = rtti_itanium_type_info_new(context, vtable->saddr);
        if (!cti) {
            continue;
        }
 
        rz_analysis_class_create(context->analysis, cti->name);
        // can't we name virtual functions virtual even without RTTI?
        recovery_apply_vtable(context, cti->name, vtable);
        // Temporarily detect by method name
        detect_constructor_destructor(context->analysis, cti);
 
        // we only need one of a kind
        if (set_u_contains(unique_rttis, cti->typeinfo_addr)) {
            rtti_itanium_type_info_free(cti);
        } else {
            set_u_add(unique_rttis, cti->typeinfo_addr);
            rz_list_append(rtti_list, cti);
        }
    }
 
    class_type_info *cti;
    rz_list_foreach (rtti_list, iter, cti) {
        add_class_bases(context, cti);
    }
 
    set_u_free(unique_rttis);
    rz_list_free(rtti_list);
}

References add_class_bases(), detect_constructor_destructor(), rz_list_t::free, class_type_info_t::name, recovery_apply_vtable(), rtti_itanium_type_info_free(), rtti_itanium_type_info_new(), rz_analysis_class_create(), rz_list_append(), rz_list_free(), rz_list_new(), set_u_add(), set_u_contains(), set_u_free(), set_u_new(), and class_type_info_t::typeinfo_addr.

Referenced by rz_analysis_rtti_recover_all().

type_to_string()

static const char* type_to_string ( RTypeInfoType  type )

static

Definition at line 297 of file rtti_itanium.c.

                                                      {
    switch (type) {
    case RZ_TYPEINFO_TYPE_CLASS:
        return CLASS_TYPE_INFO_NAME;
    case RZ_TYPEINFO_TYPE_SI_CLASS:
        return SI_CLASS_TYPE_INFO_NAME;
    case RZ_TYPEINFO_TYPE_VMI_CLASS:
        return VMI_CLASS_TYPE_INFO_NAME;
    default:
        rz_return_val_if_reached(CLASS_TYPE_INFO_NAME);
    }
}

References CLASS_TYPE_INFO_NAME, rz_return_val_if_reached, RZ_TYPEINFO_TYPE_CLASS, RZ_TYPEINFO_TYPE_SI_CLASS, RZ_TYPEINFO_TYPE_VMI_CLASS, SI_CLASS_TYPE_INFO_NAME, type, and VMI_CLASS_TYPE_INFO_NAME.

Referenced by rtti_itanium_print_class_type_info(), rtti_itanium_print_class_type_info_json(), rtti_itanium_print_si_class_type_info(), rtti_itanium_print_si_class_type_info_json(), rtti_itanium_print_vmi_class_type_info(), and rtti_itanium_print_vmi_class_type_info_json().