type.c File Reference

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

Go to the source code of this file.

Classes
struct	PrettyHelperBufs

Functions
static void	types_ht_free (HtPPKv *kv)
static void	formats_ht_free (HtPPKv *kv)
static void	callables_ht_free (HtPPKv *kv)
RZ_API RzTypeDB *	rz_type_db_new ()
	Creates a new instance of the RzTypeDB. More...
RZ_API void	rz_type_db_free (RzTypeDB *typedb)
	Frees the instance of the RzTypeDB. More...
RZ_API void	rz_type_db_purge (RzTypeDB *typedb)
	Purges the instance of the RzTypeDB. More...
RZ_API void	rz_type_db_format_purge (RzTypeDB *typedb)
	Purges formats in the instance of the RzTypeDB. More...
static void	set_default_type (RzTypeTarget *target, int bits)
RZ_API void	rz_type_db_set_bits (RzTypeDB *typedb, int bits)
	Set the RzType target architecture bits. More...
RZ_API void	rz_type_db_set_address_bits (RzTypeDB *typedb, int addr_bits)
	Set the RzType target adress size. More...
RZ_API void	rz_type_db_set_os (RzTypeDB *typedb, const char *os)
	Set the RzType target architecture operating system. More...
RZ_API void	rz_type_db_set_cpu (RzTypeDB *typedb, const char *cpu)
	Set the RzType target architecture CPU. More...
RZ_API void	rz_type_db_set_endian (RzTypeDB *typedb, bool big_endian)
	Set the RzType target architecture CPU. More...
RZ_API ut8	rz_type_db_pointer_size (const RzTypeDB *typedb)
	Returns the pointer size for the current RzTypeDB target set. More...
RZ_API bool	rz_type_db_del (RzTypeDB *typedb, RZ_NONNULL const char *name)
	Removes the type from the database. More...
RZ_API void	rz_type_db_init (RzTypeDB *typedb, const char *types_dir, const char *arch, int bits, const char *os)
	Initializes the types database for specified arch, bits, OS. More...
RZ_API void	rz_type_db_reload (RzTypeDB *typedb, const char *types_dir)
	Re-initializes the types database for current target. More...
RZ_API RZ_OWN RzList *	rz_type_db_enum_names (RzTypeDB *typedb)
	Returns the list of all enum names. More...
RZ_API RZ_OWN RzList *	rz_type_db_union_names (RzTypeDB *typedb)
	Returns the list of all union names. More...
RZ_API RZ_OWN RzList *	rz_type_db_struct_names (RzTypeDB *typedb)
	Returns the list of all struct names. More...
RZ_API RZ_OWN RzList *	rz_type_db_typedef_names (RzTypeDB *typedb)
	Returns the list of all typedef (type aliases) names. More...
RZ_API RZ_OWN RzList *	rz_type_db_all (RzTypeDB *typedb)
	Returns the list of all type names. More...
RZ_API bool	rz_type_exists (RzTypeDB *typedb, RZ_NONNULL const char *name)
	Checks if the type exists in the Type database. More...
RZ_API int	rz_type_kind (RzTypeDB *typedb, RZ_NONNULL const char *name)
	Returns the kind (RzBaseTypeKind) of the type. More...
RZ_API RzBaseType *	rz_type_db_get_enum (const RzTypeDB *typedb, RZ_NONNULL const char *name)
	Returns the enum base type matching the specified name. More...
RZ_API RZ_BORROW const char *	rz_type_db_enum_member_by_val (const RzTypeDB *typedb, RZ_NONNULL const char *name, ut64 val)
	Returns the enum case name matching the cpecified value. More...
RZ_API int	rz_type_db_enum_member_by_name (const RzTypeDB *typedb, RZ_NONNULL const char *name, const char *member)
	Returns the enum case value matched by the enum case name. More...
RZ_API RZ_OWN RzList *	rz_type_db_find_enums_by_val (const RzTypeDB *typedb, ut64 val)
	Returns all enums and cases name matching the specified value. More...
RZ_API RZ_OWN char *	rz_type_db_enum_get_bitfield (const RzTypeDB *typedb, RZ_NONNULL const char *name, ut64 val)
	Returns all matching bitfields as an OR mask given the resulting value. More...
RZ_API RzBaseType *	rz_type_db_get_union (const RzTypeDB *typedb, RZ_NONNULL const char *name)
	Returns the union base type matching the specified name. More...
RZ_API RzBaseType *	rz_type_db_get_struct (const RzTypeDB *typedb, RZ_NONNULL const char *name)
	returns the struct base type matching the specified name More...
RZ_API RzBaseType *	rz_type_db_get_typedef (const RzTypeDB *typedb, RZ_NONNULL const char *name)
	Returns the typedef base type matching the specified name. More...
RZ_API ut64	rz_type_db_atomic_bitsize (const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype)
	Returns the atomic type size in bits (target dependent) More...
RZ_API ut64	rz_type_db_enum_bitsize (const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype)
	Returns the enum type size in bits (target dependent) More...
RZ_API ut64	rz_type_db_struct_bitsize (const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype)
	Returns the struct type size in bits (target dependent) More...
RZ_API ut64	rz_type_db_union_bitsize (const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype)
	Returns the union type size in bits (target dependent) More...
RZ_API ut64	rz_type_db_typedef_bitsize (const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype)
	Returns the typedef type size in bits (target dependent) More...
RZ_API ut64	rz_type_db_base_get_bitsize (const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype)
	Returns the base type size in bits (target dependent) More...
RZ_API ut64	rz_type_db_get_bitsize (const RzTypeDB *typedb, RZ_NONNULL RzType *type)
	Returns the type size in bits (target dependent) More...
RZ_API RZ_OWN char *	rz_type_as_string (const RzTypeDB *typedb, RZ_NONNULL const RzType *type)
	Returns the type C representation. More...
RZ_API RZ_OWN char *	rz_type_declaration_as_string (const RzTypeDB *typedb, RZ_NONNULL const RzType *type)
	Returns the type C declaration representation. More...
RZ_API RZ_OWN char *	rz_type_identifier_declaration_as_string (const RzTypeDB *typedb, RZ_NONNULL const RzType *type, RZ_NONNULL const char *identifier)
	Returns the type C representation with identifier. More...
static bool	type_decl_as_pretty_string (const RzTypeDB *typedb, const RzType *type, HtPP *used_types, struct PrettyHelperBufs phbuf, bool *self_ref, char **self_ref_typename, bool zero_vla, bool print_anon, bool show_typedefs)
static char *	type_as_pretty_string (const RzTypeDB *typedb, const RzType *type, const char *identifier, HtPP *used_types, unsigned int opts, int unfold_level, int indent_level)
RZ_API RZ_OWN char *	rz_type_as_pretty_string (const RzTypeDB *typedb, RZ_NONNULL const RzType *type, RZ_NULLABLE const char *identifier, unsigned int opts, int unfold_level)
	Return a string contining the type pretty printed according to the options provided. More...
RZ_API RZ_BORROW const char *	rz_type_identifier (RZ_NONNULL const RzType *type)
	Returns the type C identifier. More...
RZ_API RZ_OWN RzType *	rz_type_clone (RZ_BORROW RZ_NONNULL const RzType *type)
	Creates an exact clone of the RzType. More...
RZ_API bool	rz_types_equal (RZ_NONNULL const RzType *type1, RZ_NONNULL const RzType *type2)
	Checks if two types are identical. More...
RZ_API RZ_BORROW RzBaseType *	rz_type_get_base_type (const RzTypeDB *typedb, RZ_NONNULL const RzType *type)
	Returns the RzBaseType for the chosen RzType. More...
RZ_API void	rz_type_free (RZ_NULLABLE RzType *type)
	Frees the RzType. More...
RZ_API bool	rz_type_db_edit_base_type (RzTypeDB *typedb, RZ_NONNULL const char *name, RZ_NONNULL const char *typestr)
	Edits the existing base type given the new C code. More...

Function Documentation

callables_ht_free()

static void callables_ht_free ( HtPPKv *  kv )

static

Definition at line 22 of file type.c.

                                          {
    free(kv->key);
    rz_type_callable_free(kv->value);
}

References free(), and rz_type_callable_free().

Referenced by rz_type_db_new(), and rz_type_db_purge().

formats_ht_free()

static void formats_ht_free ( HtPPKv *  kv )

static

Definition at line 17 of file type.c.

                                        {
    free(kv->key);
    free(kv->value);
}

References free().

Referenced by rz_type_db_format_purge(), and rz_type_db_new().

rz_type_as_pretty_string()

RZ_API RZ_OWN char* rz_type_as_pretty_string	(	const RzTypeDB *	typedb,
		RZ_NONNULL const RzType *	type,
		RZ_NULLABLE const char *	identifier,
		unsigned int	opts,
		int	unfold_level
	)

Return a string contining the type pretty printed according to the options provided.

Parameters

typedb	typedb for the current analysis
type	type to be pretty printed
identifier	name of the variable of the given type (RZ_NULLABLE)
opts	options for pretty printing (see RzTypePrintOpts)
unfold_level	level of unfolding to do in case of nested structures/unions (any negative number means maximum unfolding, i.e. INT32_MAX. 0 means no unfolding, just the typename and identifier, if any)

Returns

char* string in pretty printed form

Definition at line 1130 of file type.c.

                                                                                                                                                                             {
    rz_return_val_if_fail(typedb && type, NULL);
 
    if (unfold_level < 0) { // any negative number means maximum unfolding
        unfold_level = INT32_MAX;
    }
    HtPP *used_types = ht_pp_new0(); // use a hash table to keep track of unfolded types
    if (!used_types) {
        RZ_LOG_ERROR("Failed to create hashtable while pretty printing types")
        return NULL;
    }
    char *pretty_type = type_as_pretty_string(typedb, type, identifier, used_types, opts, unfold_level, 0);
    ht_pp_free(used_types);
    return pretty_type;
}

