type_pdb.c File Reference

#include <rz_bin.h>
#include <rz_core.h>
#include <rz_type.h>
#include <rz_pdb.h>
#include <rz_analysis.h>
#include "../bin/pdb/pdb.h"

Go to the source code of this file.

Functions
static RzType *	parse_type (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type, char *name)
static RzType *	parse_regular_type (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type, char *name)
static RzType *	parse_type_modifier (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type)
static RzType *	parse_type_pointer (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type, char *name)
static RzType *	parse_type_procedure (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type, char *name)
static RzType *	parse_type_array (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type)
static void	parse_type_arglist (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *arglist, RzPVector *vec)
static RzType *	parse_type_mfunction (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type_info, char *name)
static RzType *	parse_type_onemethod (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type_info)
static RzType *	parse_type_member (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type_info, char *name)
static RzType *	parse_type_nest (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type_info)
static RzType *	parse_union (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type)
	Parses union into BaseType and saves it into hashtable. More...
static RzTypeUnionMember *	parse_union_member (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type_info)
	Parses union member. More...
static RzType *	parse_structure (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type)
	Parses structures into BaseType and saves them into hashtable. More...
static RzTypeStructMember *	parse_struct_member (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type_info)
	Parses struct member. More...
static RzType *	parse_enum (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type)
	Parses enum into BaseType and saves it into SDB. More...
static RzTypeEnumCase *	parse_enumerate (RzPdbTpiType *type)
	Parse enum case. More...
static bool	is_parsable_type (const TpiLeafType type)
static char *	create_type_name_from_offset (ut64 offset)
	Create a type name from offset. More...
static RzType *	parse_type_static_member (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type_info, char *name)
static bool	is_tpitype_unnamed (const char *name)
static RzBaseType *	get_tpitype_basetype (const RzTypeDB *typedb, RzPdbTpiType *type, const char *name)
static RzType *	create_rztype (RzPdbTpiType *type, RzTypeIdentifierKind kind, const char *name)
static void	parse_types (const RzTypeDB *typedb, RzPdbTpiStream *stream, RzPdbTpiType *type)
	Delegate the type parsing to appropriate function. More...
RZ_API void	rz_parse_pdb_types (const RzTypeDB *typedb, const RzPdb *pdb)
	Saves PDB types from TPI stream into the type database. More...

Function Documentation

create_rztype()

static RzType* create_rztype ( RzPdbTpiType *  type, RzTypeIdentifierKind  kind, const char *  name  )

static

Definition at line 426 of file type_pdb.c.

                                                                                              {
    RzType *t = RZ_NEW0(RzType);
    if (!t) {
        return NULL;
    }
    t->kind = RZ_TYPE_KIND_IDENTIFIER;
    t->identifier.kind = kind;
    t->identifier.name = is_tpitype_unnamed(name) ? create_type_name_from_offset(type->type_index) : strdup(name);
    return t;
}

References create_type_name_from_offset(), rz_type_t::identifier, is_tpitype_unnamed(), rz_type_t::kind, NULL, RZ_NEW0, RZ_TYPE_KIND_IDENTIFIER, strdup(), and type.

Referenced by parse_structure(), and parse_union().

create_type_name_from_offset()

static char* create_type_name_from_offset ( ut64  offset )

static

Create a type name from offset.

Parameters

offset

Returns

char* Name or NULL if error

Definition at line 46 of file type_pdb.c.

                                                       {
    int offset_length = snprintf(NULL, 0, "type_0x%" PFMT64x, offset);
    char *str = malloc(offset_length + 1);
    snprintf(str, offset_length + 1, "type_0x%" PFMT64x, offset);
    return str;
}

References malloc(), NULL, PFMT64x, snprintf, and cmd_descs_generate::str.

Referenced by create_rztype(), get_tpitype_basetype(), parse_enum(), parse_type_nest(), and parse_type_procedure().

get_tpitype_basetype()

static RzBaseType* get_tpitype_basetype ( const RzTypeDB *  typedb, RzPdbTpiType *  type, const char *  name  )

inlinestatic

Definition at line 414 of file type_pdb.c.

                                                                                                             {
    RzBaseType *base_type;
    if (is_tpitype_unnamed(name)) {
        char *tmp_name = create_type_name_from_offset(type->type_index);
        base_type = rz_type_db_get_base_type(typedb, tmp_name);
        free(tmp_name);
    } else {
        base_type = rz_type_db_get_base_type(typedb, name);
    }
    return base_type;
}

References create_type_name_from_offset(), free(), is_tpitype_unnamed(), rz_type_db_get_base_type(), and type.

Referenced by parse_enum(), parse_structure(), and parse_union().

is_parsable_type()

static bool is_parsable_type ( const TpiLeafType  type )

static

Definition at line 30 of file type_pdb.c.

                                                     {
    rz_return_val_if_fail(type, false);
    return (type == LF_STRUCTURE ||
        type == LF_UNION ||
        type == LF_ENUM ||
        type == LF_CLASS ||
        type == LF_CLASS_19 ||
        type == LF_STRUCTURE_19);
}

References LF_CLASS, LF_CLASS_19, LF_ENUM, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, rz_return_val_if_fail, and type.

Referenced by rz_parse_pdb_types().

is_tpitype_unnamed()

static bool is_tpitype_unnamed ( const char *  name )

inlinestatic

Definition at line 410 of file type_pdb.c.

                                                        {
    return !name || !strcmp(name, "<unnamed-tag>") || !strcmp(name, "<anonymous-tag>");
}

Referenced by create_rztype(), get_tpitype_basetype(), and parse_enum().

parse_enum()

static RzType * parse_enum ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type  )

static

Parses enum into BaseType and saves it into SDB.

Parameters

t	RzTypeDB instance
stream	TPI Stream
type	Current type

