tpi.c File Reference

#include "pdb.h"

Go to the source code of this file.

Functions
static bool	is_simple_type (RzPdbTpiStream *stream, ut32 idx)
int	tpi_type_node_cmp (const void *incoming, const RBNode *in_tree, void *user)
RZ_API RZ_OWN char *	rz_bin_pdb_calling_convention_as_string (RZ_NONNULL RzPdbTpiCallingConvention idx)
	Parses calling convention type as string. More...
static TpiSimpleTypeMode	get_simple_type_mode (ut32 type)
static TpiSimpleTypeKind	get_simple_type_kind (ut32 type)
static void	parse_codeview_property (TpiCVProperty *p, ut16 value)
static void	parse_codeview_fld_attribute (TpiCVFldattr *f, ut16 value)
static void	parse_codeview_func_attribute (TpiCVFuncattr *f, ut8 value)
static void	parse_codeview_pointer_attribute (TpiCVPointerAttr *p, ut32 value)
static void	parse_codeview_modifier (TpiCVModifier *m, ut16 value)
RZ_IPI RzPdbTpiType *	parse_simple_type (RzPdbTpiStream *stream, ut32 idx)
	Parses simple type if the idx represents one. More...
static ut64	get_numeric_val (Tpi_Type_Numeric *numeric)
RZ_API bool	rz_bin_pdb_type_is_fwdref (RZ_NONNULL RzPdbTpiType *t)
	Return true if type is forward definition. More...
RZ_API RZ_BORROW RzList *	rz_bin_pdb_get_type_members (RZ_NONNULL RzPdbTpiStream *stream, RzPdbTpiType *t)
	Get the RzPdbTpiType member list. More...
RZ_API RZ_BORROW char *	rz_bin_pdb_get_type_name (RZ_NONNULL RzPdbTpiType *type)
	Get the name of the type. More...
RZ_API ut64	rz_bin_pdb_get_type_val (RZ_NONNULL RzPdbTpiType *type)
	Get the numeric value inside the type. More...