References INT32_MAX, NULL, RZ_LOG_ERROR, rz_return_val_if_fail, type, and type_as_pretty_string().

Referenced by rz_type_as_string(), rz_type_db_base_type_as_pretty_string(), rz_type_db_base_type_as_string(), rz_type_declaration_as_string(), and rz_type_identifier_declaration_as_string().

rz_type_as_string()

RZ_API RZ_OWN char* rz_type_as_string	(	const RzTypeDB *	typedb,
		RZ_NONNULL const RzType *	type
	)

Returns the type C representation.

Parameters

typedb	Types Database instance
type	RzType type

Definition at line 817 of file type.c.

                                                                                             {
    rz_return_val_if_fail(typedb && type, NULL);
 
    return rz_type_as_pretty_string(typedb, type, NULL, RZ_TYPE_PRINT_ZERO_VLA | RZ_TYPE_PRINT_NO_END_SEMICOLON | RZ_TYPE_PRINT_ANONYMOUS, 0);
}

References NULL, rz_return_val_if_fail, rz_type_as_pretty_string(), RZ_TYPE_PRINT_ANONYMOUS, RZ_TYPE_PRINT_NO_END_SEMICOLON, RZ_TYPE_PRINT_ZERO_VLA, and type.

Referenced by callable_as_string(), core_analysis_var_list_show(), ds_print_calls_hints(), ds_print_esil_analysis(), ds_show_functions(), ds_show_functions_argvar(), pdb_types_print_json(), print_fcn_arg(), rz_analysis_fcn_format_sig(), rz_analysis_function_get_json(), rz_analysis_function_vars_stackframe_handler(), rz_analysis_var_global_list_show(), rz_core_analysis_function_signature(), rz_core_types_function_print(), rz_core_types_link_print(), rz_core_types_struct_print(), rz_core_types_typedef_print(), rz_core_types_union_print(), rz_serialize_analysis_global_var_save(), rz_serialize_analysis_var_save(), save_callable(), save_struct(), save_typedef(), save_typelink(), save_union(), set_offset_hint(), type_decl_as_pretty_string(), type_match(), types_xrefs_function(), types_xrefs_graph(), types_xrefs_summary(), and var_variables_show().

rz_type_clone()

RZ_API RZ_OWN RzType* rz_type_clone

(

RZ_BORROW RZ_NONNULL const RzType *

type

)

Creates an exact clone of the RzType.

Parameters

type	RzType pointer

Definition at line 1181 of file type.c.

                                                                             {
    rz_return_val_if_fail(type, NULL);
    RzType *newtype = RZ_NEW0(RzType);
    if (!newtype) {
        return NULL;
    }
    switch (type->kind) {
    case RZ_TYPE_KIND_IDENTIFIER:
        newtype->kind = type->kind;
        newtype->identifier.kind = type->identifier.kind;
        newtype->identifier.is_const = type->identifier.is_const;
        newtype->identifier.name = strdup(type->identifier.name);
        break;
    case RZ_TYPE_KIND_ARRAY:
        newtype->kind = RZ_TYPE_KIND_ARRAY;
        newtype->array.count = type->array.count;
        newtype->array.type = rz_type_clone(type->array.type);
        break;
    case RZ_TYPE_KIND_POINTER:
        newtype->kind = RZ_TYPE_KIND_POINTER;
        newtype->pointer.is_const = type->pointer.is_const;
        newtype->pointer.type = rz_type_clone(type->pointer.type);
        break;
    case RZ_TYPE_KIND_CALLABLE:
        newtype->kind = RZ_TYPE_KIND_CALLABLE;
        newtype->callable = rz_type_callable_clone(type->callable);
        break;
    }
    return newtype;
}

References rz_type_t::array, rz_type_t::callable, rz_type_t::identifier, rz_type_t::kind, NULL, rz_type_t::pointer, RZ_NEW0, rz_return_val_if_fail, rz_type_callable_clone(), RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_CALLABLE, RZ_TYPE_KIND_IDENTIFIER, RZ_TYPE_KIND_POINTER, strdup(), and type.

Referenced by function_argument_type_derive(), parse_enum(), parse_structure(), parse_type_nest(), parse_type_string_cached(), parse_union(), rz_analysis_fcn_vars_add_types(), rz_analysis_function_derive_args(), rz_analysis_function_derive_return_type(), rz_analysis_function_set_type(), rz_type_callable_arg_clone(), rz_type_callable_clone(), var_type_clone_or_default_type(), and var_type_set().

rz_type_db_all()

RZ_API RZ_OWN RzList* rz_type_db_all

(

RzTypeDB *

typedb

)

Returns the list of all type names.

Parameters

typedb

Types Database instance

Definition at line 441 of file type.c.

                                                         {
    rz_return_val_if_fail(typedb, NULL);
    RzList *types = rz_type_db_get_base_types(typedb);
    RzList *result = rz_list_new();
    RzListIter *iter;
    RzBaseType *t;
    rz_list_foreach (types, iter, t) {
        rz_list_append(result, t->name);
    }
    rz_list_free(types);
    return result;
}

References rz_base_type_t::name, NULL, rz_list_append(), rz_list_free(), rz_list_new(), rz_return_val_if_fail, rz_type_db_get_base_types(), and types.

Referenced by autocmplt_cmd_arg_any_type().

rz_type_db_atomic_bitsize()

RZ_API ut64 rz_type_db_atomic_bitsize	(	const RzTypeDB *	typedb,
		RZ_NONNULL RzBaseType *	btype
	)

Returns the atomic type size in bits (target dependent)

Parameters

typedb	Types Database instance
btype	The base type

Definition at line 684 of file type.c.

                                                                                            {
    rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_ATOMIC, 0);
    return btype->size;
}

References RZ_BASE_TYPE_KIND_ATOMIC, and rz_return_val_if_fail.

Referenced by rz_type_db_base_get_bitsize(), and rz_type_db_get_bitsize().

rz_type_db_base_get_bitsize()

RZ_API ut64 rz_type_db_base_get_bitsize	(	const RzTypeDB *	typedb,
		RZ_NONNULL RzBaseType *	btype
	)

Returns the base type size in bits (target dependent)

Parameters

typedb	Types Database instance
btype	The base type

Definition at line 755 of file type.c.

                                                                                              {
    rz_return_val_if_fail(typedb && btype, 0);
    if (btype->kind == RZ_BASE_TYPE_KIND_ENUM) {
        return rz_type_db_enum_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_STRUCT) {
        return rz_type_db_struct_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_UNION) {
        return rz_type_db_union_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_ATOMIC) {
        return rz_type_db_atomic_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF) {
        return rz_type_db_typedef_bitsize(typedb, btype);
    }
    // Should not happen
    rz_warn_if_reached();
    return 0;
}

References RZ_BASE_TYPE_KIND_ATOMIC, RZ_BASE_TYPE_KIND_ENUM, RZ_BASE_TYPE_KIND_STRUCT, RZ_BASE_TYPE_KIND_TYPEDEF, RZ_BASE_TYPE_KIND_UNION, rz_return_val_if_fail, rz_type_db_atomic_bitsize(), rz_type_db_enum_bitsize(), rz_type_db_struct_bitsize(), rz_type_db_typedef_bitsize(), rz_type_db_union_bitsize(), and rz_warn_if_reached.

Referenced by rz_type_integral_set_sign().

rz_type_db_del()

RZ_API bool rz_type_db_del	(	RzTypeDB *	typedb,
		RZ_NONNULL const char *	name
	)

Removes the type from the database.

Can remove either RzBaseType or RzCallable type

Parameters

typedb	RzTypeDB instance
name	RzBaseType or RzCallable type name

Definition at line 223 of file type.c.

                                                                          {
    rz_return_val_if_fail(typedb && name, false);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        if (!rz_type_func_exist(typedb, name)) {
            eprintf("Unrecognized type \"%s\"\n", name);
            return false;
        }
        rz_type_func_delete(typedb, name);
        return true;
    }
    rz_type_db_delete_base_type(typedb, btype);
    return true;
}

References eprintf, rz_return_val_if_fail, rz_type_db_delete_base_type(), rz_type_db_get_base_type(), rz_type_func_delete(), and rz_type_func_exist().

Referenced by rz_type_del_handler().

rz_type_db_edit_base_type()

RZ_API bool rz_type_db_edit_base_type	(	RzTypeDB *	typedb,
		RZ_NONNULL const char *	name,
		RZ_NONNULL const char *	typestr
	)

Edits the existing base type given the new C code.

Searches the base type in the types database given the name. If it exists - parses the typestr as the new C type. If there is any error during the parsing it restores the original type in the database.

Parameters

typedb	Type Database instance
name	Name of the base type
typestr	C string of the new definition of the type

Definition at line 1305 of file type.c.

                                                                                                                     {
    rz_return_val_if_fail(name && typestr, false);
    RzBaseType *t = rz_type_db_get_compound_type(typedb, name);
    if (!t) {
        return false;
    }
    // Remove the original type first
    // but do not free them
    void *freefn = (void *)typedb->types->opt.freefn;
    typedb->types->opt.freefn = NULL;
    ht_pp_delete(typedb->types, t->name);
    typedb->types->opt.freefn = freefn;
    char *error_msg = NULL;
    int result = rz_type_parse_string_stateless(typedb->parser, typestr, &error_msg);
    if (result) {
        if (error_msg) {
            RZ_LOG_ERROR("%s\n", error_msg);
        }
        free(error_msg);
        // There is an error during the parsing thus we restore the old type
        // We insert the type back
        ht_pp_insert(typedb->types, t->name, t);
        return false;
    }
    // Free now unnecessary old base type
    rz_type_base_type_free(t);
    return true;
}