Definition at line 683 of file type_pdb.c.

                                                                                              {
    rz_return_val_if_fail(typedb && type, NULL);
    Tpi_LF_Enum *lf_enum = type->type_data;
    // assert all member functions we need info from
    RzBaseType *base_type = NULL;
    char *name = rz_bin_pdb_get_type_name(type);
    if (name) {
        base_type = get_tpitype_basetype(typedb, type, name);
        if (base_type) {
            if (base_type->kind != RZ_BASE_TYPE_KIND_ENUM) {
                RZ_LOG_WARN("PDB: Type of %s (enum) conflicts with already defined type (%s), redefining it.\n",
                    name, rz_type_base_type_kind_as_string(base_type->kind));
                rz_type_db_delete_base_type((RzTypeDB *)typedb, base_type);
                base_type = NULL;
            } else if (type->parsed || rz_bin_pdb_type_is_fwdref(type)) {
                return base_type->type ? rz_type_clone(base_type->type) : NULL;
            } else if (base_type->attrs != RZ_TYPE_TYPECLASS_INVALID) {
                RZ_LOG_INFO("%s : Redefining type %s.\n", __FUNCTION__, name);
            }
        }
    }
 
    if (!base_type) {
        base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ENUM);
        if (!base_type) {
            return NULL;
        }
 
        RzPdbTpiType *utype = rz_bin_pdb_get_type_by_index(stream, lf_enum->utype);
        if (!utype) {
            rz_type_base_type_free(base_type);
            return NULL;
        }
        RzType *btype = parse_type(typedb, stream, utype, NULL);
        if (!btype) {
            rz_type_base_type_free(base_type);
            return NULL;
        }
        base_type->name = is_tpitype_unnamed(name) ? create_type_name_from_offset(type->type_index) : strdup(name);
        base_type->size = rz_type_db_get_bitsize(typedb, btype);
        base_type->type = btype;
        base_type->attrs = RZ_TYPE_TYPECLASS_INVALID;
        rz_type_db_save_base_type(typedb, base_type);
 
        if (rz_bin_pdb_type_is_fwdref(type)) {
            return rz_type_clone(base_type->type);
        }
    }
    rz_vector_clear(&base_type->enum_data.cases);
    RzList *members = rz_bin_pdb_get_type_members(stream, type);
    RzListIter *it;
    RzPdbTpiType *member_info;
    rz_list_foreach (members, it, member_info) {
        if (member_info->leaf_type == LF_INDEX) {
            type = rz_bin_pdb_get_type_by_index(stream, rz_bin_pdb_get_type_val(member_info));
            members = rz_bin_pdb_get_type_members(stream, type);
            it = rz_list_head(members);
            if (!it) {
                break;
            }
            member_info = rz_list_first(members);
        }
        RzTypeEnumCase *enum_case = parse_enumerate(member_info);
        if (!enum_case) {
            continue; // skip it, move forward
        }
        void *element = rz_vector_push(&base_type->enum_data.cases, enum_case);
        if (!element) {
            rz_type_base_enum_case_free(enum_case, NULL);
            return NULL;
        }
        free(enum_case);
    }
    if (base_type->attrs == RZ_TYPE_TYPECLASS_INVALID) {
        base_type->attrs = RZ_TYPE_TYPECLASS_NONE;
        rz_list_append(stream->print_type, base_type);
    }
    type->parsed = true;
    return base_type->type ? rz_type_clone(base_type->type) : NULL;
}

References rz_base_type_t::attrs, rz_base_type_enum_t::cases, create_type_name_from_offset(), rz_base_type_t::enum_data, free(), get_tpitype_basetype(), is_tpitype_unnamed(), rz_base_type_t::kind, tpi_types::leaf_type, LF_INDEX, rz_base_type_t::name, NULL, parse_enumerate(), parse_type(), RZ_BASE_TYPE_KIND_ENUM, rz_bin_pdb_get_type_by_index(), rz_bin_pdb_get_type_members(), rz_bin_pdb_get_type_name(), rz_bin_pdb_get_type_val(), rz_bin_pdb_type_is_fwdref(), rz_list_append(), rz_list_first(), RZ_LOG_INFO, RZ_LOG_WARN, rz_return_val_if_fail, rz_type_base_enum_case_free(), rz_type_base_type_free(), rz_type_base_type_kind_as_string(), rz_type_base_type_new(), rz_type_clone(), rz_type_db_delete_base_type(), rz_type_db_get_bitsize(), rz_type_db_save_base_type(), RZ_TYPE_TYPECLASS_INVALID, RZ_TYPE_TYPECLASS_NONE, rz_vector_clear(), rz_vector_push(), rz_base_type_t::size, strdup(), type, rz_base_type_t::type, and Tpi_LF_Enum::utype.

Referenced by parse_regular_type(), and parse_types().

parse_enumerate()

static RzTypeEnumCase * parse_enumerate ( RzPdbTpiType *  type )

static

Parse enum case.

Parameters

type_info

Current type info (enum case)

Returns

RzTypeEnumCase* parsed enum case, NULL if fail

Definition at line 657 of file type_pdb.c.

                                                           {
    rz_return_val_if_fail(type && type->leaf_type == LF_ENUMERATE, NULL);
 
    char *name = NULL;
    ut64 value = 0;
    // sometimes, the type doesn't have get_val for some reason
    value = rz_bin_pdb_get_type_val(type);
    name = rz_bin_pdb_get_type_name(type);
    RzTypeEnumCase *cas = RZ_NEW0(RzTypeEnumCase);
    if (!cas) {
        goto cleanup;
    }
    cas->name = strdup(name);
    cas->val = value;
    return cas;
cleanup:
    return NULL;
}