static void	free_snumeric (Tpi_Type_Numeric *numeric)
static void	free_tpi_type (void *type_info)
static void	free_tpi_rbtree (RBNode *node, void *user)
RZ_IPI void	free_tpi_stream (RzPdbTpiStream *stream)
static void	skip_padding (RzBuffer *buf, ut16 len, ut16 *read_len, bool has_length)
static bool	has_non_padding (RzBuffer *buf, ut16 len, ut16 *read_len)
static bool	parse_type_numeric (RzBuffer *buf, Tpi_Type_Numeric *numeric, ut16 *read_len)
static void	parse_type_string (RzBuffer *buf, Tpi_Type_String *str, ut16 len, ut16 *read_len)
static Tpi_LF_Enumerate *	parse_type_enumerate (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_Index *	parse_type_index (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_NestType *	parse_type_nesttype (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_VFuncTab *	parse_type_vfunctab (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_Method *	parse_type_method (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_Member *	parse_type_member (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_StaticMember *	parse_type_staticmember (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_OneMethod *	parse_type_onemethod (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_BClass *	parse_type_bclass (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_VBClass *	parse_type_vbclass (RzBuffer *buf, ut16 len, ut16 *read_len)
static Tpi_LF_FieldList *	parse_type_fieldlist (RzBuffer *buf, ut16 len)
static Tpi_LF_Enum *	parse_type_enum (RzBuffer *buf, ut16 len)
static Tpi_LF_Structure *	parse_type_struct (RzBuffer *buf, ut16 len)
static Tpi_LF_Structure_19 *	parse_type_struct_19 (RzBuffer *buf, ut16 len)
static Tpi_LF_Pointer *	parse_type_pointer (RzBuffer *buf, ut16 len)
static Tpi_LF_Array *	parse_type_array (RzBuffer *buf, ut16 len)
static Tpi_LF_Modifier *	parse_type_modifier (RzBuffer *buf, ut16 len)
static Tpi_LF_Arglist *	parse_type_arglist (RzBuffer *buf, ut16 len)
static Tpi_LF_MFcuntion *	parse_type_mfunction (RzBuffer *buf, ut16 len)
static Tpi_LF_MethodList *	parse_type_methodlist (RzBuffer *buf, ut16 len)
static Tpi_LF_Procedure *	parse_type_procedure (RzBuffer *buf, ut16 len)
static Tpi_LF_Union *	parse_type_union (RzBuffer *buf, ut16 len)
static Tpi_LF_Bitfield *	parse_type_bitfield (RzBuffer *buf, ut16 len)
static Tpi_LF_Vtshape *	parse_type_vtshape (RzBuffer *buf, ut16 len)
static bool	parse_tpi_types (RzBuffer *buf, RzPdbTpiType *type)
static bool	parse_tpi_stream_header (RzPdbTpiStream *s, RzBuffer *buf)
RZ_IPI bool	parse_tpi_stream (RzPdb *pdb, RzPdbMsfStream *stream)
RZ_API RZ_BORROW RzPdbTpiType *	rz_bin_pdb_get_type_by_index (RZ_NONNULL RzPdbTpiStream *stream, ut32 index)
	Get RzPdbTpiType that matches tpi stream index. More...

Function Documentation

free_snumeric()

static void free_snumeric ( Tpi_Type_Numeric *  numeric )

static

Definition at line 549 of file tpi.c.

                                                     {
    switch (numeric->type_index) {
    case LF_CHAR:
    case LF_SHORT:
    case LF_USHORT:
    case LF_LONG:
    case LF_ULONG:
    case LF_QUADWORD:
    case LF_UQUADWORD:
        RZ_FREE(numeric->data);
        break;
    default:
        if (numeric->type_index >= 0x8000) {
            eprintf("%s::not supproted type\n", __FUNCTION__);
            break;
        }
        RZ_FREE(numeric->data);
    }
}

References Tpi_Type_Numeric::data, eprintf, LF_CHAR, LF_LONG, LF_QUADWORD, LF_SHORT, LF_ULONG, LF_UQUADWORD, LF_USHORT, RZ_FREE, and Tpi_Type_Numeric::type_index.

Referenced by free_tpi_type(), parse_type_array(), parse_type_bclass(), parse_type_enumerate(), parse_type_member(), parse_type_struct(), parse_type_struct_19(), parse_type_union(), and parse_type_vbclass().

free_tpi_rbtree()

static void free_tpi_rbtree ( RBNode *  node, void *  user  )

static

Definition at line 699 of file tpi.c.

                                                      {
    rz_return_if_fail(node);
    RzPdbTpiType *type = container_of(node, RzPdbTpiType, rb);
    free_tpi_type(type);
}

References container_of, free_tpi_type(), rz_return_if_fail, and type.

Referenced by free_tpi_stream().

free_tpi_stream()

RZ_IPI void free_tpi_stream

(

RzPdbTpiStream *

stream

)

Definition at line 705 of file tpi.c.

                                                    {
    if (!stream) {
        return;
    }
    rz_rbtree_free(stream->types, free_tpi_rbtree, NULL);
    rz_list_free(stream->print_type);
    free(stream);
}

References free(), free_tpi_rbtree(), NULL, rz_list_free(), and rz_rbtree_free().

Referenced by rz_bin_pdb_free().

free_tpi_type()

static void free_tpi_type ( void *  type_info )

static

Definition at line 569 of file tpi.c.

                                           {
    rz_return_if_fail(type_info);
    RzPdbTpiType *type = (RzPdbTpiType *)type_info;
    switch (type->leaf_type) {
    case LF_ENUMERATE: {
        Tpi_LF_Enumerate *lf_en = (Tpi_LF_Enumerate *)type->type_data;
        free_snumeric(&(lf_en->enum_value));
        RZ_FREE(lf_en->name.name);
        break;
    }
    case LF_NESTTYPE: {
        Tpi_LF_NestType *lf_nest = (Tpi_LF_NestType *)type->type_data;
        RZ_FREE(lf_nest->name.name);
        break;
    }
    case LF_METHOD: {
        Tpi_LF_Method *lf_meth = (Tpi_LF_Method *)type->type_data;
        RZ_FREE(lf_meth->name.name);
        break;
    }
    case LF_MEMBER: {
        Tpi_LF_Member *lf_mem = (Tpi_LF_Member *)type->type_data;
        free_snumeric(&lf_mem->offset);
        RZ_FREE(lf_mem->name.name);
        break;
    }
    case LF_STMEMBER: {
        Tpi_LF_StaticMember *lf_stmem = (Tpi_LF_StaticMember *)type->type_data;
        RZ_FREE(lf_stmem->name.name);
        break;
    }
    case LF_FIELDLIST: {
        Tpi_LF_FieldList *lf_fieldlist = (Tpi_LF_FieldList *)type->type_data;
        rz_list_free(lf_fieldlist->substructs);
        break;
    }
    case LF_CLASS:
    case LF_STRUCTURE: {
        Tpi_LF_Structure *lf_class = (Tpi_LF_Structure *)type->type_data;
        free_snumeric(&lf_class->size);
        RZ_FREE(lf_class->name.name);
        RZ_FREE(lf_class->mangled_name.name);
        break;
    }
    case LF_CLASS_19:
    case LF_STRUCTURE_19: {
        Tpi_LF_Structure_19 *lf_class_19 = (Tpi_LF_Structure_19 *)type->type_data;
        free_snumeric(&lf_class_19->size);
        RZ_FREE(lf_class_19->name.name);
        RZ_FREE(lf_class_19->mangled_name.name);
        break;
    }
    case LF_UNION: {
        Tpi_LF_Union *lf_union = (Tpi_LF_Union *)type->type_data;
        free_snumeric(&lf_union->size);
        RZ_FREE(lf_union->name.name);
        RZ_FREE(lf_union->mangled_name.name);
        break;
    }
    case LF_ONEMETHOD: {
        Tpi_LF_OneMethod *lf_onemethod = (Tpi_LF_OneMethod *)type->type_data;
        RZ_FREE(lf_onemethod->name.name);
        break;
    }
    case LF_BCLASS: {
        Tpi_LF_BClass *lf_bclass = (Tpi_LF_BClass *)type->type_data;
        free_snumeric(&lf_bclass->offset);
        break;
    }
    case LF_VBCLASS:
    case LF_IVBCLASS: {
        Tpi_LF_VBClass *lf_vbclass = (Tpi_LF_VBClass *)type->type_data;
        free_snumeric(&lf_vbclass->vb_pointer_offset);
        free_snumeric(&lf_vbclass->vb_offset_from_vbtable);
        break;
    }
    case LF_ENUM: {
        Tpi_LF_Enum *lf_enum = (Tpi_LF_Enum *)type->type_data;
        RZ_FREE(lf_enum->name.name);
        RZ_FREE(lf_enum->mangled_name.name);
        break;
    }
    case LF_ARRAY: {
        Tpi_LF_Array *lf_array = (Tpi_LF_Array *)type->type_data;
        free_snumeric(&lf_array->size);
        RZ_FREE(lf_array->name.name);
        break;
    }
    case LF_ARGLIST: {
        Tpi_LF_Arglist *lf_arglist = (Tpi_LF_Arglist *)type->type_data;
        RZ_FREE(lf_arglist->arg_type);
        break;
    }
    case LF_VTSHAPE: {
        Tpi_LF_Vtshape *lf_vtshape = (Tpi_LF_Vtshape *)type->type_data;
        RZ_FREE(lf_vtshape->vt_descriptors);
        break;
    }
    case LF_SIMPLE_TYPE: {
        Tpi_LF_SimpleType *lf_simple = (Tpi_LF_SimpleType *)type->type_data;
        RZ_FREE(lf_simple->type);
        break;
    }
    case LF_METHODLIST: {
        Tpi_LF_MethodList *lf_mlist = (Tpi_LF_MethodList *)type->type_data;
        rz_list_free(lf_mlist->members);
        break;
    }
    case LF_POINTER:
        break;
    case LF_PROCEDURE:
        break;
    case LF_MODIFIER:
        break;
    case LF_MFUNCTION:
        break;
    case LF_BITFIELD:
        break;
    case LF_INDEX:
        break;
    case LF_VFUNCTAB:
        break;
    default:
        rz_warn_if_reached();
        break;
    }
    free(type->type_data);
    free(type);
}

References Tpi_LF_Arglist::arg_type, Tpi_LF_Enumerate::enum_value, free(), free_snumeric(), LF_ARGLIST, LF_ARRAY, LF_BCLASS, LF_BITFIELD, LF_CLASS, LF_CLASS_19, LF_ENUM, LF_ENUMERATE, LF_FIELDLIST, LF_INDEX, LF_IVBCLASS, LF_MEMBER, LF_METHOD, LF_METHODLIST, LF_MFUNCTION, LF_MODIFIER, LF_NESTTYPE, LF_ONEMETHOD, LF_POINTER, LF_PROCEDURE, LF_SIMPLE_TYPE, LF_STMEMBER, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, LF_VBCLASS, LF_VFUNCTAB, LF_VTSHAPE, Tpi_LF_Structure::mangled_name, Tpi_LF_Structure_19::mangled_name, Tpi_LF_Union::mangled_name, Tpi_LF_Enum::mangled_name, Tpi_LF_MethodList::members, Tpi_Type_String::name, Tpi_LF_Array::name, Tpi_LF_Structure::name, Tpi_LF_Structure_19::name, Tpi_LF_Union::name, Tpi_LF_Enum::name, Tpi_LF_Enumerate::name, Tpi_LF_NestType::name, Tpi_LF_Method::name, Tpi_LF_Member::name, Tpi_LF_StaticMember::name, Tpi_LF_OneMethod::name, Tpi_LF_Member::offset, Tpi_LF_BClass::offset, RZ_FREE, rz_list_free(), rz_return_if_fail, rz_warn_if_reached, Tpi_LF_Array::size, Tpi_LF_Structure::size, Tpi_LF_Structure_19::size, Tpi_LF_Union::size, Tpi_LF_FieldList::substructs, type, Tpi_LF_SimpleType::type, Tpi_LF_VBClass::vb_offset_from_vbtable, Tpi_LF_VBClass::vb_pointer_offset, and Tpi_LF_Vtshape::vt_descriptors.

Referenced by free_tpi_rbtree(), and parse_type_fieldlist().

get_numeric_val()

static ut64 get_numeric_val ( Tpi_Type_Numeric *  numeric )

static

Definition at line 343 of file tpi.c.

                                                       {
    switch (numeric->type_index) {
    case LF_CHAR:
        return *(st8 *)(numeric->data);
    case LF_SHORT:
        return *(st16 *)(numeric->data);
    case LF_USHORT:
        return *(ut16 *)(numeric->data);
    case LF_LONG:
        return *(st32 *)(numeric->data);
    case LF_ULONG:
        return *(ut32 *)(numeric->data);
    case LF_QUADWORD:
        return *(st64 *)(numeric->data);
    case LF_UQUADWORD:
        return *(ut64 *)(numeric->data);
    default:
        if (numeric->type_index >= 0x8000) {
            return 0;
        }
        return *(ut16 *)(numeric->data);
    }
}

References Tpi_Type_Numeric::data, LF_CHAR, LF_LONG, LF_QUADWORD, LF_SHORT, LF_ULONG, LF_UQUADWORD, LF_USHORT, st16, st32, st64, st8, Tpi_Type_Numeric::type_index, and ut64().

Referenced by rz_bin_pdb_get_type_val().

get_simple_type_kind()

static TpiSimpleTypeKind get_simple_type_kind ( ut32  type )

static

Definition at line 72 of file tpi.c.

                                                         {
    /*   https://llvm.org/docs/PDB/RzPdbTpiStream.html#type-indices
  .---------------------------.------.----------.
  |           Unused          | Mode |   Kind   |
  '---------------------------'------'----------'
  |+32                        |+12   |+8        |+0
  */
    return (type & 0x00000000000FF);
}

References type.

Referenced by parse_simple_type().

get_simple_type_mode()

static TpiSimpleTypeMode get_simple_type_mode ( ut32  type )

static

Definition at line 61 of file tpi.c.

                                                         {
    /*   https://llvm.org/docs/PDB/RzPdbTpiStream.html#type-indices
  .---------------------------.------.----------.
  |           Unused          | Mode |   Kind   |
  '---------------------------'------'----------'
  |+32                        |+12   |+8        |+0
  */
    // because mode is only number between 0-7, 1 byte is enough
    return (type & 0x0000000000F00) >> 8;
}

References type.

Referenced by parse_simple_type().

has_non_padding()

static bool has_non_padding ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 731 of file tpi.c.

                                                                     {
    while (*read_len < len) {
        ut8 byt;
        if (!rz_buf_read8(buf, &byt)) {
            break;
        }
        rz_buf_seek(buf, -1, RZ_BUF_CUR);
        if ((byt & 0xf0) != 0xf0) {
            return true;
        }
        return false;
    }
    return false;
}

References len, RZ_BUF_CUR, rz_buf_read8(), and rz_buf_seek().

Referenced by parse_type_enum(), parse_type_struct(), parse_type_struct_19(), and parse_type_union().

is_simple_type()

static bool is_simple_type ( RzPdbTpiStream *  stream, ut32  idx  )

static

Definition at line 7 of file tpi.c.

                                                             {
    /*   https://llvm.org/docs/PDB/RzPdbTpiStream.html#type-indices
  .---------------------------.------.----------.
  |           Unused          | Mode |   Kind   |
  '---------------------------'------'----------'
  |+32                        |+12   |+8        |+0
  */
    return idx < stream->header.TypeIndexBegin;
    // return ((value & 0x00000000FFF00) <= 0x700 && (value & 0x00000000000FF) <
    // 0x80);
}

References setup::idx.

Referenced by rz_bin_pdb_get_type_by_index().

parse_codeview_fld_attribute()

static void parse_codeview_fld_attribute ( TpiCVFldattr *  f, ut16  value  )

static

Definition at line 99 of file tpi.c.

                                                                      {
    f->bits.access = GET_BF(value, 0, 2);
    f->bits.mprop = GET_BF(value, 2, 3);
    f->bits.pseudo = GET_BF(value, 5, 1);
    f->bits.noinherit = GET_BF(value, 6, 1);
    f->bits.noconstruct = GET_BF(value, 7, 1);
    f->bits.compgenx = GET_BF(value, 8, 1);
    f->bits.sealed = GET_BF(value, 9, 1);
}

References f, GET_BF, and value.

Referenced by parse_type_bclass(), parse_type_enumerate(), parse_type_index(), parse_type_member(), parse_type_methodlist(), parse_type_onemethod(), parse_type_staticmember(), and parse_type_vbclass().

parse_codeview_func_attribute()

static void parse_codeview_func_attribute ( TpiCVFuncattr *  f, ut8  value  )

static

Definition at line 109 of file tpi.c.

                                                                       {
    f->bits.cxxreturnudt = GET_BF(value, 0, 1);
    f->bits.ctor = GET_BF(value, 1, 1);
    f->bits.ctorvbase = GET_BF(value, 2, 1);
}

References f, GET_BF, and value.

Referenced by parse_type_mfunction(), and parse_type_procedure().

parse_codeview_modifier()

static void parse_codeview_modifier ( TpiCVModifier *  m, ut16  value  )

static

Definition at line 130 of file tpi.c.

                                                                  {
    m->bits.const_ = GET_BF(value, 0, 1);
    m->bits.volatile_ = GET_BF(value, 1, 1);
    m->bits.unaligned = GET_BF(value, 2, 1);
}

References GET_BF, regress::m, and value.

Referenced by parse_type_modifier().

parse_codeview_pointer_attribute()

static void parse_codeview_pointer_attribute ( TpiCVPointerAttr *  p, ut32  value  )

static

Definition at line 115 of file tpi.c.

                                                                              {
    p->bits.ptrtype = GET_BF(value, 0, 5);
    p->bits.ptrmode = GET_BF(value, 5, 3);
    p->bits.flat32 = GET_BF(value, 8, 1);
    p->bits.volatile_ = GET_BF(value, 9, 1);
    p->bits.const_ = GET_BF(value, 10, 1);
    p->bits.unaligned = GET_BF(value, 11, 1);
    p->bits.restrict_ = GET_BF(value, 12, 1);
    p->bits.size = GET_BF(value, 13, 6);
    p->bits.mocom = GET_BF(value, 19, 1);
    p->bits.lref = GET_BF(value, 20, 1);
    p->bits.rref = GET_BF(value, 21, 1);
    p->bits.unused = GET_BF(value, 22, 10);
}

References GET_BF, p, and value.

Referenced by parse_type_pointer().

parse_codeview_property()

static void parse_codeview_property ( TpiCVProperty *  p, ut16  value  )

static

Definition at line 82 of file tpi.c.

                                                                  {
    p->bits.packed = GET_BF(value, 0, 1);
    p->bits.ctor = GET_BF(value, 1, 1);
    p->bits.ovlops = GET_BF(value, 2, 1);
    p->bits.isnested = GET_BF(value, 3, 1);
    p->bits.packed = GET_BF(value, 4, 1);
    p->bits.opassign = GET_BF(value, 5, 1);
    p->bits.opcast = GET_BF(value, 6, 1);
    p->bits.fwdref = GET_BF(value, 7, 1);
    p->bits.scoped = GET_BF(value, 8, 1);
    p->bits.hasuniquename = GET_BF(value, 9, 1);
    p->bits.sealed = GET_BF(value, 10, 1);
    p->bits.hfa = GET_BF(value, 11, 2);
    p->bits.intrinsic = GET_BF(value, 13, 1);
    p->bits.mocom = GET_BF(value, 14, 2);
}

References GET_BF, p, and value.

Referenced by parse_type_enum(), parse_type_struct(), parse_type_struct_19(), and parse_type_union().

parse_simple_type()

RZ_IPI RzPdbTpiType* parse_simple_type	(	RzPdbTpiStream *	stream,
		ut32	idx
	)

Parses simple type if the idx represents one.

Parameters

RzPdbTpiStream	TPI stream context
idx	leaf index

Returns

RzPdbTpiType, leaf_type = 0 -> error

Definition at line 142 of file tpi.c.

                                                                         {
    RzPdbTpiType *type = RZ_NEW0(RzPdbTpiType);
    if (!type) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return NULL;
    }
    type->leaf_type = LF_SIMPLE_TYPE;
    type->type_index = idx;
    // For simple type we don't set length
    type->length = 0;
    Tpi_LF_SimpleType *simple_type = RZ_NEW0(Tpi_LF_SimpleType);
    if (!simple_type) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        free(type);
        return NULL;
    }
    type->type_data = simple_type;
    RzStrBuf *buf;
    TpiSimpleTypeKind kind = get_simple_type_kind(idx);
    switch (kind) {
    case PDB_NONE:
        simple_type->size = 0;
        buf = rz_strbuf_new("notype_t");
        break;
    case PDB_VOID:
        simple_type->size = 0;
        buf = rz_strbuf_new("void");
        break;
    case PDB_SIGNED_CHAR:
    case PDB_NARROW_CHAR:
        simple_type->size = 1;
        buf = rz_strbuf_new("char");
        break;
    case PDB_UNSIGNED_CHAR:
        simple_type->size = 1;
        buf = rz_strbuf_new("unsigned char");
        break;
    case PDB_WIDE_CHAR:
        simple_type->size = 4;
        buf = rz_strbuf_new("wchar_t");
        break;
    case PDB_CHAR16:
        simple_type->size = 2;
        buf = rz_strbuf_new("char16_t");
        break;
    case PDB_CHAR32:
        simple_type->size = 4;
        buf = rz_strbuf_new("char32_t");
        break;
    case PDB_BYTE:
        simple_type->size = 1;
        buf = rz_strbuf_new("uint8_t");
        break;
    case PDB_SBYTE:
        simple_type->size = 1;
        buf = rz_strbuf_new("int8_t");
        break;
    case PDB_INT16:
    case PDB_INT16_SHORT:
        simple_type->size = 2;
        buf = rz_strbuf_new("int16_t");
        break;
    case PDB_UINT16:
    case PDB_UINT16_SHORT:
        simple_type->size = 2;
        buf = rz_strbuf_new("uint16_t");
        break;
    case PDB_INT32:
    case PDB_INT32_LONG:
        simple_type->size = 4;
        buf = rz_strbuf_new("int32_t");
        break;
    case PDB_UINT32:
    case PDB_UINT32_LONG:
        simple_type->size = 4;
        buf = rz_strbuf_new("uint32_t");
        break;
    case PDB_INT64:
    case PDB_INT64_QUAD:
        simple_type->size = 8;
        buf = rz_strbuf_new("int64_t");
        break;
    case PDB_UINT64:
    case PDB_UINT64_QUAD:
        simple_type->size = 8;
        buf = rz_strbuf_new("uint64_t");
        break;
    case PDB_INT128:
    case PDB_INT128_OCT:
        simple_type->size = 16;
        buf = rz_strbuf_new("int128_t");
        break;
    case PDB_UINT128:
    case PDB_UINT128_OCT:
        simple_type->size = 16;
        buf = rz_strbuf_new("uint128_t");
        break;
    case PDB_FLOAT16:
        simple_type->size = 2;
        buf = rz_strbuf_new("float");
        break;
    case PDB_FLOAT32:
    case PDB_FLOAT32_PP:
        simple_type->size = 4;
        buf = rz_strbuf_new("float");
        break;
    case PDB_FLOAT48:
        simple_type->size = 6;
        buf = rz_strbuf_new("float");
        break;
    case PDB_FLOAT64:
        simple_type->size = 8;
        buf = rz_strbuf_new("double");
        break;
    case PDB_FLOAT80:
        simple_type->size = 10;
        buf = rz_strbuf_new("long double");
        break;
    case PDB_FLOAT128:
        simple_type->size = 16;
        buf = rz_strbuf_new("long double");
        break;
    case PDB_COMPLEX16:
        simple_type->size = 2;
        buf = rz_strbuf_new("float _Complex");
        break;
    case PDB_COMPLEX32:
    case PDB_COMPLEX32_PP:
        simple_type->size = 4;
        buf = rz_strbuf_new("float _Complex");
        break;
    case PDB_COMPLEX48:
        simple_type->size = 6;
        buf = rz_strbuf_new("float _Complex");
        break;
    case PDB_COMPLEX64:
        simple_type->size = 8;
        buf = rz_strbuf_new("double _Complex");
        break;
    case PDB_COMPLEX80:
        simple_type->size = 10;
        buf = rz_strbuf_new("long double _Complex");
        break;
    case PDB_COMPLEX128:
        simple_type->size = 16;
        buf = rz_strbuf_new("long double _Complex");
        break;
    case PDB_BOOL8:
        simple_type->size = 1;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL16:
        simple_type->size = 2;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL32:
        simple_type->size = 4;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL64:
        simple_type->size = 8;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL128:
        simple_type->size = 16;
        buf = rz_strbuf_new("bool");
        break;
    default:
        simple_type->size = 0;
        buf = rz_strbuf_new("unknown_t");
        break;
    }
    TpiSimpleTypeMode mode = get_simple_type_mode(idx);
    if (mode) {
        rz_strbuf_append(buf, " *");
    }
    switch (mode) {
    case NEAR_POINTER:
        simple_type->size = 2;
        break;
    case FAR_POINTER:
    case HUGE_POINTER:
    case NEAR_POINTER32:
    case FAR_POINTER32:
        simple_type->size = 4;
        break;
    case NEAR_POINTER64:
        simple_type->size = 8;
        break;
    case NEAR_POINTER128:
        simple_type->size = 16;
        break;
    default:
        break;
    }
    simple_type->type = rz_strbuf_drain(buf);
    // We just insert once
    rz_rbtree_insert(&stream->types, &type->type_index, &type->rb, tpi_type_node_cmp, NULL);
    return type;
}

References FAR_POINTER, FAR_POINTER32, free(), get_simple_type_kind(), get_simple_type_mode(), HUGE_POINTER, setup::idx, LF_SIMPLE_TYPE, NEAR_POINTER, NEAR_POINTER128, NEAR_POINTER32, NEAR_POINTER64, NULL, PDB_BOOL128, PDB_BOOL16, PDB_BOOL32, PDB_BOOL64, PDB_BOOL8, PDB_BYTE, PDB_CHAR16, PDB_CHAR32, PDB_COMPLEX128, PDB_COMPLEX16, PDB_COMPLEX32, PDB_COMPLEX32_PP, PDB_COMPLEX48, PDB_COMPLEX64, PDB_COMPLEX80, PDB_FLOAT128, PDB_FLOAT16, PDB_FLOAT32, PDB_FLOAT32_PP, PDB_FLOAT48, PDB_FLOAT64, PDB_FLOAT80, PDB_INT128, PDB_INT128_OCT, PDB_INT16, PDB_INT16_SHORT, PDB_INT32, PDB_INT32_LONG, PDB_INT64, PDB_INT64_QUAD, PDB_NARROW_CHAR, PDB_NONE, PDB_SBYTE, PDB_SIGNED_CHAR, PDB_UINT128, PDB_UINT128_OCT, PDB_UINT16, PDB_UINT16_SHORT, PDB_UINT32, PDB_UINT32_LONG, PDB_UINT64, PDB_UINT64_QUAD, PDB_UNSIGNED_CHAR, PDB_VOID, PDB_WIDE_CHAR, RZ_LOG_ERROR, RZ_NEW0, rz_rbtree_insert(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), Tpi_LF_SimpleType::size, tpi_type_node_cmp(), type, and Tpi_LF_SimpleType::type.

Referenced by rz_bin_pdb_get_type_by_index().

parse_tpi_stream()

RZ_IPI bool parse_tpi_stream	(	RzPdb *	pdb,
		RzPdbMsfStream *	stream
	)

Definition at line 1799 of file tpi.c.

                                                                 {
    if (!pdb || !stream) {
        return false;
    }
    if (stream->stream_idx != PDB_STREAM_TPI) {
        RZ_LOG_ERROR("Error TPI stream index.\n");
        return false;
    }
    pdb->s_tpi = RZ_NEW0(RzPdbTpiStream);
    RzPdbTpiStream *s = pdb->s_tpi;
    if (!s) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return false;
    }
    s->types = NULL;
    RzBuffer *buf = stream->stream_data;
    if (!parse_tpi_stream_header(s, buf)) {
        return false;
    }
    if (s->header.HeaderSize != sizeof(RzPdbTpiStreamHeader)) {
        RZ_LOG_ERROR("Corrupted TPI stream.\n");
        return false;
    }
    RzPdbTpiType *type;
    for (ut32 i = s->header.TypeIndexBegin; i < s->header.TypeIndexEnd; i++) {
        type = RZ_NEW0(RzPdbTpiType);
        if (!type) {
            continue;
        }
        type->type_index = i;
        if (!parse_tpi_types(buf, type) || !type->type_data) {
            RZ_LOG_ERROR("Parse TPI type error. idx in stream: 0x%" PFMT32x "\n", i);
            RZ_FREE(type);
            return false;
        }
        rz_rbtree_insert(&s->types, &type->type_index, &type->rb, tpi_type_node_cmp, NULL);
    }
    return true;
}

References header, i, NULL, parse_tpi_stream_header(), parse_tpi_types(), PDB_STREAM_TPI, PFMT32x, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_rbtree_insert(), s, rz_pdb_t::s_tpi, tpi_type_node_cmp(), and type.

Referenced by parse_streams().

parse_tpi_stream_header()

static bool parse_tpi_stream_header ( RzPdbTpiStream *  s, RzBuffer *  buf  )

static

Definition at line 1777 of file tpi.c.

                                                                      {
    return rz_buf_read_le32(buf, &s->header.Version) &&
        rz_buf_read_le32(buf, &s->header.HeaderSize) &&
        rz_buf_read_le32(buf, &s->header.TypeIndexBegin) &&
        rz_buf_read_le32(buf, &s->header.TypeIndexEnd) &&
        rz_buf_read_le32(buf, &s->header.TypeRecordBytes) &&
 
        rz_buf_read_le16(buf, &s->header.HashStreamIndex) &&
        rz_buf_read_le16(buf, &s->header.HashAuxStreamIndex) &&
        rz_buf_read_le32(buf, &s->header.HashKeySize) &&
        rz_buf_read_le32(buf, &s->header.NumHashBuckets) &&
 
        rz_buf_read_le32(buf, (ut32 *)&s->header.HashValueBufferOffset) &&
        rz_buf_read_le32(buf, &s->header.HashValueBufferLength) &&
 
        rz_buf_read_le32(buf, (ut32 *)&s->header.IndexOffsetBufferOffset) &&
        rz_buf_read_le32(buf, &s->header.IndexOffsetBufferLength) &&
 
        rz_buf_read_le32(buf, (ut32 *)&s->header.HashAdjBufferOffset) &&
        rz_buf_read_le32(buf, &s->header.HashAdjBufferLength);
}

References rz_buf_read_le16, rz_buf_read_le32, and s.

Referenced by parse_tpi_stream().

parse_tpi_types()

static bool parse_tpi_types ( RzBuffer *  buf, RzPdbTpiType *  type  )

static

Definition at line 1715 of file tpi.c.

                                                               {
    if (!buf || !type) {
        return false;
    }
    if (!rz_buf_read_le16(buf, &type->length)) {
        return false;
    }
    if (!rz_buf_read_le16(buf, &type->leaf_type)) {
        return false;
    }
    switch (type->leaf_type) {
    case LF_FIELDLIST:
        type->type_data = parse_type_fieldlist(buf, type->length);
        break;
    case LF_ENUM:
        type->type_data = parse_type_enum(buf, type->length);
        break;
    case LF_CLASS:
    case LF_STRUCTURE:
        type->type_data = parse_type_struct(buf, type->length);
        break;
    case LF_CLASS_19:
    case LF_STRUCTURE_19:
        type->type_data = parse_type_struct_19(buf, type->length);
        break;
    case LF_POINTER:
        type->type_data = parse_type_pointer(buf, type->length);
        break;
    case LF_ARRAY:
        type->type_data = parse_type_array(buf, type->length);
        break;
    case LF_MODIFIER:
        type->type_data = parse_type_modifier(buf, type->length);
        break;
    case LF_ARGLIST:
        type->type_data = parse_type_arglist(buf, type->length);
        break;
    case LF_MFUNCTION:
        type->type_data = parse_type_mfunction(buf, type->length);
        break;
    case LF_METHODLIST:
        type->type_data = parse_type_methodlist(buf, type->length);
        break;
    case LF_PROCEDURE:
        type->type_data = parse_type_procedure(buf, type->length);
        break;
    case LF_UNION:
        type->type_data = parse_type_union(buf, type->length);
        break;
    case LF_BITFIELD:
        type->type_data = parse_type_bitfield(buf, type->length);
        break;
    case LF_VTSHAPE:
        type->type_data = parse_type_vtshape(buf, type->length);
        break;
    default:
        RZ_LOG_ERROR("%s: unsupported leaf type: 0x%" PFMT32x "\n", __FUNCTION__, type->leaf_type);
        return false;
    }
    return true;
}

References LF_ARGLIST, LF_ARRAY, LF_BITFIELD, LF_CLASS, LF_CLASS_19, LF_ENUM, LF_FIELDLIST, LF_METHODLIST, LF_MFUNCTION, LF_MODIFIER, LF_POINTER, LF_PROCEDURE, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, LF_VTSHAPE, parse_type_arglist(), parse_type_array(), parse_type_bitfield(), parse_type_enum(), parse_type_fieldlist(), parse_type_methodlist(), parse_type_mfunction(), parse_type_modifier(), parse_type_pointer(), parse_type_procedure(), parse_type_struct(), parse_type_struct_19(), parse_type_union(), parse_type_vtshape(), PFMT32x, rz_buf_read_le16, RZ_LOG_ERROR, and type.

Referenced by parse_tpi_stream().

parse_type_arglist()

static Tpi_LF_Arglist* parse_type_arglist ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1439 of file tpi.c.

                                                                   {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Arglist *arglist = RZ_NEW0(Tpi_LF_Arglist);
    if (!arglist) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le32(buf, &arglist->count)) {
        RZ_FREE(arglist);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    arglist->arg_type = (ut32 *)malloc(sizeof(ut32) * arglist->count);
    if (!arglist->arg_type) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        RZ_FREE(arglist);
        return NULL;
    }
    for (size_t i = 0; i < arglist->count; i++) {
        if (!rz_buf_read_le32(buf, &arglist->arg_type[i])) {
            RZ_FREE(arglist->arg_type);
            RZ_FREE(arglist);
            return NULL;
        }
        read_bytes += sizeof(ut32);
    }
    skip_padding(buf, len, &read_bytes, true);
 
    return arglist;
}

References Tpi_LF_Arglist::arg_type, Tpi_LF_Arglist::count, i, len, malloc(), NULL, rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_tpi_types().

parse_type_array()

static Tpi_LF_Array* parse_type_array ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1384 of file tpi.c.

                                                               {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Array *array = RZ_NEW0(Tpi_LF_Array);
    if (!array) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le32(buf, &array->element_type)) {
        RZ_FREE(array);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &array->index_type)) {
        RZ_FREE(array);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!parse_type_numeric(buf, &array->size, &read_bytes)) {
        RZ_FREE(array);
        return NULL;
    }
    if (!array->size.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&array->size);
        RZ_FREE(array);
        return NULL;
    }
    parse_type_string(buf, &array->name, len, &read_bytes);
    skip_padding(buf, len, &read_bytes, true);
    return array;
}

References Tpi_LF_Array::element_type, free_snumeric(), Tpi_LF_Array::index_type, Tpi_Type_Numeric::is_integer, len, Tpi_LF_Array::name, NULL, parse_type_numeric(), parse_type_string(), rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, Tpi_LF_Array::size, and skip_padding().

Referenced by parse_tpi_types().

parse_type_bclass()

static Tpi_LF_BClass* parse_type_bclass ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 1046 of file tpi.c.

                                                                                 {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_BClass *bclass = RZ_NEW0(Tpi_LF_BClass);
    if (!bclass) {
        return NULL;
    }
    ut16 fldattr;
    if (!rz_buf_read_le16(buf, &fldattr)) {
        RZ_FREE(bclass);
        return NULL;
    }
    parse_codeview_fld_attribute(&bclass->fldattr, fldattr);
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &bclass->index)) {
        RZ_FREE(bclass);
        return NULL;
    }
    *read_len += sizeof(ut32);
    if (!parse_type_numeric(buf, &bclass->offset, read_len)) {
        RZ_FREE(bclass);
        return NULL;
    }
    if (!bclass->offset.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&bclass->offset);
        RZ_FREE(bclass);
        return NULL;
    }
    skip_padding(buf, len, read_len, false);
    return bclass;
}