References free(), freefn(), rz_base_type_t::name, NULL, rz_type_db_t::parser, RZ_LOG_ERROR, rz_return_val_if_fail, rz_type_base_type_free(), rz_type_db_get_compound_type(), rz_type_parse_string_stateless(), and rz_type_db_t::types.

Referenced by rz_types_open_editor().

rz_type_db_enum_bitsize()

RZ_API ut64 rz_type_db_enum_bitsize	(	const RzTypeDB *	typedb,
		RZ_NONNULL RzBaseType *	btype
	)

Returns the enum type size in bits (target dependent)

Parameters

typedb	Types Database instance
btype	The base type

Definition at line 695 of file type.c.

                                                                                          {
    rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_ENUM, 0);
    // FIXME: Need a proper way to determine size of enum
    return 32;
}

References RZ_BASE_TYPE_KIND_ENUM, and rz_return_val_if_fail.

Referenced by rz_type_db_base_get_bitsize(), and rz_type_db_get_bitsize().

rz_type_db_enum_get_bitfield()

RZ_API RZ_OWN char* rz_type_db_enum_get_bitfield	(	const RzTypeDB *	typedb,
		RZ_NONNULL const char *	name,
		ut64	val
	)

Returns all matching bitfields as an OR mask given the resulting value.

Parameters

typedb	Types Database instance
name	The name of the bitfield enum
val	The value to search for

Definition at line 584 of file type.c.

                                                                                                                {
    rz_return_val_if_fail(typedb && name, NULL);
    char *res = NULL;
    int i;
    bool isFirst = true;
 
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return NULL;
    }
    if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
        return NULL;
    }
    char *ret = rz_str_newf("0x%08" PFMT64x " : ", val);
    for (i = 0; i < 32; i++) {
        ut32 n = 1ULL << i;
        if (!(val & n)) {
            continue;
        }
        RzTypeEnumCase *cas;
        rz_vector_foreach(&btype->enum_data.cases, cas) {
            if (cas->val == n) {
                res = cas->name;
                break;
            }
        }
        if (isFirst) {
            isFirst = false;
        } else {
            ret = rz_str_append(ret, " | ");
        }
        if (res) {
            ret = rz_str_append(ret, res);
        } else {
            ret = rz_str_appendf(ret, "0x%x", n);
        }
    }
    return ret;
}

References rz_base_type_enum_t::cases, rz_base_type_t::enum_data, i, rz_base_type_t::kind, n, rz_type_enum_case_t::name, NULL, PFMT64x, RZ_BASE_TYPE_KIND_ENUM, rz_return_val_if_fail, rz_str_append(), rz_str_appendf(), rz_str_newf(), rz_type_db_get_base_type(), rz_vector_foreach, val, and rz_type_enum_case_t::val.

Referenced by rz_type_format_bitfield().

rz_type_db_enum_member_by_name()

RZ_API int rz_type_db_enum_member_by_name	(	const RzTypeDB *	typedb,
		RZ_NONNULL const char *	name,
		const char *	member
	)

Returns the enum case value matched by the enum case name.

Parameters

typedb	Types Database instance
name	The name of the enum to search in
member	The enum case name to search for

Definition at line 533 of file type.c.

                                                                                                                   {
    rz_return_val_if_fail(typedb && name, -1);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return -1;
    }
    if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
        return -1;
    }
    RzTypeEnumCase *cas;
    int result = -1;
    rz_vector_foreach(&btype->enum_data.cases, cas) {
        if (!strcmp(cas->name, member)) {
            result = cas->val;
            break;
        }
    }
    return result;
}

References rz_base_type_enum_t::cases, rz_base_type_t::enum_data, rz_base_type_t::kind, rz_type_enum_case_t::name, RZ_BASE_TYPE_KIND_ENUM, rz_return_val_if_fail, rz_type_db_get_base_type(), rz_vector_foreach, and rz_type_enum_case_t::val.

Referenced by rz_type_enum_bitfield_handler().

rz_type_db_enum_member_by_val()

RZ_API RZ_BORROW const char* rz_type_db_enum_member_by_val	(	const RzTypeDB *	typedb,
		RZ_NONNULL const char *	name,
		ut64	val
	)

Returns the enum case name matching the cpecified value.

Parameters

typedb	Types Database instance
name	The name of the enum to search in
val	The value to search for

Definition at line 508 of file type.c.

                                                                                                                          {
    rz_return_val_if_fail(typedb && name, NULL);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return NULL;
    }
    if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
        return NULL;
    }
    RzTypeEnumCase *cas;
    rz_vector_foreach(&btype->enum_data.cases, cas) {
        if (cas->val == val) {
            return cas->name;
        }
    }
    return NULL;
}

References rz_base_type_enum_t::cases, rz_base_type_t::enum_data, rz_base_type_t::kind, rz_type_enum_case_t::name, NULL, RZ_BASE_TYPE_KIND_ENUM, rz_return_val_if_fail, rz_type_db_get_base_type(), rz_vector_foreach, val, and rz_type_enum_case_t::val.

Referenced by ds_show_flags(), rz_type_format_enum(), and types_enum_member_find().

rz_type_db_enum_names()

RZ_API RZ_OWN RzList* rz_type_db_enum_names

(

RzTypeDB *

typedb

)

Returns the list of all enum names.

Parameters

typedb

Types Database instance

Definition at line 369 of file type.c.

                                                                {
    rz_return_val_if_fail(typedb, NULL);
    RzList *enums = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_ENUM);
    RzList *result = rz_list_new();
    RzListIter *iter;
    RzBaseType *e;
    rz_list_foreach (enums, iter, e) {
        rz_list_append(result, e->name);
    }
    rz_list_free(enums);
    return result;
}

References e, NULL, RZ_BASE_TYPE_KIND_ENUM, rz_list_append(), rz_list_free(), rz_list_new(), rz_return_val_if_fail, and rz_type_db_get_base_types_of_kind().

Referenced by autocmplt_cmd_arg_enum_type().

rz_type_db_find_enums_by_val()

RZ_API RZ_OWN RzList* rz_type_db_find_enums_by_val	(	const RzTypeDB *	typedb,
		ut64	val
	)

Returns all enums and cases name matching the specified value.

Parameters

typedb	Types Database instance
val	The value to search for

Definition at line 559 of file type.c.

                                                                                       {
    rz_return_val_if_fail(typedb, NULL);
    RzList *enums = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_ENUM);
    RzList *result = rz_list_newf(free);
    RzListIter *iter;
    RzBaseType *e;
    rz_list_foreach (enums, iter, e) {
        RzTypeEnumCase *cas;
        rz_vector_foreach(&e->enum_data.cases, cas) {
            if (cas->val == val) {
                rz_list_append(result, rz_str_newf("%s.%s", e->name, cas->name));
            }
        }
    }
    rz_list_free(enums);
    return result;
}

References e, free(), rz_type_enum_case_t::name, NULL, RZ_BASE_TYPE_KIND_ENUM, rz_list_append(), rz_list_free(), rz_list_newf(), rz_return_val_if_fail, rz_str_newf(), rz_type_db_get_base_types_of_kind(), rz_vector_foreach, val, and rz_type_enum_case_t::val.

Referenced by types_enum_member_find_all().

rz_type_db_format_purge()

RZ_API void rz_type_db_format_purge

(

RzTypeDB *

typedb

)

Purges formats in the instance of the RzTypeDB.

Definition at line 108 of file type.c.

                                                      {
    ht_pp_free(typedb->formats);
    typedb->formats = ht_pp_new(NULL, formats_ht_free, NULL);
}

References rz_type_db_t::formats, formats_ht_free(), and NULL.

Referenced by cmd_print_format().

rz_type_db_free()

RZ_API void rz_type_db_free

(

RzTypeDB *

typedb

)

Frees the instance of the RzTypeDB.

Destroys hashtables for RzBaseType, RzCallable, type formats.

Definition at line 79 of file type.c.

                                              {
    rz_type_parser_free(typedb->parser);
    ht_pp_free(typedb->callables);
    ht_pp_free(typedb->types);
    ht_pp_free(typedb->formats);
    free((void *)typedb->target->default_type);
    free(typedb->target->os);
    free(typedb->target->cpu);
    free(typedb->target);
    free(typedb);
}

References rz_type_db_t::callables, rz_type_target_t::cpu, rz_type_target_t::default_type, rz_type_db_t::formats, free(), rz_type_target_t::os, rz_type_db_t::parser, rz_type_parser_free(), rz_type_db_t::target, and rz_type_db_t::types.

Referenced by rz_analysis_free().

rz_type_db_get_bitsize()

RZ_API ut64 rz_type_db_get_bitsize	(	const RzTypeDB *	typedb,
		RZ_NONNULL RzType *	type
	)

Returns the type size in bits (target dependent)

Parameters

typedb	Types Database instance
type	The type