References cleanup(), LF_ENUMERATE, rz_type_enum_case_t::name, NULL, rz_bin_pdb_get_type_name(), rz_bin_pdb_get_type_val(), RZ_NEW0, rz_return_val_if_fail, strdup(), type, ut64(), rz_type_enum_case_t::val, and value.

Referenced by parse_enum().

parse_regular_type()

static RzType * parse_regular_type ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type, char *  name  )

static

Definition at line 74 of file type_pdb.c.

                                                                                                                  {
    rz_return_val_if_fail(type && stream && typedb, NULL);
    switch (type->leaf_type) {
    case LF_CLASS:
    case LF_CLASS_19:
        // TODO: https://github.com/rizinorg/rizin/issues/1205
        RZ_LOG_INFO("%s : LF_CLASS is not handled for now.\n", __FUNCTION__);
        break;
    case LF_STRUCTURE:
    case LF_STRUCTURE_19:
        return parse_structure(typedb, stream, type);
    case LF_MODIFIER:
        return parse_type_modifier(typedb, stream, type);
    case LF_ARRAY:
        return parse_type_array(typedb, stream, type);
    case LF_BITFIELD:
        // TODO: we don't have BITFIELD type for now https://github.com/rizinorg/rizin/issues/1240
        RZ_LOG_INFO("%s : LF_BITFIELD is not handled for now.\n", __FUNCTION__);
        break;
    case LF_POINTER:
        return parse_type_pointer(typedb, stream, type, name);
    case LF_PROCEDURE:
        return parse_type_procedure(typedb, stream, type, name);
    case LF_UNION:
        return parse_union(typedb, stream, type);
    case LF_ENUM:
        return parse_enum(typedb, stream, type);
    default:
        RZ_LOG_INFO("%s : unsupported leaf type 0x%x\n", __FUNCTION__, type->leaf_type);
        break;
    }
    return NULL;
}

References LF_ARRAY, LF_BITFIELD, LF_CLASS, LF_CLASS_19, LF_ENUM, LF_MODIFIER, LF_POINTER, LF_PROCEDURE, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, NULL, parse_enum(), parse_structure(), parse_type_array(), parse_type_modifier(), parse_type_pointer(), parse_type_procedure(), parse_union(), RZ_LOG_INFO, rz_return_val_if_fail, and type.

Referenced by parse_type().

parse_struct_member()

static RzTypeStructMember * parse_struct_member ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type_info  )

static

Parses struct member.

Parameters

typedb	Types DB instance
stream	TPI Stream
type_info	Current RzPdbTpiType (member)

Returns

RzTypeStructMember* parsed member, NULL if fail

Definition at line 352 of file type_pdb.c.

                                                                                                                        {
    rz_return_val_if_fail(type_info, NULL);
    char *name = NULL;
    ut64 offset = 0;
    RzType *type = NULL;
    switch (type_info->leaf_type) {
    case LF_ONEMETHOD: {
        name = rz_bin_pdb_get_type_name(type_info);
        type = parse_type_onemethod(typedb, stream, type_info);
        break;
    }
    case LF_MEMBER: {
        offset = rz_bin_pdb_get_type_val(type_info);
        name = rz_bin_pdb_get_type_name(type_info);
        type = parse_type_member(typedb, stream, type_info, name);
        break;
    }
    case LF_STMEMBER: {
        name = rz_bin_pdb_get_type_name(type_info);
        type = parse_type_static_member(typedb, stream, type_info, name);
        break;
    }
    case LF_NESTTYPE: {
        name = rz_bin_pdb_get_type_name(type_info);
        type = parse_type_nest(typedb, stream, type_info);
        break;
    }
    case LF_BCLASS:
        // For structure, we don't need base class for now
        goto cleanup;
    case LF_METHOD:
        // TODO: need to handle overloaded methods here
        goto cleanup;
    case LF_VFUNCTAB:
        // For structure, we don't need vtable for now
        goto cleanup;
    default:
        RZ_LOG_ERROR("%s : unsupported leaf type 0x%x\n", __FUNCTION__, type_info->leaf_type);
        goto cleanup;
    }
    if (!type) {
        RZ_LOG_INFO("%s : couldn't parse structure member type!\n", __FUNCTION__);
        return NULL;
    }
 
    RzTypeStructMember *member = RZ_NEW0(RzTypeStructMember);
    if (!member) {
        goto cleanup;
    }
    member->name = strdup(name);
    member->type = type;
    member->offset = offset;
    return member;
cleanup:
    rz_type_free(type);
    return NULL;
}

References cleanup(), tpi_types::leaf_type, LF_BCLASS, LF_MEMBER, LF_METHOD, LF_NESTTYPE, LF_ONEMETHOD, LF_STMEMBER, LF_VFUNCTAB, rz_type_struct_member_t::name, NULL, rz_type_struct_member_t::offset, parse_type_member(), parse_type_nest(), parse_type_onemethod(), parse_type_static_member(), rz_bin_pdb_get_type_name(), rz_bin_pdb_get_type_val(), RZ_LOG_ERROR, RZ_LOG_INFO, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), strdup(), type, rz_type_struct_member_t::type, and ut64().

Referenced by parse_structure().

parse_structure()

static RzType * parse_structure ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type  )

static

Parses structures into BaseType and saves them into hashtable.

Parameters

t	RzTypeDB instance
stream	TPI Stream
type	Current type