References Tpi_LF_BClass::fldattr, free_snumeric(), Tpi_LF_BClass::index, Tpi_Type_Numeric::is_integer, len, NULL, Tpi_LF_BClass::offset, parse_codeview_fld_attribute(), parse_type_numeric(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_bitfield()

static Tpi_LF_Bitfield* parse_type_bitfield ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1664 of file tpi.c.

                                                                     {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Bitfield *bf = RZ_NEW0(Tpi_LF_Bitfield);
    if (!bf) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le32(buf, &bf->base_type)) {
        RZ_FREE(bf);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read8(buf, &bf->length)) {
        RZ_FREE(bf);
        return NULL;
    }
    read_bytes += sizeof(ut8);
    if (!rz_buf_read8(buf, &bf->position)) {
        RZ_FREE(bf);
        return NULL;
    }
    read_bytes += sizeof(ut8);
    skip_padding(buf, len, &read_bytes, true);
    return bf;
}

References Tpi_LF_Bitfield::base_type, len, Tpi_LF_Bitfield::length, NULL, Tpi_LF_Bitfield::position, rz_buf_read8(), rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, skip_padding(), and ut8.

Referenced by parse_tpi_types().

parse_type_enum()

static Tpi_LF_Enum* parse_type_enum ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1197 of file tpi.c.

                                                             {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Enum *_enum = RZ_NEW0(Tpi_LF_Enum);
    if (!_enum) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16); // include leaf_type
    if (!rz_buf_read_le16(buf, &_enum->count)) {
        RZ_FREE(_enum);
        return NULL;
    }
    read_bytes += sizeof(ut16);
    ut16 prop;
    if (!rz_buf_read_le16(buf, &prop)) {
        RZ_FREE(_enum);
        return NULL;
    }
    parse_codeview_property(&_enum->prop, prop);
    read_bytes += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &_enum->utype)) {
        RZ_FREE(_enum);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &_enum->field_list)) {
        RZ_FREE(_enum);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    parse_type_string(buf, &_enum->name, len, &read_bytes);
    if (has_non_padding(buf, len, &read_bytes)) {
        parse_type_string(buf, &_enum->mangled_name, len, &read_bytes);
    }
    skip_padding(buf, len, &read_bytes, true);
    return _enum;
}