Definition at line 779 of file type.c.

                                                                                    {
    rz_return_val_if_fail(typedb && type, 0);
    // Detect if the pointer and return the corresponding size
    if (type->kind == RZ_TYPE_KIND_POINTER || type->kind == RZ_TYPE_KIND_CALLABLE) {
        // Note, that function types (RzCallable) are in fact pointers too
        return rz_type_db_pointer_size(typedb);
        // Detect if the pointer is array, then return the bitsize of the base type
        // multiplied to the array size
    } else if (type->kind == RZ_TYPE_KIND_ARRAY) {
        return type->array.count * rz_type_db_get_bitsize(typedb, type->array.type);
    }
    // The rest of the logic is for the normal, identifier types
    RzBaseType *btype = rz_type_db_get_base_type(typedb, type->identifier.name);
    if (!btype) {
        return 0;
    }
    if (btype->kind == RZ_BASE_TYPE_KIND_ENUM && type->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_ENUM) {
        return rz_type_db_enum_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_STRUCT && type->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_STRUCT) {
        return rz_type_db_struct_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_UNION && type->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_UNION) {
        return rz_type_db_union_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_ATOMIC) {
        return rz_type_db_atomic_bitsize(typedb, btype);
    } else if (btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF) {
        return rz_type_db_typedef_bitsize(typedb, btype);
    }
    // Should not happen
    rz_warn_if_reached();
    return 0;
}

References rz_base_type_t::kind, RZ_BASE_TYPE_KIND_ATOMIC, RZ_BASE_TYPE_KIND_ENUM, RZ_BASE_TYPE_KIND_STRUCT, RZ_BASE_TYPE_KIND_TYPEDEF, RZ_BASE_TYPE_KIND_UNION, rz_return_val_if_fail, rz_type_db_atomic_bitsize(), rz_type_db_enum_bitsize(), rz_type_db_get_base_type(), rz_type_db_pointer_size(), rz_type_db_struct_bitsize(), rz_type_db_typedef_bitsize(), rz_type_db_union_bitsize(), RZ_TYPE_IDENTIFIER_KIND_ENUM, RZ_TYPE_IDENTIFIER_KIND_STRUCT, RZ_TYPE_IDENTIFIER_KIND_UNION, RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_CALLABLE, RZ_TYPE_KIND_POINTER, rz_warn_if_reached, and type.

Referenced by extract_arg(), parse_enum(), path_walker(), rz_analysis_function_set_type(), rz_analysis_var_global_add(), rz_analysis_var_global_get_byaddr_in(), rz_analysis_var_global_set_type(), rz_analysis_var_resolve_overlaps(), rz_core_print_disasm(), rz_core_types_struct_print(), rz_core_types_union_print(), rz_type_db_struct_bitsize(), rz_type_db_struct_member_packed_offset(), rz_type_db_typedef_bitsize(), rz_type_db_union_bitsize(), rz_type_path_by_offset(), set_fcn_args_info(), structured_member_walker(), and var_add_structure_fields_to_list().

rz_type_db_get_enum()

RZ_API RzBaseType* rz_type_db_get_enum	(	const RzTypeDB *	typedb,
		RZ_NONNULL const char *	name
	)

Returns the enum base type matching the specified name.

Parameters

typedb	Types Database instance
name	The name of the enum to match against

Definition at line 489 of file type.c.

                                                                                            {
    rz_return_val_if_fail(typedb && name, NULL);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return NULL;
    }
    if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
        return NULL;
    }
    return btype;
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_ENUM, rz_return_val_if_fail, and rz_type_db_get_base_type().

Referenced by rz_analysis_function_blocks_switch_type_handler(), rz_type_enum_c_handler(), rz_type_enum_c_nl_handler(), and rz_type_list_enum_handler().

rz_type_db_get_struct()

RZ_API RzBaseType* rz_type_db_get_struct	(	const RzTypeDB *	typedb,
		RZ_NONNULL const char *	name
	)

returns the struct base type matching the specified name

Parameters

typedb	types database instance
name	the name of the struct to match against

Definition at line 648 of file type.c.

                                                                                              {
    rz_return_val_if_fail(typedb && name, NULL);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return NULL;
    }
    if (btype->kind != RZ_BASE_TYPE_KIND_STRUCT) {
        return NULL;
    }
    return btype;
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_STRUCT, rz_return_val_if_fail, and rz_type_db_get_base_type().

Referenced by rz_type_list_structure_handler(), rz_type_structure_c_handler(), and rz_type_structure_c_nl_handler().

rz_type_db_get_typedef()

RZ_API RzBaseType* rz_type_db_get_typedef	(	const RzTypeDB *	typedb,
		RZ_NONNULL const char *	name
	)

Returns the typedef base type matching the specified name.

Parameters

typedb	Types Database instance
name	The name of the typedef to match against

Definition at line 666 of file type.c.

                                                                                               {
    rz_return_val_if_fail(typedb && name, NULL);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return NULL;
    }
    if (btype->kind != RZ_BASE_TYPE_KIND_TYPEDEF) {
        return NULL;
    }
    return btype;
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_TYPEDEF, rz_return_val_if_fail, and rz_type_db_get_base_type().

Referenced by rz_type_list_typedef_handler(), and rz_type_typedef_c_handler().

rz_type_db_get_union()

RZ_API RzBaseType* rz_type_db_get_union	(	const RzTypeDB *	typedb,
		RZ_NONNULL const char *	name
	)

Returns the union base type matching the specified name.

Parameters

typedb	Types Database instance
name	The name of the union to match against

Definition at line 630 of file type.c.

                                                                                             {
    rz_return_val_if_fail(typedb && name, NULL);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return NULL;
    }
    if (btype->kind != RZ_BASE_TYPE_KIND_UNION) {
        return NULL;
    }
    return btype;
}

References rz_base_type_t::kind, NULL, RZ_BASE_TYPE_KIND_UNION, rz_return_val_if_fail, and rz_type_db_get_base_type().

Referenced by rz_type_list_union_handler(), rz_type_union_c_handler(), and rz_type_union_c_nl_handler().

rz_type_db_init()

RZ_API void rz_type_db_init	(	RzTypeDB *	typedb,
		const char *	types_dir,
		const char *	arch,
		int	bits,
		const char *	os
	)

Initializes the types database for specified arch, bits, OS.

Loads pre-shipped type libraries for base types and function types. Different architectures, operating systems, bitness affects on what exact types are loaded, also some atomic types sizes are different. In some cases the same type, for example, structure type could have a different layout, depending on the operating system or bitness.

Parameters

typedb	Types Database instance
types_dir	Directory where all type libraries are installed
arch	Architecture of the analysis session
bits	Bitness of the analysis session
os	Operating system of the analysis session

Definition at line 253 of file type.c.

                                                                                                                 {
    rz_return_if_fail(typedb && typedb->types && typedb->formats);
 
    // A workaround to fix loading incorrectly detected MacOS binaries
    if (os && RZ_STR_ISNOTEMPTY(os) && !strcmp(os, "darwin")) {
        os = "macos";
    }
 
    // At first we load the basic types
    // Atomic types
    char *dbpath = rz_file_path_join(types_dir, "types-atomic.sdb");
    if (rz_type_db_load_sdb(typedb, dbpath)) {
        RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
    }
    free(dbpath);
    // C runtime types
    dbpath = rz_file_path_join(types_dir, "types-libc.sdb");
    if (rz_type_db_load_sdb(typedb, dbpath)) {
        RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
    }
    free(dbpath);
 
    // We do not load further if bits are not specified
    if (bits <= 0) {
        return;
    }
 
    // Bits-specific types that are independent from architecture or OS
    char tmp[100];
    dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%d.sdb", bits));
    if (rz_type_db_load_sdb(typedb, dbpath)) {
        RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
    }
    free(dbpath);
 
    // We do not load further if architecture is not specified
    if (!arch) {
        return;
    }
 
    // Architecture-specific types
    dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s.sdb", arch));
    if (rz_type_db_load_sdb(typedb, dbpath)) {
        RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
    }
    free(dbpath);
 
    // Architecture- and bits-specific types
    dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%d.sdb", arch, bits));
    if (rz_type_db_load_sdb(typedb, dbpath)) {
        RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
    }
    free(dbpath);
 
    if (os) {
        // OS-specific types
        dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s.sdb", os));
        if (rz_type_db_load_sdb(typedb, dbpath)) {
            RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
        }
        free(dbpath);
        dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%d.sdb", os, bits));
        if (rz_type_db_load_sdb(typedb, dbpath)) {
            RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
        }
        free(dbpath);
        dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%s.sdb", arch, os));
        if (rz_type_db_load_sdb(typedb, dbpath)) {
            RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
        }
        free(dbpath);
        dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%s-%d.sdb", arch, os, bits));
        if (rz_type_db_load_sdb(typedb, dbpath)) {
            RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
        }
        free(dbpath);
    }
 
    // Then, after all basic types are initialized, we load function types
    // that use loaded previously base types for return and arguments
    dbpath = rz_file_path_join(types_dir, "functions-libc.sdb");
    if (rz_type_db_load_callables_sdb(typedb, dbpath)) {
        RZ_LOG_DEBUG("callable types: loaded \"%s\"\n", dbpath);
    }
    free(dbpath);
    // OS-specific function types
    if (os) {
        dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "functions-%s.sdb", os));
        if (rz_type_db_load_callables_sdb(typedb, dbpath)) {
            RZ_LOG_DEBUG("callable types: loaded \"%s\"\n", dbpath);
        }
        free(dbpath);
    }
}

References arch, bits(), rz_type_db_t::formats, free(), rz_file_path_join(), RZ_LOG_DEBUG, rz_return_if_fail, RZ_STR_ISNOTEMPTY, rz_strf, rz_type_db_load_callables_sdb(), rz_type_db_load_sdb(), autogen_x86imm::tmp, and rz_type_db_t::types.

Referenced by rz_core_analysis_type_init(), and rz_type_db_reload().

rz_type_db_new()

RZ_API RzTypeDB* rz_type_db_new

(

)

Creates a new instance of the RzTypeDB.