Definition at line 444 of file type_pdb.c.

                                                                                                   {
    rz_return_val_if_fail(typedb && stream && type, NULL);
 
    RzBaseType *base_type = NULL;
    char *name = rz_bin_pdb_get_type_name(type);
    if (name) {
        base_type = get_tpitype_basetype(typedb, type, name);
        if (base_type) {
            if (base_type->kind != RZ_BASE_TYPE_KIND_STRUCT) {
                RZ_LOG_WARN("PDB: Type of %s (struct) conflicts with already defined type (%s), redefining it.\n",
                    name, rz_type_base_type_kind_as_string(base_type->kind));
                rz_type_db_delete_base_type((RzTypeDB *)typedb, base_type);
                base_type = NULL;
            } else if (type->parsed || rz_bin_pdb_type_is_fwdref(type)) {
                return base_type->type ? rz_type_clone(base_type->type) : create_rztype(type, RZ_TYPE_IDENTIFIER_KIND_STRUCT, name);
            } else if (base_type->attrs != RZ_TYPE_TYPECLASS_INVALID) {
                RZ_LOG_INFO("%s : Redefining type %s.\n", __FUNCTION__, name);
            }
        }
    }
 
    if (!base_type) {
        base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_STRUCT);
        if (!base_type) {
            return NULL;
        }
 
        RzType *typ = create_rztype(type, RZ_TYPE_IDENTIFIER_KIND_STRUCT, name);
        if (!typ) {
            rz_type_base_type_free(base_type);
            return NULL;
        }
        base_type->type = typ;
        base_type->name = strdup(typ->identifier.name);
        base_type->attrs = RZ_TYPE_TYPECLASS_INVALID;
        rz_type_db_save_base_type(typedb, base_type);
 
        if (rz_bin_pdb_type_is_fwdref(type)) {
            return rz_type_clone(base_type->type);
        }
    }
    rz_vector_clear(&base_type->struct_data.members);
    RzList *members = rz_bin_pdb_get_type_members(stream, type);
    RzListIter *it;
    RzPdbTpiType *member_info;
    rz_list_foreach (members, it, member_info) {
        if (member_info->leaf_type == LF_INDEX) {
            type = rz_bin_pdb_get_type_by_index(stream, rz_bin_pdb_get_type_val(member_info));
            members = rz_bin_pdb_get_type_members(stream, type);
            it = rz_list_head(members);
            if (!it) {
                break;
            }
            member_info = rz_list_first(members);
        }
        RzTypeStructMember *struct_member = parse_struct_member(typedb, stream, member_info);
        if (!struct_member) {
            continue; // skip the failure
        }
        void *element = rz_vector_push(&base_type->struct_data.members, struct_member);
        if (!element) {
            rz_type_base_struct_member_free(struct_member, NULL);
            return NULL;
        }
        free(struct_member);
    }
    base_type->size = rz_bin_pdb_get_type_val(type);
    if (base_type->attrs == RZ_TYPE_TYPECLASS_INVALID) {
        base_type->attrs = RZ_TYPE_TYPECLASS_NONE;
        rz_list_append(stream->print_type, base_type);
    }
    type->parsed = true;
    return base_type->type ? rz_type_clone(base_type->type) : NULL;
}

References rz_base_type_t::attrs, create_rztype(), free(), get_tpitype_basetype(), rz_type_t::identifier, rz_base_type_t::kind, tpi_types::leaf_type, LF_INDEX, rz_base_type_struct_t::members, rz_base_type_t::name, NULL, parse_struct_member(), RZ_BASE_TYPE_KIND_STRUCT, rz_bin_pdb_get_type_by_index(), rz_bin_pdb_get_type_members(), rz_bin_pdb_get_type_name(), rz_bin_pdb_get_type_val(), rz_bin_pdb_type_is_fwdref(), rz_list_append(), rz_list_first(), RZ_LOG_INFO, RZ_LOG_WARN, rz_return_val_if_fail, rz_type_base_struct_member_free(), rz_type_base_type_free(), rz_type_base_type_kind_as_string(), rz_type_base_type_new(), rz_type_clone(), rz_type_db_delete_base_type(), rz_type_db_save_base_type(), RZ_TYPE_IDENTIFIER_KIND_STRUCT, RZ_TYPE_TYPECLASS_INVALID, RZ_TYPE_TYPECLASS_NONE, rz_vector_clear(), rz_vector_push(), rz_base_type_t::size, strdup(), rz_base_type_t::struct_data, type, and rz_base_type_t::type.

Referenced by parse_regular_type(), and parse_types().

parse_type()

static RzType * parse_type ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type, char *  name  )

static

Definition at line 153 of file type_pdb.c.

                                                                                                          {
    rz_return_val_if_fail(type && typedb, NULL);
    RzType *typ;
    if (type->leaf_type == LF_SIMPLE_TYPE) {
        Tpi_LF_SimpleType *simple_type = type->type_data;
        char *error_msg = NULL;
        typ = rz_type_parse_string_single(typedb->parser, simple_type->type, &error_msg);
        if (error_msg) {
            RZ_LOG_ERROR("%s : Error parsing complex type member \"%s\" type:\n%s\n", __FUNCTION__, simple_type->type, error_msg);
            RZ_FREE(error_msg);
        }
        return typ;
    } else {
        if (type->leaf_type == LF_POINTER) {
            return parse_type_pointer(typedb, stream, type, name);
        } else {
            return parse_regular_type(typedb, stream, type, name);
        }
    }
}

References LF_POINTER, LF_SIMPLE_TYPE, NULL, parse_regular_type(), parse_type_pointer(), rz_type_db_t::parser, RZ_FREE, RZ_LOG_ERROR, rz_return_val_if_fail, rz_type_parse_string_single(), type, and Tpi_LF_SimpleType::type.

Referenced by parse_enum(), parse_type_arglist(), parse_type_array(), parse_type_member(), parse_type_mfunction(), parse_type_modifier(), parse_type_nest(), parse_type_pointer(), parse_type_procedure(), and parse_type_static_member().

parse_type_arglist()

static void parse_type_arglist ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  arglist, RzPVector *  vec  )

static