References Tpi_LF_Enum::count, Tpi_LF_Enum::field_list, has_non_padding(), len, Tpi_LF_Enum::mangled_name, Tpi_LF_Enum::name, NULL, parse_codeview_property(), parse_type_string(), Tpi_LF_Enum::prop, rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, skip_padding(), and Tpi_LF_Enum::utype.

Referenced by parse_tpi_types().

parse_type_enumerate()

static Tpi_LF_Enumerate* parse_type_enumerate ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 848 of file tpi.c.

                                                                                       {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Enumerate *enumerate = RZ_NEW0(Tpi_LF_Enumerate);
    if (!enumerate) {
        return NULL;
    }
    ut16 fldattr;
    if (!rz_buf_read_le16(buf, &fldattr)) {
        RZ_FREE(enumerate);
        return NULL;
    }
    parse_codeview_fld_attribute(&enumerate->fldattr, fldattr);
    *read_len += sizeof(ut16);
    if (!parse_type_numeric(buf, &enumerate->enum_value, read_len)) {
        RZ_FREE(enumerate);
        return NULL;
    }
    if (!enumerate->enum_value.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&enumerate->enum_value);
        RZ_FREE(enumerate);
        return NULL;
    }
    parse_type_string(buf, &enumerate->name, len, read_len);
    skip_padding(buf, len, read_len, false);
    return enumerate;
}

References Tpi_LF_Enumerate::enum_value, Tpi_LF_Enumerate::fldattr, free_snumeric(), Tpi_Type_Numeric::is_integer, len, Tpi_LF_Enumerate::name, NULL, parse_codeview_fld_attribute(), parse_type_numeric(), parse_type_string(), rz_buf_read_le16, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_fieldlist()