Creates the RzTypeDB instance, initializes hashtables for RzBaseType, RzCallable, type formats. Also initializes default "target" (arch, bits, platform) parameters.

Definition at line 34 of file type.c.

                                  {
    RzTypeDB *typedb = RZ_NEW0(RzTypeDB);
    if (!typedb) {
        return NULL;
    }
    typedb->target = RZ_NEW0(RzTypeTarget);
    if (!typedb->target) {
        free(typedb);
        return NULL;
    }
    typedb->target->default_type = strdup("int");
    typedb->types = ht_pp_new(NULL, types_ht_free, NULL);
    if (!typedb->types) {
        goto rz_type_db_new_fail;
    }
    typedb->formats = ht_pp_new(NULL, formats_ht_free, NULL);
    if (!typedb->formats) {
        goto rz_type_db_new_fail;
    }
    typedb->callables = ht_pp_new(NULL, callables_ht_free, NULL);
    if (!typedb->callables) {
        goto rz_type_db_new_fail;
    }
    typedb->parser = rz_type_parser_init(typedb->types, typedb->callables);
    if (!typedb->parser) {
        goto rz_type_db_new_fail;
    }
    rz_io_bind_init(typedb->iob);
    return typedb;
 
rz_type_db_new_fail:
    free((void *)typedb->target->default_type);
    free(typedb->target);
    ht_pp_free(typedb->types);
    ht_pp_free(typedb->formats);
    ht_pp_free(typedb->callables);
    free(typedb);
    return NULL;
}

References rz_type_db_t::callables, callables_ht_free(), rz_type_target_t::default_type, rz_type_db_t::formats, formats_ht_free(), free(), rz_type_db_t::iob, NULL, rz_type_db_t::parser, rz_io_bind_init, RZ_NEW0, rz_type_parser_init(), strdup(), rz_type_db_t::target, rz_type_db_t::types, and types_ht_free().

Referenced by rz_analysis_new().

rz_type_db_pointer_size()

RZ_API ut8 rz_type_db_pointer_size

(

const RzTypeDB *

typedb

)

Returns the pointer size for the current RzTypeDB target set.

Parameters

typedb

RzTypeDB instance

Definition at line 211 of file type.c.

                                                           {
    return typedb->target->addr_bits > 0 ? typedb->target->addr_bits : typedb->target->bits;
}

References rz_type_target_t::addr_bits, rz_type_target_t::bits, and rz_type_db_t::target.

Referenced by rz_type_db_get_bitsize().

rz_type_db_purge()

RZ_API void rz_type_db_purge

(

RzTypeDB *

typedb

)

Purges the instance of the RzTypeDB.

Destroys all loaded base types and callable types.

Definition at line 96 of file type.c.

                                               {
    ht_pp_free(typedb->callables);
    typedb->callables = ht_pp_new(NULL, callables_ht_free, NULL);
    ht_pp_free(typedb->types);
    typedb->types = ht_pp_new(NULL, types_ht_free, NULL);
    rz_type_parser_free(typedb->parser);
    typedb->parser = rz_type_parser_init(typedb->types, typedb->callables);
}

References rz_type_db_t::callables, callables_ht_free(), NULL, rz_type_db_t::parser, rz_type_parser_free(), rz_type_parser_init(), rz_type_db_t::types, and types_ht_free().

Referenced by rz_analysis_purge(), rz_type_db_reload(), and rz_type_del_all_handler().

rz_type_db_reload()

RZ_API void rz_type_db_reload	(	RzTypeDB *	typedb,
		const char *	types_dir
	)

Re-initializes the types database for current target.

Similarly to rz_type_db_init loads pre-shipped type libraries for base types and function types.

Parameters

typedb	Types Database instance
types_dir	Directory where all type libraries are installed

Definition at line 357 of file type.c.

                                                                       {
    rz_type_db_purge(typedb);
    rz_type_db_init(typedb, types_dir, typedb->target->cpu, typedb->target->bits, typedb->target->os);
}

References rz_type_target_t::bits, rz_type_target_t::cpu, rz_type_target_t::os, rz_type_db_init(), rz_type_db_purge(), and rz_type_db_t::target.

Referenced by analysis_set_os(), rz_analysis_set_bits(), and rz_analysis_set_cpu().

rz_type_db_set_address_bits()

RZ_API void rz_type_db_set_address_bits	(	RzTypeDB *	typedb,
		int	addr_bits
	)

Set the RzType target adress size.

Important for calculating some types size, especially pointers's size.

Parameters

typedb	RzTypeDB instance
bits	size of an address in bits. If <= 0, then the value from rz_type_db_set_bits() is used.

Definition at line 161 of file type.c.

                                                                         {
    rz_return_if_fail(typedb);
    typedb->target->addr_bits = addr_bits;
}

References rz_type_target_t::addr_bits, rz_return_if_fail, and rz_type_db_t::target.

Referenced by rz_analysis_set_bits().

rz_type_db_set_bits()

RZ_API void rz_type_db_set_bits	(	RzTypeDB *	typedb,
		int	bits
	)

Set the RzType target architecture bits.

Important for calculating some types size, especially pointers's size.

Parameters

typedb	RzTypeDB instance
bits	Architecture bits to set

Definition at line 145 of file type.c.

                                                            {
    typedb->target->bits = bits;
    // Also set the new default type
    set_default_type(typedb->target, bits);
}

References rz_type_target_t::bits, bits(), set_default_type(), and rz_type_db_t::target.

Referenced by rz_analysis_set_bits().

rz_type_db_set_cpu()

RZ_API void rz_type_db_set_cpu	(	RzTypeDB *	typedb,
		const char *	cpu
	)

Set the RzType target architecture CPU.

Important for calculating some types size, especially pointers's size.

Parameters

typedb	RzTypeDB instance
cpu	Architecture name to set

Definition at line 189 of file type.c.

                                                                  {
    free(typedb->target->cpu);
    typedb->target->cpu = cpu ? strdup(cpu) : NULL;
}

References cpu, rz_type_target_t::cpu, free(), NULL, strdup(), and rz_type_db_t::target.

Referenced by rz_analysis_set_cpu().

rz_type_db_set_endian()

RZ_API void rz_type_db_set_endian	(	RzTypeDB *	typedb,
		bool	big_endian
	)

Set the RzType target architecture CPU.

Important for calculating complex types layout.

Parameters

typedb	RzTypeDB instance
big_endian	True if the big endian, false if the opposite

Definition at line 202 of file type.c.

                                                                     {
    typedb->target->big_endian = big_endian;
}

References rz_type_target_t::big_endian, and rz_type_db_t::target.

Referenced by cb_bigendian(), and rz_analysis_set_big_endian().

rz_type_db_set_os()

RZ_API void rz_type_db_set_os	(	RzTypeDB *	typedb,
		const char *	os
	)

Set the RzType target architecture operating system.

Important for calculating some types size, especially pointers's size.

Parameters

typedb	RzTypeDB instance
os	Operating system name to set

Definition at line 175 of file type.c.

                                                                {
    free(typedb->target->os);
    typedb->target->os = os ? strdup(os) : NULL;
}

References free(), NULL, rz_type_target_t::os, strdup(), and rz_type_db_t::target.

Referenced by analysis_set_os().

rz_type_db_struct_bitsize()

RZ_API ut64 rz_type_db_struct_bitsize	(	const RzTypeDB *	typedb,
		RZ_NONNULL RzBaseType *	btype
	)

Returns the struct type size in bits (target dependent)

Parameters

typedb	Types Database instance
btype	The base type

Definition at line 707 of file type.c.

                                                                                            {
    rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_STRUCT, 0);
    RzTypeStructMember *memb;
    ut64 size = 0;
    rz_vector_foreach(&btype->struct_data.members, memb) {
        size += rz_type_db_get_bitsize(typedb, memb->type);
    }
    return size;
}

References RZ_BASE_TYPE_KIND_STRUCT, rz_return_val_if_fail, rz_type_db_get_bitsize(), rz_vector_foreach, rz_type_struct_member_t::type, and ut64().

Referenced by rz_type_db_base_get_bitsize(), and rz_type_db_get_bitsize().

rz_type_db_struct_names()

RZ_API RZ_OWN RzList* rz_type_db_struct_names

(

RzTypeDB *

typedb

)

Returns the list of all struct names.

Parameters

typedb

Types Database instance

Definition at line 405 of file type.c.

                                                                  {
    rz_return_val_if_fail(typedb, NULL);
    RzList *structs = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_STRUCT);
    RzList *result = rz_list_new();
    RzListIter *iter;
    RzBaseType *s;
    rz_list_foreach (structs, iter, s) {
        rz_list_append(result, s->name);
    }
    rz_list_free(structs);
    return result;
}

References NULL, RZ_BASE_TYPE_KIND_STRUCT, rz_list_append(), rz_list_free(), rz_list_new(), rz_return_val_if_fail, rz_type_db_get_base_types_of_kind(), and s.

Referenced by autocmplt_cmd_arg_struct_type().

rz_type_db_typedef_bitsize()

RZ_API ut64 rz_type_db_typedef_bitsize	(	const RzTypeDB *	typedb,
		RZ_NONNULL RzBaseType *	btype
	)

Returns the typedef type size in bits (target dependent)

Parameters

typedb	Types Database instance
btype	The base type

Definition at line 740 of file type.c.

                                                                                             {
    rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF, 0);
    rz_return_val_if_fail(btype->type, 0);
    if (btype->type->kind == RZ_TYPE_KIND_IDENTIFIER && !strcmp(btype->type->identifier.name, btype->name)) {
        return btype->size;
    }
    return rz_type_db_get_bitsize(typedb, btype->type);
}