Definition at line 174 of file type_pdb.c.

                                                                                                                      {
    rz_return_if_fail(arglist && typedb && vec);
    Tpi_LF_Arglist *lf_arglist = arglist->type_data;
    if (!vec) {
        return;
    }
    ut32 *ptr_types = lf_arglist->arg_type;
    for (int i = 0; i < lf_arglist->count; i++) {
        RzPdbTpiType *stype = rz_bin_pdb_get_type_by_index(stream, *ptr_types++);
        if (!stype) {
            continue;
        }
        RzType *type = parse_type(typedb, stream, stype, NULL);
        if (!type) {
            continue;
        }
        RzCallableArg *arg = RZ_NEW0(RzCallableArg);
        arg->name = rz_str_newf("arg%d", i);
        arg->type = type;
        rz_pvector_push(vec, arg);
    }
}

References Tpi_LF_Arglist::arg_type, Tpi_LF_Arglist::count, i, arg::name, NULL, parse_type(), rz_bin_pdb_get_type_by_index(), RZ_NEW0, rz_pvector_push(), rz_return_if_fail, rz_str_newf(), type, and tpi_types::type_data.

Referenced by parse_type_mfunction(), and parse_type_procedure().

parse_type_array()

static RzType * parse_type_array ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type  )

static

Definition at line 53 of file type_pdb.c.

                                                                                                    {
    rz_return_val_if_fail(type && stream && typedb, NULL);
    Tpi_LF_Array *lf_array = type->type_data;
    RzPdbTpiType *element = rz_bin_pdb_get_type_by_index(stream, lf_array->element_type);
    if (!element) {
        return NULL;
    }
    RzType *element_type = parse_type(typedb, stream, element, NULL);
    if (!element_type) {
        return NULL;
    }
    RzType *typ = RZ_NEW0(RzType);
    if (!typ) {
        return NULL;
    }
    typ->kind = RZ_TYPE_KIND_ARRAY;
    typ->array.type = element_type;
    typ->array.count = rz_bin_pdb_get_type_val(type);
    return typ;
}

References rz_type_t::array, Tpi_LF_Array::element_type, rz_type_t::kind, NULL, parse_type(), rz_bin_pdb_get_type_by_index(), rz_bin_pdb_get_type_val(), RZ_NEW0, rz_return_val_if_fail, RZ_TYPE_KIND_ARRAY, and type.

Referenced by parse_regular_type().

parse_type_member()

static RzType * parse_type_member ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type_info, char *  name  )

static

Definition at line 288 of file type_pdb.c.

                                                                                                                      {
    rz_return_val_if_fail(type_info && typedb, NULL);
    Tpi_LF_Member *lf_member = type_info->type_data;
 
    RzPdbTpiType *utype = rz_bin_pdb_get_type_by_index(stream, lf_member->index);
    if (!utype) {
        return NULL;
    }
    return parse_type(typedb, stream, utype, name);
}

References Tpi_LF_Member::index, NULL, parse_type(), rz_bin_pdb_get_type_by_index(), rz_return_val_if_fail, and tpi_types::type_data.

Referenced by parse_struct_member(), and parse_union_member().

parse_type_mfunction()

static RzType * parse_type_mfunction ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type_info, char *  name  )

static

Definition at line 238 of file type_pdb.c.

                                                                                                                         {
    rz_return_val_if_fail(type_info && stream && typedb, NULL);
    Tpi_LF_MFcuntion *lf_mfunction = type_info->type_data;
    RzType *type = RZ_NEW0(RzType);
    RzCallable *callable = RZ_NEW0(RzCallable);
    if (!type || !callable) {
        free(type);
        free(callable);
        return NULL;
    }
    type->kind = RZ_TYPE_KIND_CALLABLE;
    type->callable = callable;
    type->callable->name = strdup(name);
    type->callable->cc = rz_bin_pdb_calling_convention_as_string(lf_mfunction->call_conv);
    // parse return type
    RzPdbTpiType *ret_type = rz_bin_pdb_get_type_by_index(stream, lf_mfunction->return_type);
    if (ret_type) {
        type->callable->ret = parse_type(typedb, stream, ret_type, name);
        if (!type->callable->ret) {
            type->callable->noret = true;
        }
    }
    // parse parameter list
    type->callable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
    if (!type->callable->args) {
        rz_type_free(type);
        return NULL;
    }
    RzPdbTpiType *arglist = rz_bin_pdb_get_type_by_index(stream, lf_mfunction->arglist);
    if (arglist) {
        parse_type_arglist(typedb, stream, arglist, type->callable->args);
    }
    rz_type_func_save((RzTypeDB *)typedb, callable);
    return type;
}

References Tpi_LF_MFcuntion::arglist, Tpi_LF_MFcuntion::call_conv, free(), NULL, parse_type(), parse_type_arglist(), Tpi_LF_MFcuntion::return_type, rz_bin_pdb_calling_convention_as_string(), rz_bin_pdb_get_type_by_index(), RZ_NEW0, rz_pvector_new(), rz_return_val_if_fail, rz_type_callable_arg_free(), rz_type_free(), rz_type_func_save(), RZ_TYPE_KIND_CALLABLE, strdup(), type, and tpi_types::type_data.

Referenced by parse_type_onemethod().

parse_type_modifier()

static RzType * parse_type_modifier ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type  )

static

Definition at line 108 of file type_pdb.c.

                                                                                                       {
    rz_return_val_if_fail(type && stream && typedb, NULL);
    Tpi_LF_Modifier *lf_modifier = type->type_data;
    RzPdbTpiType *m_utype = rz_bin_pdb_get_type_by_index(stream, lf_modifier->modified_type);
    if (m_utype) {
        RzType *typ = parse_type(typedb, stream, m_utype, NULL);
        if (typ && lf_modifier->umodifier.bits.const_) {
            switch (typ->kind) {
            case RZ_TYPE_KIND_IDENTIFIER:
                typ->identifier.is_const = true;
                break;
            case RZ_TYPE_KIND_POINTER:
                typ->pointer.is_const = true;
                break;
            default:
                break;
            }
        }
        return typ;
    }
    return NULL;
}