static Tpi_LF_FieldList* parse_type_fieldlist ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1119 of file tpi.c.

                                                                       {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_FieldList *fieldlist = RZ_NEW0(Tpi_LF_FieldList);
    if (!fieldlist) {
        return NULL;
    }
    fieldlist->substructs = rz_list_newf((RzListFree)free_tpi_type);
    if (!fieldlist->substructs) {
        goto error;
    }
 
    ut16 read_len = sizeof(ut16);
    while (read_len < len) {
        RzPdbTpiType *type = RZ_NEW0(RzPdbTpiType);
        if (!type) {
            rz_list_free(fieldlist->substructs);
            goto error;
        }
        type->length = 0;
        type->type_index = 0;
        if (!rz_buf_read_le16(buf, &type->leaf_type)) {
            RZ_FREE(type);
            rz_list_free(fieldlist->substructs);
            goto error;
        }
        read_len += sizeof(ut16);
        switch (type->leaf_type) {
        case LF_ENUMERATE:
            type->type_data = parse_type_enumerate(buf, len, &read_len);
            break;
        case LF_NESTTYPE:
            type->type_data = parse_type_nesttype(buf, len, &read_len);
            break;
        case LF_VFUNCTAB:
            type->type_data = parse_type_vfunctab(buf, len, &read_len);
            break;
        case LF_METHOD:
            type->type_data = parse_type_method(buf, len, &read_len);
            break;
        case LF_MEMBER:
            type->type_data = parse_type_member(buf, len, &read_len);
            break;
        case LF_ONEMETHOD:
            type->type_data = parse_type_onemethod(buf, len, &read_len);
            break;
        case LF_BCLASS:
            type->type_data = parse_type_bclass(buf, len, &read_len);
            break;
        case LF_VBCLASS:
        case LF_IVBCLASS:
            type->type_data = parse_type_vbclass(buf, len, &read_len);
            break;
        case LF_STMEMBER:
            type->type_data = parse_type_staticmember(buf, len, &read_len);
            break;
        case LF_INDEX:
            type->type_data = parse_type_index(buf, len, &read_len);
            break;
        default:
            RZ_LOG_ERROR("%s: Unsupported leaf type 0x%" PFMT32x "\n", __FUNCTION__,
                type->leaf_type);
            RZ_FREE(type);
            rz_list_free(fieldlist->substructs);
            goto error;
        }
        if (!type->type_data) {
            RZ_FREE(type);
            rz_list_free(fieldlist->substructs);
            goto error;
        }
        rz_list_append(fieldlist->substructs, type);
    }
    return fieldlist;
error:
    RZ_FREE(fieldlist);
    return NULL;
}

References error(), free_tpi_type(), len, LF_BCLASS, LF_ENUMERATE, LF_INDEX, LF_IVBCLASS, LF_MEMBER, LF_METHOD, LF_NESTTYPE, LF_ONEMETHOD, LF_STMEMBER, LF_VBCLASS, LF_VFUNCTAB, NULL, parse_type_bclass(), parse_type_enumerate(), parse_type_index(), parse_type_member(), parse_type_method(), parse_type_nesttype(), parse_type_onemethod(), parse_type_staticmember(), parse_type_vbclass(), parse_type_vfunctab(), PFMT32x, rz_buf_read_le16, RZ_FREE, rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, Tpi_LF_FieldList::substructs, and type.

Referenced by parse_tpi_types().

parse_type_index()

static Tpi_LF_Index* parse_type_index ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 876 of file tpi.c.

                                                                               {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Index *index = RZ_NEW0(Tpi_LF_Index);
    if (!index) {
        return NULL;
    }
    ut16 fldattr;
    if (!rz_buf_read_le16(buf, &fldattr)) {
        RZ_FREE(index);
        return NULL;
    }
    parse_codeview_fld_attribute(&index->fldattr, fldattr);
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &index->index)) {
        RZ_FREE(index);
        return NULL;
    }
    *read_len += sizeof(ut32);
    skip_padding(buf, len, read_len, false);
    return index;
}

References Tpi_LF_Index::fldattr, Tpi_LF_Index::index, len, NULL, parse_codeview_fld_attribute(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_member()

static Tpi_LF_Member* parse_type_member ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 959 of file tpi.c.

                                                                                 {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Member *member = RZ_NEW0(Tpi_LF_Member);
    if (!member) {
        return NULL;
    }
    ut16 fldattr;
    if (!rz_buf_read_le16(buf, &fldattr)) {
        RZ_FREE(member);
        return NULL;
    }
    parse_codeview_fld_attribute(&member->fldattr, fldattr);
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &member->index)) {
        RZ_FREE(member);
        return NULL;
    }
    *read_len += sizeof(ut32);
    if (!parse_type_numeric(buf, &member->offset, read_len)) {
        RZ_FREE(member);
        return NULL;
    }
    if (!member->offset.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&member->offset);
        RZ_FREE(member);
        return NULL;
    }
    parse_type_string(buf, &member->name, len, read_len);
    skip_padding(buf, len, read_len, false);
    return member;
}

References Tpi_LF_Member::fldattr, free_snumeric(), Tpi_LF_Member::index, Tpi_Type_Numeric::is_integer, len, Tpi_LF_Member::name, NULL, Tpi_LF_Member::offset, parse_codeview_fld_attribute(), parse_type_numeric(), parse_type_string(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_method()

static Tpi_LF_Method* parse_type_method ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 938 of file tpi.c.

                                                                                 {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Method *method = RZ_NEW0(Tpi_LF_Method);
    if (!method) {
        return NULL;
    }
    if (!rz_buf_read_le16(buf, &method->count)) {
        RZ_FREE(method);
        return NULL;
    }
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &method->mlist)) {
        RZ_FREE(method);
        return NULL;
    }
    *read_len += sizeof(ut32);
    parse_type_string(buf, &method->name, len, read_len);
    skip_padding(buf, len, read_len, false);
    return method;
}

References Tpi_LF_Method::count, len, Tpi_LF_Method::mlist, Tpi_LF_Method::name, NULL, parse_type_string(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_methodlist()

static Tpi_LF_MethodList* parse_type_methodlist ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1523 of file tpi.c.

                                                                         {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_MethodList *mlist = RZ_NEW0(Tpi_LF_MethodList);
    if (!mlist) {
        return NULL;
    }
    mlist->members = rz_list_newf(free);
    if (!mlist->members) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        goto error;
    }
    ut16 read_bytes = sizeof(ut16);
    while (read_bytes < len) {
        Tpi_Type_MethodListMember *member = RZ_NEW0(Tpi_Type_MethodListMember);
        if (!member) {
            continue;
        }
        ut16 fldattr;
        if (!rz_buf_read_le16(buf, &fldattr)) {
            RZ_FREE(member);
            rz_list_free(mlist->members);
            RZ_FREE(mlist);
            return NULL;
        }
        parse_codeview_fld_attribute(&member->fldattr, fldattr);
        read_bytes += sizeof(ut16);
        if (!rz_buf_read_le16(buf, &member->pad)) {
            RZ_FREE(member);
            rz_list_free(mlist->members);
            RZ_FREE(mlist);
            return NULL;
        }
        read_bytes += sizeof(ut16);
        if (!rz_buf_read_le32(buf, &member->type)) {
            RZ_FREE(member);
            rz_list_free(mlist->members);
            RZ_FREE(mlist);
            return NULL;
        }
        read_bytes += sizeof(ut32);
        member->optional_offset = 0;
        if (member->fldattr.bits.mprop == MTintro ||
            member->fldattr.bits.mprop == MTpureintro) {
            if (!rz_buf_read_le32(buf, &member->optional_offset)) {
                RZ_FREE(member);
                rz_list_free(mlist->members);
                RZ_FREE(mlist);
                return NULL;
            }
            read_bytes += sizeof(ut32);
        }
        rz_list_append(mlist->members, member);
    }
    skip_padding(buf, len, &read_bytes, true);
    return mlist;
 
error:
    RZ_FREE(mlist);
    return NULL;
}

References TpiCVFldattr::bits, error(), Tpi_Type_MethodListMember::fldattr, free(), len, Tpi_LF_MethodList::members, TpiCVFldattr::mprop, MTintro, MTpureintro, NULL, Tpi_Type_MethodListMember::optional_offset, Tpi_Type_MethodListMember::pad, parse_codeview_fld_attribute(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, skip_padding(), and Tpi_Type_MethodListMember::type.

Referenced by parse_tpi_types().

parse_type_mfunction()

static Tpi_LF_MFcuntion* parse_type_mfunction ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1470 of file tpi.c.

                                                                       {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_MFcuntion *mfunc = RZ_NEW0(Tpi_LF_MFcuntion);
    if (!mfunc) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le32(buf, &mfunc->return_type)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &mfunc->class_type)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &mfunc->this_type)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read8(buf, (ut8 *)&mfunc->call_conv)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    read_bytes += sizeof(ut8);
    ut8 funcattr;
    if (!rz_buf_read8(buf, &funcattr)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    parse_codeview_func_attribute(&mfunc->func_attr, funcattr);
    read_bytes += sizeof(ut8);
    if (!rz_buf_read_le16(buf, &mfunc->parm_count)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    read_bytes += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &mfunc->arglist)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, (ut32 *)&mfunc->this_adjust)) {
        RZ_FREE(mfunc);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    skip_padding(buf, len, &read_bytes, true);
    return mfunc;
}

References Tpi_LF_MFcuntion::arglist, Tpi_LF_MFcuntion::call_conv, Tpi_LF_MFcuntion::class_type, Tpi_LF_MFcuntion::func_attr, len, NULL, Tpi_LF_MFcuntion::parm_count, parse_codeview_func_attribute(), Tpi_LF_MFcuntion::return_type, rz_buf_read8(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, skip_padding(), Tpi_LF_MFcuntion::this_adjust, Tpi_LF_MFcuntion::this_type, and ut8.

Referenced by parse_tpi_types().

parse_type_modifier()

static Tpi_LF_Modifier* parse_type_modifier ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1416 of file tpi.c.

                                                                     {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Modifier *modifier = RZ_NEW0(Tpi_LF_Modifier);
    if (!modifier) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le32(buf, &modifier->modified_type)) {
        RZ_FREE(modifier);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    ut16 umodifier;
    if (!rz_buf_read_le16(buf, &umodifier)) {
        RZ_FREE(modifier);
        return NULL;
    }
    parse_codeview_modifier(&modifier->umodifier, umodifier);
    read_bytes += sizeof(ut16);
    skip_padding(buf, len, &read_bytes, true);
    return modifier;
}

References len, Tpi_LF_Modifier::modified_type, NULL, parse_codeview_modifier(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, skip_padding(), and Tpi_LF_Modifier::umodifier.

Referenced by parse_tpi_types().

parse_type_nesttype()

static Tpi_LF_NestType* parse_type_nesttype ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 898 of file tpi.c.

                                                                                     {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_NestType *nest = RZ_NEW0(Tpi_LF_NestType);
    if (!nest) {
        return NULL;
    }
    if (!rz_buf_read_le16(buf, &nest->pad)) {
        RZ_FREE(nest);
        return NULL;
    }
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &nest->index)) {
        RZ_FREE(nest);
        return NULL;
    }
    *read_len += sizeof(ut32);
    parse_type_string(buf, &nest->name, len, read_len);
    skip_padding(buf, len, read_len, false);
    return nest;
}