References RZ_BASE_TYPE_KIND_TYPEDEF, rz_return_val_if_fail, rz_type_db_get_bitsize(), and RZ_TYPE_KIND_IDENTIFIER.

Referenced by rz_type_db_base_get_bitsize(), and rz_type_db_get_bitsize().

rz_type_db_typedef_names()

RZ_API RZ_OWN RzList* rz_type_db_typedef_names

(

RzTypeDB *

typedb

)

Returns the list of all typedef (type aliases) names.

Parameters

typedb

Types Database instance

Definition at line 423 of file type.c.

                                                                 {
    rz_return_val_if_fail(typedb, NULL);
    RzList *typedefs = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_TYPEDEF);
    RzList *result = rz_list_new();
    RzListIter *iter;
    RzBaseType *t;
    rz_list_foreach (typedefs, iter, t) {
        rz_list_append(result, t->name);
    }
    rz_list_free(typedefs);
    return result;
}

References rz_base_type_t::name, NULL, RZ_BASE_TYPE_KIND_TYPEDEF, rz_list_append(), rz_list_free(), rz_list_new(), rz_return_val_if_fail, and rz_type_db_get_base_types_of_kind().

Referenced by autocmplt_cmd_arg_alias_type().

rz_type_db_union_bitsize()

RZ_API ut64 rz_type_db_union_bitsize	(	const RzTypeDB *	typedb,
		RZ_NONNULL RzBaseType *	btype
	)

Returns the union type size in bits (target dependent)

Parameters

typedb	Types Database instance
btype	The base type

Definition at line 723 of file type.c.

                                                                                           {
    rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_UNION, 0);
    RzTypeUnionMember *memb;
    ut64 size = 0;
    // Union has the size of the maximum size of its elements
    rz_vector_foreach(&btype->union_data.members, memb) {
        size = RZ_MAX(rz_type_db_get_bitsize(typedb, memb->type), size);
    }
    return size;
}

References RZ_BASE_TYPE_KIND_UNION, RZ_MAX, rz_return_val_if_fail, rz_type_db_get_bitsize(), rz_vector_foreach, rz_type_union_member_t::type, and ut64().

Referenced by rz_type_db_base_get_bitsize(), and rz_type_db_get_bitsize().

rz_type_db_union_names()

RZ_API RZ_OWN RzList* rz_type_db_union_names

(

RzTypeDB *

typedb

)

Returns the list of all union names.

Parameters

typedb

Types Database instance

Definition at line 387 of file type.c.

                                                                 {
    rz_return_val_if_fail(typedb, NULL);
    RzList *unions = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_UNION);
    RzList *result = rz_list_new();
    RzListIter *iter;
    RzBaseType *u;
    rz_list_foreach (unions, iter, u) {
        rz_list_append(result, u->name);
    }
    rz_list_free(unions);
    return result;
}

References rz_base_type_t::name, NULL, RZ_BASE_TYPE_KIND_UNION, rz_list_append(), rz_list_free(), rz_list_new(), rz_return_val_if_fail, and rz_type_db_get_base_types_of_kind().

Referenced by autocmplt_cmd_arg_union_type().

rz_type_declaration_as_string()

RZ_API RZ_OWN char* rz_type_declaration_as_string	(	const RzTypeDB *	typedb,
		RZ_NONNULL const RzType *	type
	)

Returns the type C declaration representation.

Parameters

typedb	Types Database instance
type	RzType type

Definition at line 829 of file type.c.

                                                                                                         {
    rz_return_val_if_fail(typedb && type, NULL);
 
    return rz_type_as_pretty_string(typedb, type, NULL, RZ_TYPE_PRINT_ZERO_VLA | RZ_TYPE_PRINT_NO_END_SEMICOLON, 1); // one level unfold
}

References NULL, rz_return_val_if_fail, rz_type_as_pretty_string(), RZ_TYPE_PRINT_NO_END_SEMICOLON, RZ_TYPE_PRINT_ZERO_VLA, and type.

rz_type_exists()

RZ_API bool rz_type_exists	(	RzTypeDB *	typedb,
		RZ_NONNULL const char *	name
	)

Checks if the type exists in the Type database.

Parameters

typedb	Types Database instance
name	Name of the type

Definition at line 462 of file type.c.

                                                                          {
    rz_return_val_if_fail(typedb && name, -1);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    return btype != NULL;
}

References NULL, rz_return_val_if_fail, and rz_type_db_get_base_type().

rz_type_free()

RZ_API void rz_type_free

(

RZ_NULLABLE RzType *

type

)

Frees the RzType.

Doesn't free the underlying RzBaseType, only the RzType wrapper. Same goes for the RzCallable. Both are stored in the corresponding hashtables and should not be touched until deleted explicitly.

Parameters

type	RzType type

Definition at line 1273 of file type.c.

                                                   {
    if (!type) {
        return;
    }
    switch (type->kind) {
    case RZ_TYPE_KIND_IDENTIFIER:
        free(type->identifier.name);
        break;
    case RZ_TYPE_KIND_POINTER:
        rz_type_free(type->pointer.type);
        break;
    case RZ_TYPE_KIND_ARRAY:
        rz_type_free(type->array.type);
        break;
    case RZ_TYPE_KIND_CALLABLE:
        break;
    }
    free(type);
}

References free(), RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_CALLABLE, RZ_TYPE_KIND_IDENTIFIER, RZ_TYPE_KIND_POINTER, and type.

Referenced by c_parser_get_primitive_type(), c_parser_get_typedef(), c_parser_new_enum_naked_type(), c_parser_new_enum_type(), c_parser_new_primitive_type(), c_parser_new_structure_naked_type(), c_parser_new_structure_type(), c_parser_new_typedef(), c_parser_new_typedef_naked_type(), c_parser_new_union_naked_type(), c_parser_new_union_type(), c_parser_new_unspecified_naked_type(), get_callable_type(), parse_sole_type_name(), parse_struct_member(), parse_type_mfunction(), parse_type_pointer(), parse_type_procedure(), parse_union_member(), rz_analysis_dwarf_integrate_functions(), rz_analysis_fcn_vars_add_types(), rz_analysis_function_blocks_switch_type_handler(), rz_analysis_function_set_type(), rz_analysis_function_set_var(), rz_analysis_function_vars_bp_handler(), rz_analysis_function_vars_regs_handler(), rz_analysis_function_vars_sp_handler(), rz_analysis_var_global_free(), rz_analysis_var_global_set_type(), rz_type_array_of_base_type(), rz_type_base_struct_member_free(), rz_type_base_type_free(), rz_type_base_union_member_free(), rz_type_callable_arg_free(), rz_type_callable_free(), rz_type_integral_set_sign(), rz_type_pointer_of_base_type(), type_match(), var_free(), and var_type_set_str().

rz_type_get_base_type()

RZ_API RZ_BORROW RzBaseType* rz_type_get_base_type	(	const RzTypeDB *	typedb,
		RZ_NONNULL const RzType *	type
	)

Returns the RzBaseType for the chosen RzType.

Parameters

typedb	Type Database instance
type	RzType type pointer

Definition at line 1251 of file type.c.

                                                                                                          {
    rz_return_val_if_fail(type, false);
    const char *identifier = rz_type_identifier(type);
    if (!identifier) {
        return NULL;
    }
    RzBaseType *btype = rz_type_db_get_base_type(typedb, identifier);
    if (!btype) {
        return NULL;
    }
    return btype;
}

References NULL, rz_return_val_if_fail, rz_type_db_get_base_type(), rz_type_identifier(), and type.

Referenced by base_type_to_format_unfold().

rz_type_identifier()

RZ_API RZ_BORROW const char* rz_type_identifier

(

RZ_NONNULL const RzType *

type

)

Returns the type C identifier.

In case of the compound types it returns the name of identifier For example, for "char **ptr" it will return "char", for "const int **arr[56][76]" it will return "int"

Parameters

type	RzType type

Definition at line 1155 of file type.c.

                                                                               {
    rz_return_val_if_fail(type, NULL);
 
    switch (type->kind) {
    case RZ_TYPE_KIND_IDENTIFIER: {
        // Here it can be any of the RzBaseType
        return type->identifier.name;
    }
    case RZ_TYPE_KIND_POINTER: {
        return rz_type_identifier(type->pointer.type);
    }
    case RZ_TYPE_KIND_ARRAY: {
        return rz_type_identifier(type->array.type);
        break;
    }
    case RZ_TYPE_KIND_CALLABLE:
        return type->callable->name;
    }
    return NULL;
}

References NULL, rz_return_val_if_fail, RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_CALLABLE, RZ_TYPE_KIND_IDENTIFIER, RZ_TYPE_KIND_POINTER, and type.

Referenced by ds_show_flags(), get_base_type_typeclass(), get_type_typeclass(), parse_typedef_node(), rz_core_print_disasm(), rz_type_get_base_type(), rz_type_integral_set_sign(), type_to_format_pair(), and types_xrefs_all().

rz_type_identifier_declaration_as_string()

RZ_API RZ_OWN char* rz_type_identifier_declaration_as_string	(	const RzTypeDB *	typedb,
		RZ_NONNULL const RzType *	type,
		RZ_NONNULL const char *	identifier
	)

Returns the type C representation with identifier.

Parameters

typedb	Types Database instance
type	RzType type

Definition at line 841 of file type.c.

                                                                                                                                                       {
    rz_return_val_if_fail(typedb && type, NULL);
 
    return rz_type_as_pretty_string(typedb, type, identifier, RZ_TYPE_PRINT_ZERO_VLA | RZ_TYPE_PRINT_NO_END_SEMICOLON | RZ_TYPE_PRINT_UNFOLD_ANON_ONLY_STRICT, 1); // one level unfold (for anonymous only)
}