References TpiCVModifier::bits, TpiCVModifier::const_, rz_type_t::identifier, rz_type_t::kind, Tpi_LF_Modifier::modified_type, NULL, parse_type(), rz_type_t::pointer, rz_bin_pdb_get_type_by_index(), rz_return_val_if_fail, RZ_TYPE_KIND_IDENTIFIER, RZ_TYPE_KIND_POINTER, type, and Tpi_LF_Modifier::umodifier.

Referenced by parse_regular_type().

parse_type_nest()

static RzType * parse_type_nest ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type_info  )

static

Definition at line 309 of file type_pdb.c.

                                                                                                        {
    rz_return_val_if_fail(type_info && stream && typedb, NULL);
    Tpi_LF_NestType *lf_nest = type_info->type_data;
    RzPdbTpiType *utype = rz_bin_pdb_get_type_by_index(stream, lf_nest->index);
    if (!utype) {
        return NULL;
    }
    char *name = rz_bin_pdb_get_type_name(utype);
    if (name) {
        RzBaseType *b_type = rz_type_db_get_base_type(typedb, name);
        if (b_type && b_type->type) {
            if (b_type->type->kind == RZ_TYPE_KIND_IDENTIFIER) {
                return rz_type_clone(b_type->type);
            }
        }
        return NULL;
    }
 
    RzType *n_type = parse_type(typedb, stream, utype, NULL);
    if (!n_type) {
        return NULL;
    }
    RzBaseType *btype = rz_type_base_type_new(RZ_BASE_TYPE_KIND_TYPEDEF);
    if (!btype) {
        return NULL;
    }
    btype->name = name ? strdup(name) : create_type_name_from_offset(lf_nest->index);
    btype->type = n_type;
    rz_type_db_save_base_type(typedb, btype);
    if (n_type->kind == RZ_TYPE_KIND_IDENTIFIER) {
        return rz_type_clone(n_type);
    }
    return NULL;
}

References create_type_name_from_offset(), Tpi_LF_NestType::index, rz_type_t::kind, rz_base_type_t::name, NULL, parse_type(), RZ_BASE_TYPE_KIND_TYPEDEF, rz_bin_pdb_get_type_by_index(), rz_bin_pdb_get_type_name(), rz_return_val_if_fail, rz_type_base_type_new(), rz_type_clone(), rz_type_db_get_base_type(), rz_type_db_save_base_type(), RZ_TYPE_KIND_IDENTIFIER, strdup(), rz_base_type_t::type, and tpi_types::type_data.

Referenced by parse_struct_member(), and parse_union_member().

parse_type_onemethod()

static RzType * parse_type_onemethod ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type_info  )

static

Definition at line 274 of file type_pdb.c.

                                                                                                             {
    rz_return_val_if_fail(type_info && typedb, NULL);
    Tpi_LF_OneMethod *lf_onemethod = type_info->type_data;
    char *name = rz_bin_pdb_get_type_name(type_info);
    RzPdbTpiType *utype = rz_bin_pdb_get_type_by_index(stream, lf_onemethod->index);
    if (!utype) {
        return NULL;
    }
    if (utype->leaf_type == LF_MFUNCTION) {
        return parse_type_mfunction(typedb, stream, utype, name);
    }
    return NULL;
}

References Tpi_LF_OneMethod::index, tpi_types::leaf_type, LF_MFUNCTION, NULL, parse_type_mfunction(), rz_bin_pdb_get_type_by_index(), rz_bin_pdb_get_type_name(), rz_return_val_if_fail, and tpi_types::type_data.

Referenced by parse_struct_member(), and parse_union_member().

parse_type_pointer()

static RzType * parse_type_pointer ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type, char *  name  )

static

Definition at line 131 of file type_pdb.c.

                                                                                                                  {
    rz_return_val_if_fail(type && typedb, NULL);
    Tpi_LF_Pointer *lf_pointer = type->type_data;
    RzType *typ = RZ_NEW0(RzType);
    if (!typ) {
        goto error;
    }
    typ->kind = RZ_TYPE_KIND_POINTER;
    RzPdbTpiType *p_utype = rz_bin_pdb_get_type_by_index(stream, lf_pointer->utype);
    if (p_utype) {
        RzType *tmp = parse_type(typedb, stream, p_utype, name);
        if (!tmp) {
            goto error;
        }
        typ->pointer.type = tmp;
        return typ;
    }
error:
    rz_type_free(typ);
    return NULL;
}

References error(), rz_type_t::kind, NULL, parse_type(), rz_type_t::pointer, rz_bin_pdb_get_type_by_index(), RZ_NEW0, rz_return_val_if_fail, rz_type_free(), RZ_TYPE_KIND_POINTER, autogen_x86imm::tmp, type, and Tpi_LF_Pointer::utype.

Referenced by parse_regular_type(), and parse_type().

parse_type_procedure()

static RzType * parse_type_procedure ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type, char *  name  )

static

Definition at line 197 of file type_pdb.c.

                                                                                                                    {
    rz_return_val_if_fail(type && stream && typedb, NULL);
    Tpi_LF_Procedure *lf_procedure = type->type_data;
    RzType *typ = RZ_NEW0(RzType);
    RzCallable *callable = RZ_NEW0(RzCallable);
    if (!typ || !callable) {
        free(typ);
        free(callable);
        return NULL;
    }
    typ->kind = RZ_TYPE_KIND_CALLABLE;
    typ->callable = callable;
    if (!name) {
        typ->callable->name = create_type_name_from_offset(type->type_index);
    } else {
        typ->callable->name = strdup(name);
    }
 
    typ->callable->cc = rz_bin_pdb_calling_convention_as_string(lf_procedure->call_conv);
    // parse return type
    RzPdbTpiType *ret_type = rz_bin_pdb_get_type_by_index(stream, lf_procedure->return_type);
    if (ret_type) {
        typ->callable->ret = parse_type(typedb, stream, ret_type, name);
        if (!typ->callable->ret) {
            typ->callable->noret = true;
        }
    }
    // parse parameter list
    typ->callable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
    if (!typ->callable->args) {
        rz_type_free(typ);
        return NULL;
    }
    RzPdbTpiType *arglist = rz_bin_pdb_get_type_by_index(stream, lf_procedure->arg_list);
    if (arglist) {
        parse_type_arglist(typedb, stream, arglist, typ->callable->args);
    }
    rz_type_func_save((RzTypeDB *)typedb, callable);
    return typ;
}