References Tpi_LF_NestType::index, len, Tpi_LF_NestType::name, NULL, Tpi_LF_NestType::pad, parse_type_string(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_numeric()

static bool parse_type_numeric ( RzBuffer *  buf, Tpi_Type_Numeric *  numeric, ut16 *  read_len  )

static

Definition at line 746 of file tpi.c.

                                                                                         {
    numeric->data = 0;
    numeric->is_integer = true;
    if (!rz_buf_read_le16(buf, &numeric->type_index)) {
        return false;
    }
    *read_len += sizeof(ut16);
    switch (numeric->type_index) {
    case LF_CHAR:
        numeric->data = RZ_NEW0(st8);
        if (!rz_buf_read8(buf, numeric->data)) {
            RZ_FREE(numeric->data);
            return false;
        }
        *read_len += sizeof(st8);
        break;
    case LF_SHORT:
        numeric->data = RZ_NEW0(st16);
        if (!rz_buf_read_le16(buf, numeric->data)) {
            RZ_FREE(numeric->data);
            return false;
        }
        *read_len += sizeof(st16);
        break;
    case LF_USHORT:
        numeric->data = RZ_NEW0(ut16);
        if (!rz_buf_read_le16(buf, numeric->data)) {
            RZ_FREE(numeric->data);
            return false;
        }
        *read_len += sizeof(ut16);
        break;
    case LF_LONG:
        numeric->data = RZ_NEW0(st32);
        if (!rz_buf_read_le32(buf, numeric->data)) {
            RZ_FREE(numeric->data);
            return false;
        }
        *read_len += sizeof(st32);
        break;
    case LF_ULONG:
        numeric->data = RZ_NEW0(ut32);
        if (!rz_buf_read_le32(buf, numeric->data)) {
            RZ_FREE(numeric->data);
            return false;
        }
        *read_len += sizeof(ut32);
        break;
    case LF_QUADWORD:
        numeric->data = RZ_NEW0(st64);
        if (!rz_buf_read_le64(buf, numeric->data)) {
            RZ_FREE(numeric->data);
            return false;
        }
        *read_len += sizeof(st64);
        break;
    case LF_UQUADWORD:
        numeric->data = RZ_NEW0(ut64);
        if (!rz_buf_read_le64(buf, numeric->data)) {
            RZ_FREE(numeric->data);
            return false;
        }
        *read_len += sizeof(ut64);
        break;
    default:
        if (numeric->type_index >= 0x8000) {
            numeric->is_integer = false;
            RZ_LOG_ERROR("%s: Skipping unsupported type (%d)\n", __FUNCTION__,
                numeric->type_index);
            return false;
        }
        numeric->data = RZ_NEW0(ut16);
        *(ut16 *)(numeric->data) = numeric->type_index;
        return true;
    }
    return true;
}

References Tpi_Type_Numeric::data, Tpi_Type_Numeric::is_integer, LF_CHAR, LF_LONG, LF_QUADWORD, LF_SHORT, LF_ULONG, LF_UQUADWORD, LF_USHORT, rz_buf_read8(), rz_buf_read_le16, rz_buf_read_le32, rz_buf_read_le64, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, st16, st32, st64, st8, Tpi_Type_Numeric::type_index, and ut64().

Referenced by parse_type_array(), parse_type_bclass(), parse_type_enumerate(), parse_type_member(), parse_type_struct(), parse_type_struct_19(), parse_type_union(), and parse_type_vbclass().

parse_type_onemethod()

static Tpi_LF_OneMethod* parse_type_onemethod ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 1015 of file tpi.c.

                                                                                       {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_OneMethod *onemethod = RZ_NEW0(Tpi_LF_OneMethod);
    if (!onemethod) {
        return NULL;
    }
    ut16 fldattr;
    if (!rz_buf_read_le16(buf, &fldattr)) {
        RZ_FREE(onemethod);
        return NULL;
    }
    parse_codeview_fld_attribute(&onemethod->fldattr, fldattr);
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &onemethod->index)) {
        RZ_FREE(onemethod);
        return NULL;
    }
    *read_len += sizeof(ut32);
    onemethod->offset_in_vtable = 0;
    if (onemethod->fldattr.bits.mprop == MTintro ||
        onemethod->fldattr.bits.mprop == MTpureintro) {
        if (!rz_buf_read_le32(buf, &onemethod->offset_in_vtable)) {
            RZ_FREE(onemethod);
        }
        *read_len += sizeof(ut32);
    }
    parse_type_string(buf, &onemethod->name, len, read_len);
    skip_padding(buf, len, read_len, false);
    return onemethod;
}

References TpiCVFldattr::bits, Tpi_LF_OneMethod::fldattr, Tpi_LF_OneMethod::index, len, TpiCVFldattr::mprop, MTintro, MTpureintro, Tpi_LF_OneMethod::name, NULL, Tpi_LF_OneMethod::offset_in_vtable, parse_codeview_fld_attribute(), parse_type_string(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_pointer()

static Tpi_LF_Pointer* parse_type_pointer ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1342 of file tpi.c.

                                                                   {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Pointer *pointer = RZ_NEW0(Tpi_LF_Pointer);
    if (!pointer) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le32(buf, &pointer->utype)) {
        RZ_FREE(pointer);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    ut32 ptrattr;
    if (!rz_buf_read_le32(buf, &ptrattr)) {
        RZ_FREE(pointer);
        return NULL;
    }
    parse_codeview_pointer_attribute(&pointer->ptr_attr, ptrattr);
    read_bytes += sizeof(ut32);
    if (pointer->ptr_attr.bits.ptrmode == PTR_MODE_PMFUNC ||
        pointer->ptr_attr.bits.ptrmode == PTR_MODE_PMEM) {
        read_bytes += sizeof(ut32);
        if (!rz_buf_read_le32(buf, &pointer->pmember.pmclass)) {
            RZ_FREE(pointer);
            return NULL;
        }
        read_bytes += sizeof(ut16);
        if (!rz_buf_read_le16(buf, &pointer->pmember.pmtype)) {
            RZ_FREE(pointer);
            return NULL;
        }
    } else if (pointer->ptr_attr.bits.ptrtype == PTR_BASE_TYPE) {
        read_bytes += sizeof(ut32);
        if (!rz_buf_read_le32(buf, &pointer->pbase.index)) {
            RZ_FREE(pointer);
            return NULL;
        }
    }
    skip_padding(buf, len, &read_bytes, true);
    return pointer;
}

References TpiCVPointerAttr::bits, len, NULL, parse_codeview_pointer_attribute(), Tpi_LF_Pointer::pbase, Tpi_LF_Pointer::pmember, Tpi_LF_Pointer::ptr_attr, PTR_BASE_TYPE, PTR_MODE_PMEM, PTR_MODE_PMFUNC, TpiCVPointerAttr::ptrmode, TpiCVPointerAttr::ptrtype, rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, skip_padding(), and Tpi_LF_Pointer::utype.

Referenced by parse_tpi_types().

parse_type_procedure()

static Tpi_LF_Procedure* parse_type_procedure ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1584 of file tpi.c.

                                                                       {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Procedure *proc = RZ_NEW0(Tpi_LF_Procedure);
    if (!proc) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le32(buf, &proc->return_type)) {
        RZ_FREE(proc);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read8(buf, (ut8 *)&proc->call_conv)) {
        RZ_FREE(proc);
        return NULL;
    }
    read_bytes += sizeof(ut8);
    ut8 funcattr;
    if (!rz_buf_read8(buf, &funcattr)) {
        RZ_FREE(proc);
        return NULL;
    }
    parse_codeview_func_attribute(&proc->func_attr, funcattr);
    read_bytes += sizeof(ut8);
    if (!rz_buf_read_le16(buf, &proc->parm_count)) {
        RZ_FREE(proc);
        return NULL;
    }
    read_bytes += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &proc->arg_list)) {
        RZ_FREE(proc);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    skip_padding(buf, len, &read_bytes, true);
    return proc;
}

References len, NULL, parse_codeview_func_attribute(), proc, rz_buf_read8(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, skip_padding(), and ut8.

Referenced by parse_tpi_types().

parse_type_staticmember()

static Tpi_LF_StaticMember* parse_type_staticmember ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 992 of file tpi.c.

                                                                                             {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_StaticMember *member = RZ_NEW0(Tpi_LF_StaticMember);
    if (!member) {
        return NULL;
    }
    ut16 fldattr;
    if (!rz_buf_read_le16(buf, &fldattr)) {
        RZ_FREE(member);
        return NULL;
    }
    parse_codeview_fld_attribute(&member->fldattr, fldattr);
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &member->index)) {
        RZ_FREE(member);
        return NULL;
    }
    *read_len += sizeof(ut32);
    parse_type_string(buf, &member->name, len, read_len);
    skip_padding(buf, len, read_len, false);
    return member;
}

References Tpi_LF_StaticMember::fldattr, Tpi_LF_StaticMember::index, len, Tpi_LF_StaticMember::name, NULL, parse_codeview_fld_attribute(), parse_type_string(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, rz_return_val_if_fail, and skip_padding().

Referenced by parse_type_fieldlist().

parse_type_string()

static void parse_type_string ( RzBuffer *  buf, Tpi_Type_String *  str, ut16  len, ut16 *  read_len  )

static

Definition at line 824 of file tpi.c.

                                                                                             {
    ut16 size = 0;
    while (*read_len < len) {
        ut8 byt;
        if (!rz_buf_read8(buf, &byt)) {
            break;
        }
        *(read_len) += 1;
        size++;
        if (!byt) {
            rz_buf_seek(buf, -size, RZ_BUF_CUR);
            str->name = (char *)rz_mem_alloc(size);
            if (!str->name) {
                str->name = NULL;
                RZ_LOG_ERROR("Error allocating memory.\n");
                return;
            }
            rz_buf_read(buf, (ut8 *)str->name, size);
            str->size = size;
            break;
        }
    }
}

References len, NULL, RZ_BUF_CUR, rz_buf_read(), rz_buf_read8(), rz_buf_seek(), RZ_LOG_ERROR, rz_mem_alloc(), and cmd_descs_generate::str.

Referenced by parse_type_array(), parse_type_enum(), parse_type_enumerate(), parse_type_member(), parse_type_method(), parse_type_nesttype(), parse_type_onemethod(), parse_type_staticmember(), parse_type_struct(), parse_type_struct_19(), and parse_type_union().

parse_type_struct()

static Tpi_LF_Structure* parse_type_struct ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1234 of file tpi.c.

                                                                    {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Structure *structure = RZ_NEW0(Tpi_LF_Structure);
    if (!structure) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le16(buf, &structure->count)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut16);
    ut16 prop;
    if (!rz_buf_read_le16(buf, &prop)) {
        RZ_FREE(structure);
        return NULL;
    }
    parse_codeview_property(&structure->prop, prop);
    read_bytes += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &structure->field_list)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &structure->derived)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &structure->vshape)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!parse_type_numeric(buf, &structure->size, &read_bytes)) {
        RZ_FREE(structure);
        return NULL;
    }
    if (!structure->size.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&structure->size);
        RZ_FREE(structure);
        return NULL;
    }
    parse_type_string(buf, &structure->name, len, &read_bytes);
    if (has_non_padding(buf, len, &read_bytes)) {
        parse_type_string(buf, &structure->mangled_name, len, &read_bytes);
    }
    skip_padding(buf, len, &read_bytes, true);
    return structure;
}