References NULL, rz_return_val_if_fail, rz_type_as_pretty_string(), RZ_TYPE_PRINT_NO_END_SEMICOLON, RZ_TYPE_PRINT_UNFOLD_ANON_ONLY_STRICT, RZ_TYPE_PRINT_ZERO_VLA, and type.

Referenced by callable_as_string().

rz_type_kind()

RZ_API int rz_type_kind	(	RzTypeDB *	typedb,
		RZ_NONNULL const char *	name
	)

Returns the kind (RzBaseTypeKind) of the type.

Parameters

typedb	Types Database instance
name	Name of the type

Definition at line 474 of file type.c.

                                                                       {
    rz_return_val_if_fail(typedb && name, -1);
    RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
    if (!btype) {
        return -1;
    }
    return btype->kind;
}

References rz_base_type_t::kind, rz_return_val_if_fail, and rz_type_db_get_base_type().

rz_types_equal()

RZ_API bool rz_types_equal	(	RZ_NONNULL const RzType *	type1,
		RZ_NONNULL const RzType *	type2
	)

Checks if two types are identical.

Parameters

type1	RzType pointer
type2	RzType pointer

Definition at line 1218 of file type.c.

                                                                                           {
    rz_return_val_if_fail(type1 && type2, false);
    if (type1->kind != type2->kind) {
        return false;
    }
    switch (type1->kind) {
    case RZ_TYPE_KIND_IDENTIFIER:
        return !strcmp(type1->identifier.name, type2->identifier.name);
    case RZ_TYPE_KIND_POINTER:
        rz_return_val_if_fail(type1->pointer.type && type2->pointer.type, false);
        return rz_types_equal(type1->pointer.type, type2->pointer.type);
    case RZ_TYPE_KIND_ARRAY:
        if (type1->array.count != type2->array.count) {
            return false;
        }
        return rz_types_equal(type1->array.type, type2->array.type);
    case RZ_TYPE_KIND_CALLABLE:
        rz_return_val_if_fail(type1->callable && type2->callable, false);
        rz_return_val_if_fail(type1->callable->name && type2->callable->name, false);
        return !strcmp(type1->callable->name, type2->callable->name);
    default:
        rz_warn_if_reached();
        return false;
    }
    return false;
}

References rz_return_val_if_fail, RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_CALLABLE, RZ_TYPE_KIND_IDENTIFIER, RZ_TYPE_KIND_POINTER, and rz_warn_if_reached.

Referenced by typecmp(), and types_xrefs().

set_default_type()

static void set_default_type ( RzTypeTarget *  target, int  bits  )

static

Definition at line 113 of file type.c.

                                                             {
    if (target->default_type) {
        free((void *)target->default_type);
    }
    switch (bits) {
    case 8:
        target->default_type = strdup("int8_t");
        break;
    case 16:
        target->default_type = strdup("int16_t");
        break;
    case 32:
        target->default_type = strdup("int32_t");
        break;
    case 64:
        target->default_type = strdup("int64_t");
        break;
    default:
        rz_warn_if_reached();
        target->default_type = strdup("int");
    }
}

References bits(), rz_type_target_t::default_type, free(), rz_warn_if_reached, and strdup().

Referenced by rz_type_db_set_bits().

type_as_pretty_string()

static char* type_as_pretty_string ( const RzTypeDB *  typedb, const RzType *  type, const char *  identifier, HtPP *  used_types, unsigned int  opts, int  unfold_level, int  indent_level  )

static

Definition at line 948 of file type.c.

                                                                                                                                                                                {
    rz_return_val_if_fail(typedb && type, NULL);
 
    if (unfold_level < 0) { // recursion base case
        return NULL;
    }
    bool multiline = opts & RZ_TYPE_PRINT_MULTILINE;
    bool anon_only = opts & RZ_TYPE_PRINT_UNFOLD_ANON_ONLY;
    bool anon_only_strict = opts & RZ_TYPE_PRINT_UNFOLD_ANON_ONLY_STRICT;
    bool zero_vla = opts & RZ_TYPE_PRINT_ZERO_VLA;
    bool print_anon = opts & RZ_TYPE_PRINT_ANONYMOUS;
    bool no_end_semicolon = opts & RZ_TYPE_PRINT_NO_END_SEMICOLON;
    no_end_semicolon = no_end_semicolon && (indent_level == 0); // indent_level needs to be zero for the last semicolon
    bool end_newline = opts & RZ_TYPE_PRINT_END_NEWLINE;
    end_newline = end_newline && (indent_level == 0); // only append newline for the outer type
    bool show_typedefs = opts & RZ_TYPE_PRINT_SHOW_TYPEDEF;
    if (indent_level == 0) { // for the root type, disregard anon_only
        anon_only = false;
    }
    anon_only = anon_only || anon_only_strict;
    bool unfold_all = !anon_only && unfold_level;
    bool unfold_anon = unfold_level;
    int indent = 0;
    char *separator = " ";
    if (multiline) {
        indent = indent_level; // indent only if multiline
        separator = "\n";
    }
 
    RzStrBuf *buf = rz_strbuf_new("");
    for (int i = 0; i < indent; i++) {
        rz_strbuf_append(buf, "\t");
    }
    RzStrBuf *typename = rz_strbuf_new("");
    RzStrBuf *pointer_buf = rz_strbuf_new("");
    RzStrBuf *array_buf = rz_strbuf_new("");
    struct PrettyHelperBufs phbuf = { typename, pointer_buf, array_buf };
    bool self_ref = false;
    char *self_ref_typename = NULL;
    bool decl = type_decl_as_pretty_string(typedb, type, used_types, phbuf, &self_ref, &self_ref_typename, zero_vla, print_anon, show_typedefs);
    if (!decl) {
        rz_strbuf_free(buf);
        rz_strbuf_free(typename);
        rz_strbuf_free(pointer_buf);
        rz_strbuf_free(array_buf);
        return NULL;
    }
    if (self_ref) { // in case of self referntial type
        unfold_level = 0; // no unfold
        unfold_anon = unfold_all = false;
    } else if (self_ref_typename) {
        ht_pp_insert(used_types, self_ref_typename, NULL); // add the type to the ht
    }
    RzBaseType *btype = NULL;
    bool is_anon = false;
    if (type->kind == RZ_TYPE_KIND_IDENTIFIER) {
        is_anon = !strncmp(type->identifier.name, "anonymous ", 10);
        btype = rz_type_db_get_base_type(typedb, type->identifier.name);
    } else if ((type->kind == RZ_TYPE_KIND_POINTER && rz_type_is_callable_ptr_nested(type)) || type->kind == RZ_TYPE_KIND_CALLABLE) {
        identifier = NULL; // no need to separately print identifier for function pointers or functions
    }
    char *typename_str = rz_strbuf_drain(phbuf.typename);
    char *pointer_str = rz_strbuf_drain(phbuf.pointerbuf);
    char *array_str = rz_strbuf_drain(phbuf.arraybuf);
    rz_strbuf_append(buf, typename_str);
 
    if (btype) {
        bool not_empty; // to check if no members are present
        switch (btype->kind) {
        case RZ_BASE_TYPE_KIND_STRUCT:
            if (unfold_all || (is_anon && unfold_anon)) {
                rz_strbuf_append(buf, " {");
                RzTypeStructMember *memb;
                not_empty = rz_vector_len(&btype->struct_data.members);
                if (not_empty) {
                    rz_strbuf_appendf(buf, "%s", multiline ? "\n" : " ");
                }
                rz_vector_foreach(&btype->struct_data.members, memb) {
                    char *unfold = type_as_pretty_string(typedb, memb->type, memb->name, used_types, opts, unfold_level - 1, indent_level + 1);
                    rz_strbuf_appendf(buf, "%s%s", unfold, separator);
                    free(unfold);
                }
                for (int i = 0; i < indent; i++) {
                    rz_strbuf_append(buf, "\t");
                }
                rz_strbuf_append(buf, "}");
            }
            break;
        case RZ_BASE_TYPE_KIND_UNION:
            if (unfold_all || (is_anon && unfold_anon)) {
                rz_strbuf_append(buf, " {");
                RzTypeUnionMember *memb;
                not_empty = rz_vector_len(&btype->union_data.members);
                if (not_empty) {
                    rz_strbuf_appendf(buf, "%s", multiline ? "\n" : " ");
                }
                rz_vector_foreach(&btype->union_data.members, memb) {
                    char *unfold = type_as_pretty_string(typedb, memb->type, memb->name, used_types, opts, unfold_level - 1, indent_level + 1);
                    rz_strbuf_appendf(buf, "%s%s", unfold, separator);
                    free(unfold);
                }
                for (int i = 0; i < indent; i++) {
                    rz_strbuf_append(buf, "\t");
                }
                rz_strbuf_append(buf, "}");
            }
            break;
        case RZ_BASE_TYPE_KIND_ENUM:
            if (unfold_all || (is_anon && unfold_anon)) {
                RzTypeEnumCase *cas;
                rz_strbuf_append(buf, " {");
                if (multiline) {
                    indent++; // no recursive call, so manually need to update indent
                }
                not_empty = rz_vector_len(&btype->enum_data.cases);
                if (not_empty) {
                    rz_strbuf_appendf(buf, "%s", multiline ? "\n" : " ");
                }
                rz_vector_foreach(&btype->enum_data.cases, cas) {
                    for (int i = 0; i < indent; i++) {
                        rz_strbuf_append(buf, "\t");
                    }
                    rz_strbuf_appendf(buf, "%s = 0x%" PFMT64x ",%s", cas->name, cas->val, separator);
                }
                if (not_empty) {
                    rz_strbuf_slice(buf, 0, rz_strbuf_length(buf) - 2);
                    rz_strbuf_append(buf, separator);
                }
                if (multiline) {
                    indent--; // restore the original value
                }
                for (int i = 0; i < indent; i++) {
                    rz_strbuf_append(buf, "\t");
                }
                rz_strbuf_append(buf, "}");
            }
            break;
        case RZ_BASE_TYPE_KIND_TYPEDEF:
            if (show_typedefs && !rz_type_is_callable_ptr_nested(btype->type)) { // if not a callable
                rz_strbuf_appendf(buf, " %s", btype->name);
            }
            break;
        case RZ_BASE_TYPE_KIND_ATOMIC:
            break;
        default:
            rz_warn_if_reached();
            break;
        }
    }
 
    if (rz_str_nlen(pointer_str, 1) != 0 || identifier || rz_str_nlen(array_str, 1) != 0) {
        rz_strbuf_append(buf, " "); // add space only if the type is pointer or an array or has an identifier
    }
    rz_strbuf_appendf(buf, "%s%s%s", pointer_str ? pointer_str : "", identifier ? identifier : "", array_str ? array_str : "");
    if (!no_end_semicolon) {
        rz_strbuf_append(buf, ";");
    }
    if (end_newline) {
        rz_strbuf_append(buf, "\n");
    }
    if (self_ref_typename) {
        ht_pp_delete(used_types, self_ref_typename);
        free(self_ref_typename);
    }
    free(typename_str);
    free(pointer_str);
    free(array_str);
 
    char *pretty_type = rz_strbuf_drain(buf);
    return pretty_type;
}