References Tpi_LF_Procedure::arg_list, rz_callable_at::args, Tpi_LF_Procedure::call_conv, rz_type_t::callable, rz_callable_at::cc, create_type_name_from_offset(), free(), rz_type_t::kind, rz_callable_at::name, rz_callable_at::noret, NULL, parse_type(), parse_type_arglist(), rz_callable_at::ret, Tpi_LF_Procedure::return_type, rz_bin_pdb_calling_convention_as_string(), rz_bin_pdb_get_type_by_index(), RZ_NEW0, rz_pvector_new(), rz_return_val_if_fail, rz_type_callable_arg_free(), rz_type_free(), rz_type_func_save(), RZ_TYPE_KIND_CALLABLE, strdup(), and type.

Referenced by parse_regular_type().

parse_type_static_member()

static RzType* parse_type_static_member ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type_info, char *  name  )

static

Definition at line 299 of file type_pdb.c.

                                                                                                                             {
    rz_return_val_if_fail(type_info && typedb, NULL);
    Tpi_LF_StaticMember *lf_stmember = type_info->type_data;
    RzPdbTpiType *utype = rz_bin_pdb_get_type_by_index(stream, lf_stmember->index);
    if (!utype) {
        return NULL;
    }
    return parse_type(typedb, stream, utype, name);
}

References Tpi_LF_StaticMember::index, NULL, parse_type(), rz_bin_pdb_get_type_by_index(), rz_return_val_if_fail, and tpi_types::type_data.

Referenced by parse_struct_member().

parse_types()

static void parse_types ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type  )

static

Delegate the type parsing to appropriate function.

Parameters

t	RzTypeDB instance
stream	TPI Stream
type	Current type

Definition at line 771 of file type_pdb.c.

                                                                                            {
    rz_return_if_fail(typedb && type);
 
    switch (type->leaf_type) {
    case LF_CLASS:
    case LF_CLASS_19:
        break;
    case LF_STRUCTURE:
    case LF_STRUCTURE_19:
        parse_structure(typedb, stream, type);
        break;
    case LF_UNION:
        parse_union(typedb, stream, type);
        break;
    case LF_ENUM:
        parse_enum(typedb, stream, type);
        break;
    default:
        // shouldn't happen, happens when someone modifies leafs that get here
        // but not how they should be parsed
        RZ_LOG_ERROR("Unknown type record");
        break;
    }
}

References LF_CLASS, LF_CLASS_19, LF_ENUM, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, parse_enum(), parse_structure(), parse_union(), RZ_LOG_ERROR, rz_return_if_fail, and type.

Referenced by rz_parse_pdb_types().

parse_union()

static RzType * parse_union ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type  )

static

Parses union into BaseType and saves it into hashtable.

Parameters

typedb	Types DB instance
stream	TPI Stream
type_info	Current RzPdbTpiType (enum case)

Definition at line 577 of file type_pdb.c.

                                                                                               {
    rz_return_val_if_fail(typedb && stream && type, NULL);
 
    RzBaseType *base_type = NULL;
    char *name = rz_bin_pdb_get_type_name(type);
    if (name) {
        base_type = get_tpitype_basetype(typedb, type, name);
        if (base_type) {
            if (base_type->kind != RZ_BASE_TYPE_KIND_UNION) {
                RZ_LOG_WARN("PDB: Type of %s (union) conflicts with already defined type (%s), redefining it.\n",
                    name, rz_type_base_type_kind_as_string(base_type->kind));
                rz_type_db_delete_base_type((RzTypeDB *)typedb, base_type);
                base_type = NULL;
            } else if (type->parsed || rz_bin_pdb_type_is_fwdref(type)) {
                return base_type->type ? rz_type_clone(base_type->type) : create_rztype(type, RZ_TYPE_IDENTIFIER_KIND_UNION, name);
            } else if (base_type->attrs != RZ_TYPE_TYPECLASS_INVALID) {
                RZ_LOG_INFO("%s : Redefining type %s.\n", __FUNCTION__, name);
            }
        }
    }
 
    if (!base_type) {
        base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_UNION);
        if (!base_type) {
            return NULL;
        }
 
        RzType *typ = create_rztype(type, RZ_TYPE_IDENTIFIER_KIND_UNION, name);
        if (!typ) {
            rz_type_base_type_free(base_type);
            return NULL;
        }
        base_type->type = typ;
        base_type->name = strdup(typ->identifier.name);
        base_type->attrs = RZ_TYPE_TYPECLASS_INVALID;
        rz_type_db_save_base_type(typedb, base_type);
 
        if (rz_bin_pdb_type_is_fwdref(type)) {
            return rz_type_clone(base_type->type);
        }
    }
    rz_vector_clear(&base_type->union_data.members);
    RzList *members = rz_bin_pdb_get_type_members(stream, type);
    RzListIter *it;
    RzPdbTpiType *member_info;
    rz_list_foreach (members, it, member_info) {
        if (member_info->leaf_type == LF_INDEX) {
            type = rz_bin_pdb_get_type_by_index(stream, rz_bin_pdb_get_type_val(member_info));
            members = rz_bin_pdb_get_type_members(stream, type);
            it = rz_list_head(members);
            if (!it) {
                break;
            }
            member_info = rz_list_first(members);
        }
        RzTypeUnionMember *union_member = parse_union_member(typedb, stream, member_info);
        if (!union_member) {
            continue; // skip the failure
        }
        void *element = rz_vector_push(&base_type->union_data.members, union_member);
        if (!element) {
            rz_type_base_union_member_free(union_member, NULL);
            return NULL;
        }
        free(union_member);
    }
    base_type->size = rz_bin_pdb_get_type_val(type);
    if (base_type->attrs == RZ_TYPE_TYPECLASS_INVALID) {
        base_type->attrs = RZ_TYPE_TYPECLASS_NONE;
        rz_list_append(stream->print_type, base_type);
    }
    type->parsed = true;
    return base_type->type ? rz_type_clone(base_type->type) : NULL;
}