References Tpi_LF_Structure::count, Tpi_LF_Structure::derived, Tpi_LF_Structure::field_list, free_snumeric(), has_non_padding(), Tpi_Type_Numeric::is_integer, len, Tpi_LF_Structure::mangled_name, Tpi_LF_Structure::name, NULL, parse_codeview_property(), parse_type_numeric(), parse_type_string(), Tpi_LF_Structure::prop, rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, Tpi_LF_Structure::size, skip_padding(), and Tpi_LF_Structure::vshape.

Referenced by parse_tpi_types().

parse_type_struct_19()

static Tpi_LF_Structure_19* parse_type_struct_19 ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1286 of file tpi.c.

                                                                          {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Structure_19 *structure = RZ_NEW0(Tpi_LF_Structure_19);
    if (!structure) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    ut16 prop;
    if (!rz_buf_read_le16(buf, &prop)) {
        RZ_FREE(structure);
        return NULL;
    }
    parse_codeview_property(&structure->prop, prop);
    read_bytes += sizeof(ut16);
    if (!rz_buf_read_le16(buf, &structure->unknown)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &structure->field_list)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &structure->derived)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &structure->vshape)) {
        RZ_FREE(structure);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!parse_type_numeric(buf, &structure->unknown1, &read_bytes)) {
        RZ_FREE(structure);
        return NULL;
    }
    if (!parse_type_numeric(buf, &structure->size, &read_bytes)) {
        RZ_FREE(structure);
        return NULL;
    }
    if (!structure->size.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&structure->size);
        RZ_FREE(structure);
        return NULL;
    }
    parse_type_string(buf, &structure->name, len, &read_bytes);
    if (has_non_padding(buf, len, &read_bytes)) {
        parse_type_string(buf, &structure->mangled_name, len, &read_bytes);
    }
    skip_padding(buf, len, &read_bytes, true);
    return structure;
}

References Tpi_LF_Structure_19::derived, Tpi_LF_Structure_19::field_list, free_snumeric(), has_non_padding(), Tpi_Type_Numeric::is_integer, len, Tpi_LF_Structure_19::mangled_name, Tpi_LF_Structure_19::name, NULL, parse_codeview_property(), parse_type_numeric(), parse_type_string(), Tpi_LF_Structure_19::prop, rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, Tpi_LF_Structure_19::size, skip_padding(), Tpi_LF_Structure_19::unknown, Tpi_LF_Structure_19::unknown1, and Tpi_LF_Structure_19::vshape.

Referenced by parse_tpi_types().

parse_type_union()

static Tpi_LF_Union* parse_type_union ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1622 of file tpi.c.

                                                               {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Union *unin = RZ_NEW0(Tpi_LF_Union);
    if (!unin) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le16(buf, &unin->count)) {
        RZ_FREE(unin);
        return NULL;
    }
    read_bytes += sizeof(ut16);
    ut16 prop;
    if (!rz_buf_read_le16(buf, &prop)) {
        RZ_FREE(unin);
        return NULL;
    }
    parse_codeview_property(&unin->prop, prop);
    read_bytes += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &unin->field_list)) {
        RZ_FREE(unin);
        return NULL;
    }
    read_bytes += sizeof(ut32);
    if (!parse_type_numeric(buf, &unin->size, &read_bytes)) {
        RZ_FREE(unin);
    }
    if (!unin->size.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&unin->size);
        RZ_FREE(unin);
        return NULL;
    }
    parse_type_string(buf, &unin->name, len, &read_bytes);
    if (has_non_padding(buf, len, &read_bytes)) {
        parse_type_string(buf, &unin->mangled_name, len, &read_bytes);
    }
 
    skip_padding(buf, len, &read_bytes, true);
    return unin;
}

References Tpi_LF_Union::count, Tpi_LF_Union::field_list, free_snumeric(), has_non_padding(), Tpi_Type_Numeric::is_integer, len, Tpi_LF_Union::mangled_name, Tpi_LF_Union::name, NULL, parse_codeview_property(), parse_type_numeric(), parse_type_string(), Tpi_LF_Union::prop, rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, Tpi_LF_Union::size, and skip_padding().

Referenced by parse_tpi_types().

parse_type_vbclass()

static Tpi_LF_VBClass* parse_type_vbclass ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 1078 of file tpi.c.

                                                                                   {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_VBClass *bclass = RZ_NEW0(Tpi_LF_VBClass);
    if (!bclass) {
        return NULL;
    }
    ut16 fldattr;
    if (!rz_buf_read_le16(buf, &fldattr)) {
        RZ_FREE(bclass);
        return NULL;
    }
    parse_codeview_fld_attribute(&bclass->fldattr, fldattr);
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &bclass->direct_vbclass_idx)) {
        RZ_FREE(bclass);
        return NULL;
    }
    *read_len += sizeof(ut32);
    if (!rz_buf_read_le32(buf, &bclass->vb_pointer_idx)) {
        RZ_FREE(bclass);
        return NULL;
    }
    *read_len += sizeof(ut32);
    parse_type_numeric(buf, &bclass->vb_pointer_offset, read_len);
    if (!bclass->vb_pointer_offset.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&bclass->vb_pointer_offset);
        RZ_FREE(bclass);
        return NULL;
    }
    parse_type_numeric(buf, &bclass->vb_offset_from_vbtable, read_len);
    if (!bclass->vb_offset_from_vbtable.is_integer) {
        RZ_LOG_ERROR("Integer expected!\n");
        free_snumeric(&bclass->vb_offset_from_vbtable);
        RZ_FREE(bclass);
        return NULL;
    }
    skip_padding(buf, len, read_len, false);
    return bclass;
}

References Tpi_LF_VBClass::direct_vbclass_idx, Tpi_LF_VBClass::fldattr, free_snumeric(), Tpi_Type_Numeric::is_integer, len, NULL, parse_codeview_fld_attribute(), parse_type_numeric(), rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, skip_padding(), Tpi_LF_VBClass::vb_offset_from_vbtable, Tpi_LF_VBClass::vb_pointer_idx, and Tpi_LF_VBClass::vb_pointer_offset.

Referenced by parse_type_fieldlist().

parse_type_vfunctab()

static Tpi_LF_VFuncTab* parse_type_vfunctab ( RzBuffer *  buf, ut16  len, ut16 *  read_len  )

static

Definition at line 919 of file tpi.c.

                                                                                     {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_VFuncTab *vftab = RZ_NEW0(Tpi_LF_VFuncTab);
    if (!vftab) {
        return NULL;
    }
    if (!rz_buf_read_le16(buf, &vftab->pad)) {
        RZ_FREE(vftab);
        return NULL;
    }
    *read_len += sizeof(ut16);
    if (!rz_buf_read_le32(buf, &vftab->index)) {
        RZ_FREE(vftab);
        return NULL;
    }
    *read_len += sizeof(ut32);
    return vftab;
}

References Tpi_LF_VFuncTab::index, NULL, Tpi_LF_VFuncTab::pad, rz_buf_read_le16, rz_buf_read_le32, RZ_FREE, RZ_NEW0, and rz_return_val_if_fail.

Referenced by parse_type_fieldlist().

parse_type_vtshape()

static Tpi_LF_Vtshape* parse_type_vtshape ( RzBuffer *  buf, ut16  len  )

static

Definition at line 1690 of file tpi.c.

                                                                   {
    rz_return_val_if_fail(buf, NULL);
    Tpi_LF_Vtshape *vt = RZ_NEW0(Tpi_LF_Vtshape);
    if (!vt) {
        return NULL;
    }
    ut16 read_bytes = sizeof(ut16);
    if (!rz_buf_read_le16(buf, &vt->count)) {
        RZ_FREE(vt);
        return NULL;
    }
    read_bytes += sizeof(ut16);
    ut16 size = (4 * vt->count + (vt->count % 2) * 4) / 8;
    vt->vt_descriptors = (char *)malloc(size);
    if (!vt->vt_descriptors) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        RZ_FREE(vt);
        return NULL;
    }
    rz_buf_read(buf, (ut8 *)vt->vt_descriptors, size);
    read_bytes += size;
    skip_padding(buf, len, &read_bytes, true);
    return vt;
}

References Tpi_LF_Vtshape::count, len, malloc(), NULL, rz_buf_read(), rz_buf_read_le16, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, skip_padding(), and Tpi_LF_Vtshape::vt_descriptors.

Referenced by parse_tpi_types().

rz_bin_pdb_calling_convention_as_string()

RZ_API RZ_OWN char* rz_bin_pdb_calling_convention_as_string

(

RZ_NONNULL RzPdbTpiCallingConvention

idx

)

Parses calling convention type as string.

Parameters

idx

Definition at line 35 of file tpi.c.

                                                                                                      {
    switch (idx) {
    case NEAR_C:
    case FAR_C:
        return strdup("__cdecl");
    case NEAR_PASCAL:
    case FAR_PASCAL:
        return strdup("__pascal");
    case NEAR_FAST:
    case FAR_FAST:
        return strdup("__fastcall");
    case NEAR_STD:
    case FAR_STD:
        return strdup("__stdcall");
    case NEAR_SYS:
    case FAR_SYS:
        return strdup("__syscall");
    case THISCALL:
        return strdup("__thiscall");
    case NEAR_VEC:
        return strdup("__vectorcall");
    default:
        return NULL;
    }
}

References FAR_C, FAR_FAST, FAR_PASCAL, FAR_STD, FAR_SYS, setup::idx, NEAR_C, NEAR_FAST, NEAR_PASCAL, NEAR_STD, NEAR_SYS, NEAR_VEC, NULL, strdup(), and THISCALL.

Referenced by parse_type_mfunction(), and parse_type_procedure().

rz_bin_pdb_get_type_by_index()

RZ_API RZ_BORROW RzPdbTpiType* rz_bin_pdb_get_type_by_index	(	RZ_NONNULL RzPdbTpiStream *	stream,
		ut32	index
	)

Get RzPdbTpiType that matches tpi stream index.

Parameters

stream	TPI Stream
index	TPI Stream Index

Definition at line 1844 of file tpi.c.

                                                                                                           {
    rz_return_val_if_fail(stream, NULL);
    if (index == 0) {
        return NULL;
    }
 
    RBNode *node = rz_rbtree_find(stream->types, &index, tpi_type_node_cmp, NULL);
    if (!node) {
        if (!is_simple_type(stream, index)) {
            return NULL;
        } else {
            return parse_simple_type(stream, index);
        }
    }
    RzPdbTpiType *type = container_of(node, RzPdbTpiType, rb);
    return type;
}

References container_of, is_simple_type(), NULL, parse_simple_type(), rz_rbtree_find(), rz_return_val_if_fail, tpi_type_node_cmp(), and type.

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

rz_bin_pdb_get_type_members()

RZ_API RZ_BORROW RzList* rz_bin_pdb_get_type_members	(	RZ_NONNULL RzPdbTpiStream *	stream,
		RzPdbTpiType *	t
	)

Get the RzPdbTpiType member list.

Parameters

stream	TPI stream
t	RzPdbTpiType

Returns

RzList *