References PrettyHelperBufs::arraybuf, rz_base_type_enum_t::cases, rz_base_type_t::enum_data, free(), i, rz_base_type_t::kind, rz_base_type_struct_t::members, rz_base_type_union_t::members, rz_type_enum_case_t::name, rz_type_struct_member_t::name, rz_type_union_member_t::name, rz_base_type_t::name, NULL, PFMT64x, PrettyHelperBufs::pointerbuf, RZ_BASE_TYPE_KIND_ATOMIC, RZ_BASE_TYPE_KIND_ENUM, RZ_BASE_TYPE_KIND_STRUCT, RZ_BASE_TYPE_KIND_TYPEDEF, RZ_BASE_TYPE_KIND_UNION, rz_return_val_if_fail, rz_str_nlen(), rz_strbuf_append(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_length(), rz_strbuf_new(), rz_strbuf_slice(), rz_type_db_get_base_type(), rz_type_is_callable_ptr_nested(), RZ_TYPE_KIND_CALLABLE, RZ_TYPE_KIND_IDENTIFIER, RZ_TYPE_KIND_POINTER, RZ_TYPE_PRINT_ANONYMOUS, RZ_TYPE_PRINT_END_NEWLINE, RZ_TYPE_PRINT_MULTILINE, RZ_TYPE_PRINT_NO_END_SEMICOLON, RZ_TYPE_PRINT_SHOW_TYPEDEF, RZ_TYPE_PRINT_UNFOLD_ANON_ONLY, RZ_TYPE_PRINT_UNFOLD_ANON_ONLY_STRICT, RZ_TYPE_PRINT_ZERO_VLA, rz_vector_foreach, rz_vector_len(), rz_warn_if_reached, rz_base_type_t::struct_data, type, rz_type_struct_member_t::type, rz_type_union_member_t::type, rz_base_type_t::type, type_decl_as_pretty_string(), PrettyHelperBufs::typename, rz_base_type_t::union_data, and rz_type_enum_case_t::val.

Referenced by rz_type_as_pretty_string().

type_decl_as_pretty_string()

static bool type_decl_as_pretty_string ( const RzTypeDB *  typedb, const RzType *  type, HtPP *  used_types, struct PrettyHelperBufs  phbuf, bool *  self_ref, char **  self_ref_typename, bool  zero_vla, bool  print_anon, bool  show_typedefs  )

static

Definition at line 853 of file type.c.

                                                                                                                                                                                                                                  {
    rz_return_val_if_fail(typedb && type && used_types && self_ref, false);
 
    bool is_anon = false;
    switch (type->kind) {
    case RZ_TYPE_KIND_IDENTIFIER: {
        if (!type->identifier.name) {
            return false;
        }
        is_anon = !strncmp(type->identifier.name, "anonymous ", strlen("anonymous "));
        *self_ref = false;
        ht_pp_find(used_types, type->identifier.name, self_ref);
        *self_ref = *self_ref && !is_anon; // no self_ref for anon types
        *self_ref_typename = *self_ref ? strdup(type->identifier.name) : NULL;
 
        RzBaseType *btype = rz_type_db_get_base_type(typedb, type->identifier.name);
        if (!btype) {
            rz_strbuf_append(phbuf.typename, "unknown_t");
        } else {
            switch (btype->kind) {
            case RZ_BASE_TYPE_KIND_STRUCT:
                rz_strbuf_appendf(phbuf.typename, "%sstruct", type->identifier.is_const ? "const " : "");
                if (!is_anon || print_anon) {
                    rz_strbuf_appendf(phbuf.typename, " %s", btype->name);
                }
                break;
            case RZ_BASE_TYPE_KIND_UNION:
                rz_strbuf_appendf(phbuf.typename, "%sunion", type->identifier.is_const ? "const " : "");
                if (!is_anon || print_anon) {
                    rz_strbuf_appendf(phbuf.typename, " %s", btype->name);
                }
                break;
            case RZ_BASE_TYPE_KIND_ENUM:
                rz_strbuf_appendf(phbuf.typename, "%senum", type->identifier.is_const ? "const " : "");
                if (!is_anon || print_anon) {
                    rz_strbuf_appendf(phbuf.typename, " %s", btype->name);
                }
                break;
            case RZ_BASE_TYPE_KIND_TYPEDEF: {
                if (show_typedefs) {
                    char *typestr = rz_type_as_string(typedb, btype->type);
                    if (!typestr) {
                        RZ_LOG_ERROR("Failed to get type representation of typedef of base type: %s\n", btype->name);
                        return false;
                    }
                    rz_strbuf_appendf(phbuf.typename, "typedef %s", typestr);
                    free(typestr);
                } else {
                    rz_strbuf_append(phbuf.typename, btype->name);
                }
                break;
            }
            case RZ_BASE_TYPE_KIND_ATOMIC:
                rz_strbuf_appendf(phbuf.typename, "%s%s", type->identifier.is_const ? "const " : "", btype->name);
                break;
            default:
                rz_warn_if_reached();
                break;
            }
        }
        break;
    }
    case RZ_TYPE_KIND_POINTER:
        if (rz_type_is_callable_ptr_nested(type)) { // function pointers
            char *typestr = rz_type_callable_ptr_as_string(typedb, type);
            rz_strbuf_append(phbuf.typename, typestr);
            free(typestr);
        } else {
            type_decl_as_pretty_string(typedb, type->pointer.type, used_types, phbuf, self_ref, self_ref_typename, zero_vla, print_anon, show_typedefs);
            rz_strbuf_append(phbuf.pointerbuf, "*");
            rz_strbuf_appendf(phbuf.pointerbuf, "%s", type->pointer.is_const ? " const " : "");
        }
        break;
    case RZ_TYPE_KIND_ARRAY:
        if (type->array.count) {
            rz_strbuf_appendf(phbuf.arraybuf, "[%" PFMT64d "]", type->array.count);
        } else { // variable length arrays
            rz_strbuf_appendf(phbuf.arraybuf, "[%s]", zero_vla ? "0" : "");
        }
        type_decl_as_pretty_string(typedb, type->array.type, used_types, phbuf, self_ref, self_ref_typename, zero_vla, print_anon, show_typedefs);
        break;
    case RZ_TYPE_KIND_CALLABLE: {
        char *callstr = rz_type_callable_as_string(typedb, type->callable);
        rz_strbuf_append(phbuf.typename, callstr);
        free(callstr);
        break;
    }
    default:
        rz_warn_if_reached();
        break;
    }
 
    return true;
}

References PrettyHelperBufs::arraybuf, free(), rz_base_type_t::kind, rz_base_type_t::name, NULL, PFMT64d, PrettyHelperBufs::pointerbuf, RZ_BASE_TYPE_KIND_ATOMIC, RZ_BASE_TYPE_KIND_ENUM, RZ_BASE_TYPE_KIND_STRUCT, RZ_BASE_TYPE_KIND_TYPEDEF, RZ_BASE_TYPE_KIND_UNION, RZ_LOG_ERROR, rz_return_val_if_fail, rz_strbuf_append(), rz_strbuf_appendf(), rz_type_as_string(), rz_type_callable_as_string(), rz_type_callable_ptr_as_string(), rz_type_db_get_base_type(), rz_type_is_callable_ptr_nested(), RZ_TYPE_KIND_ARRAY, RZ_TYPE_KIND_CALLABLE, RZ_TYPE_KIND_IDENTIFIER, RZ_TYPE_KIND_POINTER, rz_warn_if_reached, strdup(), type, rz_base_type_t::type, and PrettyHelperBufs::typename.

Referenced by type_as_pretty_string().

types_ht_free()

static void types_ht_free ( HtPPKv *  kv )

static

Definition at line 12 of file type.c.

                                      {
    free(kv->key);
    rz_type_base_type_free(kv->value);
}

References free(), and rz_type_base_type_free().

Referenced by rz_type_db_new(), and rz_type_db_purge().