References rz_base_type_t::attrs, create_rztype(), free(), get_tpitype_basetype(), rz_type_t::identifier, rz_base_type_t::kind, tpi_types::leaf_type, LF_INDEX, rz_base_type_union_t::members, rz_base_type_t::name, NULL, parse_union_member(), RZ_BASE_TYPE_KIND_UNION, rz_bin_pdb_get_type_by_index(), rz_bin_pdb_get_type_members(), rz_bin_pdb_get_type_name(), rz_bin_pdb_get_type_val(), rz_bin_pdb_type_is_fwdref(), rz_list_append(), rz_list_first(), RZ_LOG_INFO, RZ_LOG_WARN, rz_return_val_if_fail, rz_type_base_type_free(), rz_type_base_type_kind_as_string(), rz_type_base_type_new(), rz_type_base_union_member_free(), rz_type_clone(), rz_type_db_delete_base_type(), rz_type_db_save_base_type(), RZ_TYPE_IDENTIFIER_KIND_UNION, RZ_TYPE_TYPECLASS_INVALID, RZ_TYPE_TYPECLASS_NONE, rz_vector_clear(), rz_vector_push(), rz_base_type_t::size, strdup(), type, rz_base_type_t::type, and rz_base_type_t::union_data.

Referenced by parse_regular_type(), and parse_types().

parse_union_member()

static RzTypeUnionMember * parse_union_member ( const RzTypeDB *  typedb, RzPdbTpiStream *  stream, RzPdbTpiType *  type_info  )

static

Parses union member.

Parameters

typedb	Types DB instance
stream	TPI Stream
type_info	Current RzPdbTpiType (member)

Returns

RzTypeUnionMember* parsed member, NULL if fail

Definition at line 527 of file type_pdb.c.

                                                                                                                      {
    rz_return_val_if_fail(type_info && stream && typedb, NULL);
    char *name = NULL;
    ut64 offset = 0;
    RzType *type = NULL;
    switch (type_info->leaf_type) {
    case LF_ONEMETHOD: {
        name = rz_bin_pdb_get_type_name(type_info);
        type = parse_type_onemethod(typedb, stream, type_info);
        break;
    }
    case LF_MEMBER: {
        offset = rz_bin_pdb_get_type_val(type_info);
        name = rz_bin_pdb_get_type_name(type_info);
        type = parse_type_member(typedb, stream, type_info, name);
        break;
    }
    case LF_NESTTYPE: {
        name = rz_bin_pdb_get_type_name(type_info);
        type = parse_type_nest(typedb, stream, type_info);
        break;
    }
    default:
        RZ_LOG_ERROR("%s : unsupported leaf type 0x%x\n", __FUNCTION__, type_info->leaf_type);
        goto cleanup;
    }
    if (!type) {
        RZ_LOG_INFO("%s : couldn't parse union member type!\n", __FUNCTION__);
        return NULL;
    }
 
    RzTypeUnionMember *member = RZ_NEW0(RzTypeUnionMember);
    if (!member) {
        goto cleanup;
    }
    member->name = strdup(name);
    member->type = type;
    member->offset = offset;
    return member;
cleanup:
    rz_type_free(type);
    return NULL;
}

References cleanup(), tpi_types::leaf_type, LF_MEMBER, LF_NESTTYPE, LF_ONEMETHOD, rz_type_union_member_t::name, NULL, rz_type_union_member_t::offset, parse_type_member(), parse_type_nest(), parse_type_onemethod(), rz_bin_pdb_get_type_name(), rz_bin_pdb_get_type_val(), RZ_LOG_ERROR, RZ_LOG_INFO, RZ_NEW0, rz_return_val_if_fail, rz_type_free(), strdup(), type, rz_type_union_member_t::type, and ut64().

Referenced by parse_union().

rz_parse_pdb_types()

RZ_API void rz_parse_pdb_types	(	const RzTypeDB *	typedb,
		const RzPdb *	pdb
	)

Saves PDB types from TPI stream into the type database.

Parameters

t	RzTypeDB instance
pdb	PDB instance

Definition at line 802 of file type_pdb.c.

                                                                         {
    rz_return_if_fail(typedb && pdb);
    RzPdbTpiStream *stream = pdb->s_tpi;
    if (!stream) { // no TPI stream found
        return;
    }
 
    stream->print_type = rz_list_new();
    if (!stream->print_type) {
        return;
    }
 
    RBIter it;
    RzPdbTpiType *type;
    rz_rbtree_foreach (stream->types, it, type, RzPdbTpiType, rb) {
        if (type && is_parsable_type(type->leaf_type)) {
            parse_types(typedb, stream, type);
        }
    }
}

References is_parsable_type(), parse_types(), tpi_stream_t::print_type, rz_list_new(), rz_rbtree_foreach, rz_return_if_fail, rz_pdb_t::s_tpi, and type.

Referenced by rz_core_pdb_load_info().