Definition at line 406 of file tpi.c.

                                                                                                         {
    rz_return_val_if_fail(t, NULL);
    RzPdbTpiType *tmp;
    switch (t->leaf_type) {
    case LF_FIELDLIST: {
        Tpi_LF_FieldList *lf = t->type_data;
        return lf->substructs;
    }
    case LF_UNION: {
        tmp = rz_bin_pdb_get_type_by_index(stream, ((Tpi_LF_Union *)t->type_data)->field_list);
        Tpi_LF_FieldList *lf_union = tmp ? tmp->type_data : NULL;
        return lf_union ? lf_union->substructs : NULL;
    }
    case LF_STRUCTURE:
    case LF_CLASS: {
        tmp = rz_bin_pdb_get_type_by_index(stream, ((Tpi_LF_Structure *)t->type_data)->field_list);
        Tpi_LF_FieldList *lf_struct = tmp ? tmp->type_data : NULL;
        return lf_struct ? lf_struct->substructs : NULL;
    }
    case LF_STRUCTURE_19:
    case LF_CLASS_19: {
        tmp = rz_bin_pdb_get_type_by_index(stream, ((Tpi_LF_Structure_19 *)t->type_data)->field_list);
        Tpi_LF_FieldList *lf_struct19 = tmp ? tmp->type_data : NULL;
        return lf_struct19 ? lf_struct19->substructs : NULL;
    }
    case LF_ENUM: {
        tmp = rz_bin_pdb_get_type_by_index(stream, ((Tpi_LF_Enum *)t->type_data)->field_list);
        Tpi_LF_FieldList *lf_enum = tmp ? tmp->type_data : NULL;
        return lf_enum ? lf_enum->substructs : NULL;
    }
    default:
        return NULL;
    }
}

References tpi_types::leaf_type, LF_CLASS, LF_CLASS_19, LF_ENUM, LF_FIELDLIST, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, NULL, rz_bin_pdb_get_type_by_index(), rz_return_val_if_fail, Tpi_LF_FieldList::substructs, autogen_x86imm::tmp, and tpi_types::type_data.

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

rz_bin_pdb_get_type_name()

RZ_API RZ_BORROW char* rz_bin_pdb_get_type_name

(

RZ_NONNULL RzPdbTpiType *

type

)

Get the name of the type.

Parameters

type	RzPdbTpiType *

Returns

char *

Definition at line 447 of file tpi.c.

                                                                               {
    rz_return_val_if_fail(type, NULL);
    switch (type->leaf_type) {
    case LF_MEMBER: {
        Tpi_LF_Member *lf_member = type->type_data;
        return lf_member->name.name;
    }
    case LF_STMEMBER: {
        Tpi_LF_StaticMember *lf_stmember = type->type_data;
        return lf_stmember->name.name;
    }
    case LF_ONEMETHOD: {
        Tpi_LF_OneMethod *lf_onemethod = type->type_data;
        return lf_onemethod->name.name;
    }
    case LF_METHOD: {
        Tpi_LF_Method *lf_method = type->type_data;
        return lf_method->name.name;
    }
    case LF_NESTTYPE: {
        Tpi_LF_NestType *lf_nesttype = type->type_data;
        return lf_nesttype->name.name;
    }
    case LF_ENUM: {
        Tpi_LF_Enum *lf_enum = type->type_data;
        return lf_enum->name.name;
    }
    case LF_ENUMERATE: {
        Tpi_LF_Enumerate *lf_enumerate = type->type_data;
        return lf_enumerate->name.name;
    }
    case LF_CLASS:
    case LF_STRUCTURE: {
        Tpi_LF_Structure *lf_struct = type->type_data;
        return lf_struct->name.name;
    }
    case LF_CLASS_19:
    case LF_STRUCTURE_19: {
        Tpi_LF_Structure_19 *lf_struct_19 = type->type_data;
        return lf_struct_19->name.name;
    }
    case LF_ARRAY: {
        Tpi_LF_Array *lf_array = type->type_data;
        return lf_array->name.name;
    }
    case LF_UNION: {
        Tpi_LF_Union *lf_union = type->type_data;
        return lf_union->name.name;
    }
    default:
        return NULL;
    }
}

References LF_ARRAY, LF_CLASS, LF_CLASS_19, LF_ENUM, LF_ENUMERATE, LF_MEMBER, LF_METHOD, LF_NESTTYPE, LF_ONEMETHOD, LF_STMEMBER, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, Tpi_Type_String::name, Tpi_LF_Array::name, Tpi_LF_Structure::name, Tpi_LF_Structure_19::name, Tpi_LF_Union::name, Tpi_LF_Enum::name, Tpi_LF_Enumerate::name, Tpi_LF_NestType::name, Tpi_LF_Method::name, Tpi_LF_Member::name, Tpi_LF_StaticMember::name, Tpi_LF_OneMethod::name, NULL, rz_return_val_if_fail, and type.

Referenced by parse_enum(), parse_enumerate(), parse_struct_member(), parse_structure(), parse_type_nest(), parse_type_onemethod(), parse_union(), and parse_union_member().

rz_bin_pdb_get_type_val()

RZ_API ut64 rz_bin_pdb_get_type_val

(

RZ_NONNULL RzPdbTpiType *

type

)

Get the numeric value inside the type.

Parameters

type	RzPdbTpiType *

Returns

ut64

Definition at line 507 of file tpi.c.

                                                                   {
    rz_return_val_if_fail(type, -1);
    switch (type->leaf_type) {
    case LF_ONEMETHOD: {
        Tpi_LF_OneMethod *lf_onemethod = type->type_data;
        return lf_onemethod->offset_in_vtable;
    }
    case LF_MEMBER: {
        Tpi_LF_Member *lf_member = type->type_data;
        return get_numeric_val(&lf_member->offset);
    }
    case LF_ENUMERATE: {
        Tpi_LF_Enumerate *lf_enumerate = type->type_data;
        return get_numeric_val(&lf_enumerate->enum_value);
    }
    case LF_CLASS:
    case LF_STRUCTURE: {
        Tpi_LF_Structure *lf_struct = type->type_data;
        return get_numeric_val(&lf_struct->size);
    }
    case LF_CLASS_19:
    case LF_STRUCTURE_19: {
        Tpi_LF_Structure_19 *lf_struct_19 = type->type_data;
        return get_numeric_val(&lf_struct_19->size);
    }
    case LF_ARRAY: {
        Tpi_LF_Array *lf_array = type->type_data;
        return get_numeric_val(&lf_array->size);
    }
    case LF_UNION: {
        Tpi_LF_Union *lf_union = type->type_data;
        return get_numeric_val(&lf_union->size);
    }
    case LF_INDEX: {
        Tpi_LF_Index *lf_index = type->type_data;
        return lf_index->index;
    }
    default:
        return 0;
    }
}

References Tpi_LF_Enumerate::enum_value, get_numeric_val(), Tpi_LF_Index::index, LF_ARRAY, LF_CLASS, LF_CLASS_19, LF_ENUMERATE, LF_INDEX, LF_MEMBER, LF_ONEMETHOD, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, Tpi_LF_Member::offset, Tpi_LF_OneMethod::offset_in_vtable, rz_return_val_if_fail, Tpi_LF_Array::size, Tpi_LF_Structure::size, Tpi_LF_Structure_19::size, Tpi_LF_Union::size, and type.

Referenced by parse_enum(), parse_enumerate(), parse_struct_member(), parse_structure(), parse_type_array(), parse_union(), and parse_union_member().

rz_bin_pdb_type_is_fwdref()

RZ_API bool rz_bin_pdb_type_is_fwdref

(

RZ_NONNULL RzPdbTpiType *

t

)

Return true if type is forward definition.

Parameters

t	RzPdbTpiType

Returns

bool

Definition at line 372 of file tpi.c.

                                                                  {
    rz_return_val_if_fail(t, false); // return val stands for we do nothing for it
    switch (t->leaf_type) {
    case LF_UNION: {
        Tpi_LF_Union *lf = (Tpi_LF_Union *)t->type_data;
        return lf->prop.bits.fwdref ? true : false;
    }
    case LF_STRUCTURE:
    case LF_CLASS: {
        Tpi_LF_Structure *lf = (Tpi_LF_Structure *)t->type_data;
        return lf->prop.bits.fwdref ? true : false;
    }
    case LF_STRUCTURE_19:
    case LF_CLASS_19: {
        Tpi_LF_Structure_19 *lf = (Tpi_LF_Structure_19 *)t->type_data;
        return lf->prop.bits.fwdref ? true : false;
    }
    case LF_ENUM: {
        Tpi_LF_Enum *lf = (Tpi_LF_Enum *)t->type_data;
        return lf->prop.bits.fwdref ? true : false;
    }
    default:
        rz_warn_if_reached();
        return false;
    }
}

References TpiCVProperty::bits, TpiCVProperty::fwdref, LF_CLASS, LF_CLASS_19, LF_ENUM, LF_STRUCTURE, LF_STRUCTURE_19, LF_UNION, Tpi_LF_Structure::prop, Tpi_LF_Structure_19::prop, Tpi_LF_Union::prop, Tpi_LF_Enum::prop, rz_return_val_if_fail, and rz_warn_if_reached.

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

skip_padding()

static void skip_padding ( RzBuffer *  buf, ut16  len, ut16 *  read_len, bool  has_length  )

static

Definition at line 714 of file tpi.c.

                                                                                   {
    while (*read_len < len) {
        ut8 byt;
        if (!rz_buf_read8(buf, &byt)) {
            break;
        }
        if (has_length && ((byt & 0xf0) == 0xf0 || byt == 0)) {
            *read_len += 1;
        } else if ((byt & 0xf0) == 0xf0) {
            *read_len += 1;
        } else {
            rz_buf_seek(buf, -1, RZ_BUF_CUR);
            break;
        }
    }
}

References len, RZ_BUF_CUR, rz_buf_read8(), and rz_buf_seek().

Referenced by parse_type_arglist(), parse_type_array(), parse_type_bclass(), parse_type_bitfield(), parse_type_enum(), parse_type_enumerate(), parse_type_index(), parse_type_member(), parse_type_method(), parse_type_methodlist(), parse_type_mfunction(), parse_type_modifier(), parse_type_nesttype(), parse_type_onemethod(), parse_type_pointer(), parse_type_procedure(), parse_type_staticmember(), parse_type_struct(), parse_type_struct_19(), parse_type_union(), parse_type_vbclass(), and parse_type_vtshape().

tpi_type_node_cmp()

int tpi_type_node_cmp	(	const void *	incoming,
		const RBNode *	in_tree,
		void *	user
	)

Definition at line 19 of file tpi.c.

                                                                               {
    ut32 ia = *(ut32 *)incoming;
    ut32 ta = container_of(in_tree, const RzPdbTpiType, rb)->type_index;
    if (ia < ta) {
        return -1;
    } else if (ia > ta) {
        return 1;
    }
    return 0;
}

References container_of.

Referenced by parse_simple_type(), parse_tpi_stream(), and rz_bin_pdb_get_type_by_index().