|
| "bool" | deserialize_tinfo ("tinfo_t" tif, "til_t" til, "type_t const **" ptype, "p_list const **" pfields, "p_list const **" pfldcmts, "char const *" cmt=None) |
| | deserialize_tinfo(tif, til, ptype, pfields, pfldcmts, cmt=None) -> bool
|
| |
| "bool" | is_type_const ("type_t" t) |
| | is_type_const(t) -> bool See BTM_CONST.
|
| |
| "bool" | is_type_volatile ("type_t" t) |
| | is_type_volatile(t) -> bool See BTM_VOLATILE.
|
| |
| "type_t" | get_base_type ("type_t" t) |
| | get_base_type(t) -> type_t Get get basic type bits (TYPE_BASE_MASK)
|
| |
| "type_t" | get_type_flags ("type_t" t) |
| | get_type_flags(t) -> type_t Get type flags (TYPE_FLAGS_MASK)
|
| |
| "type_t" | get_full_type ("type_t" t) |
| | get_full_type(t) -> type_t Get basic type bits + type flags (TYPE_FULL_MASK)
|
| |
| "bool" | is_typeid_last ("type_t" t) |
| | is_typeid_last(t) -> bool Is the type_t the last byte of type declaration? (there are no additional bytes after a basic type, see _BT_LAST_BASIC)
|
| |
| "bool" | is_type_partial ("type_t" t) |
| | is_type_partial(t) -> bool Identifies an unknown or void type with a known size (see Basic type: unknown & void)
|
| |
| "bool" | is_type_void ("type_t" t) |
| | is_type_void(t) -> bool See BTF_VOID.
|
| |
| "bool" | is_type_unknown ("type_t" t) |
| | is_type_unknown(t) -> bool See BT_UNKNOWN.
|
| |
| "bool" | is_type_ptr ("type_t" t) |
| | is_type_ptr(t) -> bool See BT_PTR.
|
| |
| "bool" | is_type_complex ("type_t" t) |
| | is_type_complex(t) -> bool See BT_COMPLEX.
|
| |
| "bool" | is_type_func ("type_t" t) |
| | is_type_func(t) -> bool See BT_FUNC.
|
| |
| "bool" | is_type_array ("type_t" t) |
| | is_type_array(t) -> bool See BT_ARRAY.
|
| |
| "bool" | is_type_typedef ("type_t" t) |
| | is_type_typedef(t) -> bool See BTF_TYPEDEF.
|
| |
| "bool" | is_type_sue ("type_t" t) |
| | is_type_sue(t) -> bool Is the type a struct/union/enum?
|
| |
| "bool" | is_type_struct ("type_t" t) |
| | is_type_struct(t) -> bool See BTF_STRUCT.
|
| |
| "bool" | is_type_union ("type_t" t) |
| | is_type_union(t) -> bool See BTF_UNION.
|
| |
| "bool" | is_type_struni ("type_t" t) |
| | is_type_struni(t) -> bool Is the type a struct or union?
|
| |
| "bool" | is_type_enum ("type_t" t) |
| | is_type_enum(t) -> bool See BTF_ENUM.
|
| |
| "bool" | is_type_bitfld ("type_t" t) |
| | is_type_bitfld(t) -> bool See BT_BITFIELD.
|
| |
| "bool" | is_type_int ("type_t" bt) |
| | is_type_int(bt) -> bool Does the type_t specify one of the basic types in Basic type: integer?
|
| |
| "bool" | is_type_int128 ("type_t" t) |
| | is_type_int128(t) -> bool Does the type specify a 128-bit value? (signed or unsigned, see Basic type: integer)
|
| |
| "bool" | is_type_int64 ("type_t" t) |
| | is_type_int64(t) -> bool Does the type specify a 64-bit value? (signed or unsigned, see Basic type: integer)
|
| |
| "bool" | is_type_int32 ("type_t" t) |
| | is_type_int32(t) -> bool Does the type specify a 32-bit value? (signed or unsigned, see Basic type: integer)
|
| |
| "bool" | is_type_int16 ("type_t" t) |
| | is_type_int16(t) -> bool Does the type specify a 16-bit value? (signed or unsigned, see Basic type: integer)
|
| |
| "bool" | is_type_char ("type_t" t) |
| | is_type_char(t) -> bool Does the type specify a char value? (signed or unsigned, see Basic type: integer)
|
| |
| "bool" | is_type_paf ("type_t" t) |
| | is_type_paf(t) -> bool Is the type a pointer, array, or function type?
|
| |
| "bool" | is_type_ptr_or_array ("type_t" t) |
| | is_type_ptr_or_array(t) -> bool Is the type a pointer or array type?
|
| |
| "bool" | is_type_floating ("type_t" t) |
| | is_type_floating(t) -> bool Is the type a floating point type?
|
| |
| "bool" | is_type_integral ("type_t" t) |
| | is_type_integral(t) -> bool Is the type an integral type (char/short/int/long/bool)?
|
| |
| "bool" | is_type_ext_integral ("type_t" t) |
| | is_type_ext_integral(t) -> bool Is the type an extended integral type? (integral or enum)
|
| |
| "bool" | is_type_arithmetic ("type_t" t) |
| | is_type_arithmetic(t) -> bool Is the type an arithmetic type? (floating or integral)
|
| |
| "bool" | is_type_ext_arithmetic ("type_t" t) |
| | is_type_ext_arithmetic(t) -> bool Is the type an extended arithmetic type? (arithmetic or enum)
|
| |
| "bool" | is_type_uint ("type_t" t) |
| | is_type_uint(t) -> bool See BTF_UINT.
|
| |
| "bool" | is_type_uchar ("type_t" t) |
| | is_type_uchar(t) -> bool See BTF_UCHAR.
|
| |
| "bool" | is_type_uint16 ("type_t" t) |
| | is_type_uint16(t) -> bool See BTF_UINT16.
|
| |
| "bool" | is_type_uint32 ("type_t" t) |
| | is_type_uint32(t) -> bool See BTF_UINT32.
|
| |
| "bool" | is_type_uint64 ("type_t" t) |
| | is_type_uint64(t) -> bool See BTF_UINT64.
|
| |
| "bool" | is_type_uint128 ("type_t" t) |
| | is_type_uint128(t) -> bool See BTF_UINT128.
|
| |
| "bool" | is_type_ldouble ("type_t" t) |
| | is_type_ldouble(t) -> bool See BTF_LDOUBLE.
|
| |
| "bool" | is_type_double ("type_t" t) |
| | is_type_double(t) -> bool See BTF_DOUBLE.
|
| |
| "bool" | is_type_float ("type_t" t) |
| | is_type_float(t) -> bool See BTF_FLOAT.
|
| |
| "bool" | is_type_tbyte ("type_t" t) |
| | is_type_tbyte(t) -> bool See BTF_FLOAT.
|
| |
| "bool" | is_type_bool ("type_t" t) |
| | is_type_bool(t) -> bool See BTF_BOOL.
|
| |
| "bool" | is_tah_byte ("type_t" t) |
| | is_tah_byte(t) -> bool The TAH byte (type attribute header byte) denotes the start of type attributes.
|
| |
| "bool" | is_sdacl_byte ("type_t" t) |
| | is_sdacl_byte(t) -> bool Identify an sdacl byte.
|
| |
| "bool" | append_argloc ("qtype *" out, "argloc_t" vloc) |
| | append_argloc(out, vloc) -> bool Serialize argument location
|
| |
| "bool" | extract_argloc ("argloc_t" vloc, "type_t const **" ptype, "bool" forbid_stkoff) |
| | extract_argloc(vloc, ptype, forbid_stkoff) -> bool Deserialize an argument location.
|
| |
| "type_t const *" | resolve_typedef ("til_t" til, "type_t const *" type) |
| | resolve_typedef(til, type) -> type_t const *
|
| |
| "bool" | is_restype_void ("til_t" til, "type_t const *" type) |
| | is_restype_void(til, type) -> bool
|
| |
| "bool" | is_restype_enum ("til_t" til, "type_t const *" type) |
| | is_restype_enum(til, type) -> bool
|
| |
| "bool" | is_restype_struni ("til_t" til, "type_t const *" type) |
| | is_restype_struni(til, type) -> bool
|
| |
| "bool" | is_restype_struct ("til_t" til, "type_t const *" type) |
| | is_restype_struct(til, type) -> bool
|
| |
| "type_t" | get_scalar_bt ("int" size) |
| | get_scalar_bt(size) -> type_t
|
| |
| "til_t *" | new_til ("char const *" name, "char const *" desc) |
| | new_til(name, desc) -> til_t Initialize a til.
|
| |
| "qstring *" | load_til ("char const *" name, "char const *" tildir=None) |
| | load_til(name, tildir=None) -> til_t Load til from a file without adding it to the database list (see also add_til).
|
| |
| "bool" | compact_til ("til_t" ti) |
| | compact_til(ti) -> bool Collect garbage in til.
|
| |
| "bool" | store_til ("til_t" ti, "char const *" tildir, "char const *" name) |
| | store_til(ti, tildir, name) -> bool Store til to a file.
|
| |
| "void" | free_til ("til_t" ti) |
| | free_til(ti) Free memory allocated by til.
|
| |
| "qstring *" | load_til_header ("char const *" tildir, "char const *" name) |
| | load_til_header(tildir, name) -> til_t Get human-readable til description.
|
| |
| "bool" | is_code_far ("cm_t" cm) |
| | is_code_far(cm) -> bool Does the given model specify far code?.
|
| |
| "bool" | is_data_far ("cm_t" cm) |
| | is_data_far(cm) -> bool Does the given model specify far data?.
|
| |
| "int" | verify_argloc ("argloc_t" vloc, "int" size, "rangeset_t" gaps) |
| | verify_argloc(vloc, size, gaps) -> int Verify argloc_t.
|
| |
| "bool" | optimize_argloc ("argloc_t" vloc, "int" size, "rangeset_t" gaps) |
| | optimize_argloc(vloc, size, gaps) -> bool Verify and optimize scattered argloc into simple form.
|
| |
| "size_t" | print_argloc ("argloc_t" vloc, "int" size=0, "int" vflags=0) |
| | print_argloc(vloc, size=0, vflags=0) -> size_t Convert an argloc to human readable form.
|
| |
| "int" | for_all_arglocs ("aloc_visitor_t" vv, "argloc_t" vloc, "int" size, "int" off=0) |
| | for_all_arglocs(vv, vloc, size, off=0) -> int Compress larger argloc types and initiate the aloc visitor.
|
| |
| "int" | for_all_const_arglocs ("const_aloc_visitor_t" vv, "argloc_t" vloc, "int" size, "int" off=0) |
| | for_all_const_arglocs(vv, vloc, size, off=0) -> int See for_all_arglocs()
|
| |
| "bool" | is_user_cc ("cm_t" cm) |
| | is_user_cc(cm) -> bool Does the calling convention specify argument locations explicitly?
|
| |
| "bool" | is_vararg_cc ("cm_t" cm) |
| | is_vararg_cc(cm) -> bool Does the calling convention use ellipsis?
|
| |
| "bool" | is_purging_cc ("cm_t" cm) |
| | is_purging_cc(cm) -> bool Does the calling convention clean the stack arguments upon return?.
|
| |
| "bool" | is_golang_cc ("cm_t" cc) |
| | is_golang_cc(cc) -> bool GO language calling convention (return value in stack)?
|
| |
| "bool" | is_swift_cc ("cm_t" cc) |
| | is_swift_cc(cc) -> bool Swift calling convention (arguments and return values in registers)?
|
| |
| "comp_t" | get_comp ("comp_t" comp) |
| | get_comp(comp) -> comp_t Get compiler bits.
|
| |
| "char const *" | get_compiler_name ("comp_t" id) |
| | get_compiler_name(id) -> char const * Get full compiler name.
|
| |
| "char const *" | get_compiler_abbr ("comp_t" id) |
| | get_compiler_abbr(id) -> char const * Get abbreviated compiler name.
|
| |
| "void" | get_compilers ("compvec_t *" ids, "qstrvec_t *" names, "qstrvec_t *" abbrs) |
| | get_compilers(ids, names, abbrs) Get names of all built-in compilers.
|
| |
| "comp_t" | is_comp_unsure ("comp_t" comp) |
| | is_comp_unsure(comp) -> comp_t See COMP_UNSURE.
|
| |
| "comp_t" | default_compiler () |
| | default_compiler() -> comp_t Get compiler specified by inf.cc.
|
| |
| "bool" | is_gcc () |
| | is_gcc() -> bool Is the target compiler COMP_GNU?
|
| |
| "bool" | is_gcc32 () |
| | is_gcc32() -> bool Is the target compiler 32 bit gcc?
|
| |
| "bool" | is_gcc64 () |
| | is_gcc64() -> bool Is the target compiler 64 bit gcc?
|
| |
| "bool" | gcc_layout () |
| | gcc_layout() -> bool Should use the struct/union layout as done by gcc?
|
| |
| "bool" | set_compiler ("compiler_info_t" cc, "int" flags, "char const *" abiname=None) |
| | set_compiler(cc, flags, abiname=None) -> bool Change current compiler.
|
| |
| "bool" | set_compiler_id ("comp_t" id, "char const *" abiname=None) |
| | set_compiler_id(id, abiname=None) -> bool Set the compiler id (see Compiler IDs)
|
| |
| "bool" | set_abi_name ("char const *" abiname, "bool" user_level=False) |
| | set_abi_name(abiname, user_level=False) -> bool Set abi name (see Compiler IDs)
|
| |
| "qstring *" | get_abi_name () |
| | get_abi_name() -> str Get ABI name.
|
| |
| "bool" | append_abi_opts ("char const *" abi_opts, "bool" user_level=False) |
| | append_abi_opts(abi_opts, user_level=False) -> bool Add/remove/check ABI option General form of full abi name: abiname-opt1-opt2-... or -opt1-opt2-...
|
| |
| "bool" | remove_abi_opts ("char const *" abi_opts, "bool" user_level=False) |
| | remove_abi_opts(abi_opts, user_level=False) -> bool
|
| |
| "bool" | set_compiler_string ("char const *" compstr, "bool" user_level) |
| | set_compiler_string(compstr, user_level) -> bool
|
| |
| "bool" | use_golang_cc () |
| | use_golang_cc() -> bool is GOLANG calling convention used by default?
|
| |
| "void" | switch_to_golang () |
| | switch_to_golang() switch to GOLANG calling convention (to be used as default CC)
|
| |
| "int" | convert_pt_flags_to_hti ("int" pt_flags) |
| | convert_pt_flags_to_hti(pt_flags) -> int Convert Type parsing flags to Type formatting flags.
|
| |
| "qstring *" | parse_decl ("tinfo_t" out_tif, "til_t" til, "char const *" decl, "int" pt_flags) |
| | parse_decl(out_tif, til, decl, pt_flags) -> str Parse ONE declaration.
|
| |
| "int" | parse_decls ("til_t" til, "char const *" input, "printer_t *" printer, "int" hti_flags) |
| | parse_decls(til, input, printer, hti_flags) -> int Parse many declarations and store them in a til.
|
| |
| "qstring *" | print_type ("ea_t" ea, "int" prtype_flags) |
| | print_type(ea, prtype_flags) -> str Get type declaration for the specified address.
|
| |
| "char const *" | tinfo_errstr ("tinfo_code_t" code) |
| | tinfo_errstr(code) -> char const * Helper function to convert an error code into a printable string.
|
| |
| "bool" | del_named_type ("til_t" ti, "char const *" name, "int" ntf_flags) |
| | del_named_type(ti, name, ntf_flags) -> bool Delete information about a symbol.
|
| |
| "char const *" | first_named_type ("til_t" ti, "int" ntf_flags) |
| | first_named_type(ti, ntf_flags) -> char const * Enumerate types.
|
| |
| "char const *" | next_named_type ("til_t" ti, "char const *" name, "int" ntf_flags) |
| | next_named_type(ti, name, ntf_flags) -> char const * Enumerate types.
|
| |
| "uint32" | copy_named_type ("til_t" dsttil, "til_t" srctil, "char const *" name) |
| | copy_named_type(dsttil, srctil, name) -> uint32 Copy a named type from one til to another.
|
| |
| "qstring *" | gen_decorate_name ("char const *" name, "bool" mangle, "cm_t" cc, "tinfo_t" type) |
| | gen_decorate_name(name, mangle, cc, type) -> str Generic function for decorate_name() (may be used in IDP modules)
|
| |
| "qstring *" | calc_c_cpp_name ("char const *" name, "tinfo_t" type, "int" ccn_flags) |
| | calc_c_cpp_name(name, type, ccn_flags) -> str Get C or C++ form of the name.
|
| |
| "bool" | enable_numbered_types ("til_t" ti, "bool" enable) |
| | enable_numbered_types(ti, enable) -> bool Enable the use of numbered types in til.
|
| |
| "uint32" | alloc_type_ordinals ("til_t" ti, "int" qty) |
| | alloc_type_ordinals(ti, qty) -> uint32 Allocate a range of ordinal numbers for new types.
|
| |
| "uint32" | alloc_type_ordinal ("til_t" ti) |
| | alloc_type_ordinal(ti) -> uint32 alloc_type_ordinals(ti, 1)
|
| |
| "uint32" | get_ordinal_limit ("til_t" ti=None) |
| | get_ordinal_limit(ti=None) -> uint32 Get number of allocated ordinals + 1.
|
| |
| "uint32" | get_ordinal_count ("til_t" ti=None) |
| | get_ordinal_count(ti=None) -> uint32 Get number of allocated ordinals.
|
| |
| "bool" | del_numbered_type ("til_t" ti, "uint32" ordinal) |
| | del_numbered_type(ti, ordinal) -> bool Delete a numbered type.
|
| |
| "bool" | set_type_alias ("til_t" ti, "uint32" src_ordinal, "uint32" dst_ordinal) |
| | set_type_alias(ti, src_ordinal, dst_ordinal) -> bool Create a type alias.
|
| |
| "uint32" | get_alias_target ("til_t" ti, "uint32" ordinal) |
| | get_alias_target(ti, ordinal) -> uint32 Find the final alias destination.
|
| |
| "int32" | get_type_ordinal ("til_t" ti, "char const *" name) |
| | get_type_ordinal(ti, name) -> int32 Get type ordinal by its name.
|
| |
| "char const *" | get_numbered_type_name ("til_t" ti, "uint32" ordinal) |
| | get_numbered_type_name(ti, ordinal) -> char const * Get type name (if exists) by its ordinal.
|
| |
| "qstring *" | create_numbered_type_name ("int32" ord) |
| | create_numbered_type_name(ord) -> str Create anonymous name for numbered type.
|
| |
| "bool" | is_ordinal_name ("char const *" name, "uint32 *" ord=None) |
| | is_ordinal_name(name, ord=None) -> bool Check if the name is an ordinal name.
|
| |
| "bool" | is_type_choosable ("til_t" ti, "uint32" ordinal) |
| | is_type_choosable(ti, ordinal) -> bool Check if a struct/union type is choosable
|
| |
| "void" | set_type_choosable ("til_t" ti, "uint32" ordinal, "bool" value) |
| | set_type_choosable(ti, ordinal, value) Enable/disable 'choosability' flag for a struct/union type
|
| |
| "ea_t" | get_vftable_ea ("uint32" ordinal) |
| | get_vftable_ea(ordinal) -> ea_t Get address of a virtual function table.
|
| |
| "uint32" | get_vftable_ordinal ("ea_t" vftable_ea) |
| | get_vftable_ordinal(vftable_ea) -> uint32 Get ordinal number of the virtual function table.
|
| |
| "bool" | set_vftable_ea ("uint32" ordinal, "ea_t" vftable_ea) |
| | set_vftable_ea(ordinal, vftable_ea) -> bool Set the address of a vftable instance for a vftable type.
|
| |
| "bool" | del_vftable_ea ("uint32" ordinal) |
| | del_vftable_ea(ordinal) -> bool Delete the address of a vftable instance for a vftable type.
|
| |
| "bool" | deref_ptr ("ea_t *" ptr_ea, "tinfo_t" tif, "ea_t *" closure_obj=None) |
| | deref_ptr(ptr_ea, tif, closure_obj=None) -> bool Dereference a pointer.
|
| |
| "int" | add_til ("char const *" name, "int" flags) |
| | add_til(name, flags) -> int Load a til file and add it the database type libraries list.
|
| |
| "bool" | del_til ("char const *" name) |
| | del_til(name) -> bool Unload a til file.
|
| |
| "bool" | apply_named_type ("ea_t" ea, "char const *" name) |
| | apply_named_type(ea, name) -> bool Apply the specified named type to the address.
|
| |
| "bool" | apply_tinfo ("ea_t" ea, "tinfo_t" tif, "uint32" flags) |
| | apply_tinfo(ea, tif, flags) -> bool Apply the specified type to the specified address.
|
| |
| "bool" | apply_cdecl ("til_t" til, "ea_t" ea, "char const *" decl, "int" flags=0) |
| | apply_cdecl(til, ea, decl, flags=0) -> bool Apply the specified type to the address.
|
| |
| "bool" | apply_callee_tinfo ("ea_t" caller, "tinfo_t" tif) |
| | apply_callee_tinfo(caller, tif) -> bool Apply the type of the called function to the calling instruction.
|
| |
| "bool" | apply_once_tinfo_and_name ("ea_t" dea, "tinfo_t" tif, "char const *" name) |
| | apply_once_tinfo_and_name(dea, tif, name) -> bool Apply the specified type and name to the address.
|
| |
| "int" | guess_tinfo ("tinfo_t" out, "tid_t" id) |
| | guess_tinfo(out, id) -> int Generate a type information about the id from the disassembly.
|
| |
| "void" | set_c_header_path ("char const *" incdir) |
| | set_c_header_path(incdir) Set include directory path the target compiler.
|
| |
| "qstring *" | get_c_header_path () |
| | get_c_header_path() -> str Get the include directory path of the target compiler.
|
| |
| "void" | set_c_macros ("char const *" macros) |
| | set_c_macros(macros) Set predefined macros for the target compiler.
|
| |
| "qstring *" | get_c_macros () |
| | get_c_macros() -> str Get predefined macros for the target compiler.
|
| |
| "til_t *" | get_idati () |
| | get_idati() -> til_t Pointer to the local type library - this til is private for each IDB file Functions that accept til_t* default to idati when is nullptr provided.
|
| |
| "size_t *, flags64_t *, opinfo_t *, size_t *" | get_idainfo_by_type ("tinfo_t" tif) |
| | get_idainfo_by_type(tif) -> bool Extract information from a tinfo_t.
|
| |
| "bool" | get_tinfo_by_flags ("tinfo_t" out, "flags64_t" flags) |
| | get_tinfo_by_flags(out, flags) -> bool Get tinfo object that corresponds to data flags
|
| |
| "void" | copy_tinfo_t ("tinfo_t" _this, "tinfo_t" r) |
| | copy_tinfo_t(_this, r)
|
| |
| "bool" | detach_tinfo_t ("tinfo_t" _this) |
| | detach_tinfo_t(_this) -> bool
|
| |
| "void" | clear_tinfo_t ("tinfo_t" _this) |
| | clear_tinfo_t(_this)
|
| |
| "bool" | create_tinfo ("tinfo_t" _this, "type_t" bt, "type_t" bt2, "void *" ptr) |
| | create_tinfo(_this, bt, bt2, ptr) -> bool
|
| |
| "int" | verify_tinfo ("typid_t" typid) |
| | verify_tinfo(typid) -> int
|
| |
| "bool" | get_tinfo_details ("typid_t" typid, "type_t" bt2, "void *" buf) |
| | get_tinfo_details(typid, bt2, buf) -> bool
|
| |
| "size_t" | get_tinfo_size ("uint32 *" p_effalign, "typid_t" typid, "int" gts_code) |
| | get_tinfo_size(p_effalign, typid, gts_code) -> size_t
|
| |
| "size_t" | get_tinfo_pdata ("void *" outptr, "typid_t" typid, "int" what) |
| | get_tinfo_pdata(outptr, typid, what) -> size_t
|
| |
| "size_t" | get_tinfo_property ("typid_t" typid, "int" gta_prop) |
| | get_tinfo_property(typid, gta_prop) -> size_t
|
| |
| "size_t" | get_tinfo_property4 ("typid_t" typid, "int" gta_prop, "size_t" p1, "size_t" p2, "size_t" p3, "size_t" p4) |
| | get_tinfo_property4(typid, gta_prop, p1, p2, p3, p4) -> size_t
|
| |
| "size_t" | set_tinfo_property ("tinfo_t" tif, "int" sta_prop, "size_t" x) |
| | set_tinfo_property(tif, sta_prop, x) -> size_t
|
| |
| "size_t" | set_tinfo_property4 ("tinfo_t" tif, "int" sta_prop, "size_t" p1, "size_t" p2, "size_t" p3, "size_t" p4) |
| | set_tinfo_property4(tif, sta_prop, p1, p2, p3, p4) -> size_t
|
| |
| "bool" | serialize_tinfo ("qtype *" type, "qtype *" fields, "qtype *" fldcmts, "tinfo_t" tif, "int" sudt_flags) |
| | serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool
|
| |
| "int" | find_tinfo_udt_member ("udm_t" udm, "typid_t" typid, "int" strmem_flags) |
| | find_tinfo_udt_member(udm, typid, strmem_flags) -> int
|
| |
| "qstring *" | print_tinfo ("char const *" prefix, "int" indent, "int" cmtindent, "int" flags, "tinfo_t" tif, "char const *" name, "char const *" cmt) |
| | print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> str
|
| |
| "char const *" | dstr_tinfo ("tinfo_t" tif) |
| | dstr_tinfo(tif) -> char const *
|
| |
| "int" | visit_subtypes ("tinfo_visitor_t" visitor, "type_mods_t" out, "tinfo_t" tif, "char const *" name, "char const *" cmt) |
| | visit_subtypes(visitor, out, tif, name, cmt) -> int
|
| |
| "bool" | compare_tinfo ("typid_t" t1, "typid_t" t2, "int" tcflags) |
| | compare_tinfo(t1, t2, tcflags) -> bool
|
| |
| "int" | lexcompare_tinfo ("typid_t" t1, "typid_t" t2, "int" arg3) |
| | lexcompare_tinfo(t1, t2, arg3) -> int
|
| |
| "bool" | get_stock_tinfo ("tinfo_t" tif, "stock_type_id_t" id) |
| | get_stock_tinfo(tif, id) -> bool
|
| |
| "uint64" | read_tinfo_bitfield_value ("typid_t" typid, "uint64" v, "int" bitoff) |
| | read_tinfo_bitfield_value(typid, v, bitoff) -> uint64
|
| |
| "uint64" | write_tinfo_bitfield_value ("typid_t" typid, "uint64" dst, "uint64" v, "int" bitoff) |
| | write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64
|
| |
| "bool" | get_tinfo_attr ("typid_t" typid, "qstring const &" key, "bytevec_t *" bv, "bool" all_attrs) |
| | get_tinfo_attr(typid, key, bv, all_attrs) -> bool
|
| |
| "bool" | set_tinfo_attr ("tinfo_t" tif, "type_attr_t" ta, "bool" may_overwrite) |
| | set_tinfo_attr(tif, ta, may_overwrite) -> bool
|
| |
| "bool" | del_tinfo_attr ("tinfo_t" tif, "qstring const &" key, "bool" make_copy) |
| | del_tinfo_attr(tif, key, make_copy) -> bool
|
| |
| "bool" | get_tinfo_attrs ("typid_t" typid, "type_attrs_t" tav, "bool" include_ref_attrs) |
| | get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool
|
| |
| "bool" | set_tinfo_attrs ("tinfo_t" tif, "type_attrs_t" ta) |
| | set_tinfo_attrs(tif, ta) -> bool
|
| |
| "uint32" | score_tinfo ("tinfo_t" tif) |
| | score_tinfo(tif) -> uint32
|
| |
| "tinfo_code_t" | save_tinfo ("tinfo_t" tif, "til_t" til, "size_t" ord, "char const *" name, "int" ntf_flags) |
| | save_tinfo(tif, til, ord, name, ntf_flags) -> tinfo_code_t
|
| |
| "bool" | append_tinfo_covered ("rangeset_t" out, "typid_t" typid, "uint64" offset) |
| | append_tinfo_covered(out, typid, offset) -> bool
|
| |
| "bool" | calc_tinfo_gaps ("rangeset_t" out, "typid_t" typid) |
| | calc_tinfo_gaps(out, typid) -> bool
|
| |
| "bool" | value_repr_t__from_opinfo ("value_repr_t" _this, "flags64_t" flags, "aflags_t" afl, "opinfo_t" opinfo, "array_parameters_t" ap) |
| | value_repr_t__from_opinfo(_this, flags, afl, opinfo, ap) -> bool
|
| |
| "qstring *" | value_repr_t__print_ ("value_repr_t" _this, "bool" colored) |
| | value_repr_t__print_(_this, colored) -> str
|
| |
| "ssize_t" | udt_type_data_t__find_member ("udt_type_data_t" _this, "udm_t" udm, "int" strmem_flags) |
| | udt_type_data_t__find_member(_this, udm, strmem_flags) -> ssize_t
|
| |
| "bool" | udm_t__make_gap ("udm_t" _this, "uval_t" byteoff, "uval_t" nbytes) |
| | udm_t__make_gap(_this, byteoff, nbytes) -> bool
|
| |
| "ssize_t" | udt_type_data_t__get_best_fit_member ("udt_type_data_t" _this, "asize_t" disp) |
| | udt_type_data_t__get_best_fit_member(_this, disp) -> ssize_t
|
| |
| "ssize_t" | get_tinfo_by_edm_name ("tinfo_t" tif, "til_t" til, "char const *" mname) |
| | get_tinfo_by_edm_name(tif, til, mname) -> ssize_t
|
| |
| "tinfo_t" | remove_pointer ("tinfo_t" tif) |
| | remove_pointer(tif) -> tinfo_t
|
| |
| "cm_t" | guess_func_cc ("func_type_data_t" fti, "int" npurged, "int" cc_flags) |
| | guess_func_cc(fti, npurged, cc_flags) -> cm_t Use func_type_data_t.guess_cc()
|
| |
| "qstring *" | dump_func_type_data ("func_type_data_t" fti, "int" praloc_bits) |
| | dump_func_type_data(fti, praloc_bits) -> str Use func_type_data_t.dump()
|
| |
| "bool" | stroff_as_size ("int" plen, "tinfo_t" tif, "asize_t" value) |
| | stroff_as_size(plen, tif, value) -> bool Should display a structure offset expression as the structure size?
|
| |
| "adiff_t *" | visit_stroff_udms ("udm_visitor_t" sfv, "tid_t const *" path, "adiff_t *" disp, "bool" appzero) |
| | visit_stroff_udms(sfv, path, disp, appzero) -> int Visit structure fields in a stroff expression or in a reference to a struct data variable.
|
| |
| "bool" | is_one_bit_mask ("uval_t" mask) |
| | is_one_bit_mask(mask) -> bool Is bitmask one bit?
|
| |
| "bool" | inf_pack_stkargs (*args) |
| | inf_pack_stkargs() -> bool inf_pack_stkargs(cc) -> bool
|
| |
| "bool" | inf_big_arg_align (*args) |
| | inf_big_arg_align() -> bool inf_big_arg_align(cc) -> bool
|
| |
| "bool" | inf_huge_arg_align (*args) |
| | inf_huge_arg_align() -> bool inf_huge_arg_align(cc) -> bool
|
| |
| "error_t" | unpack_idcobj_from_idb ("idc_value_t *" obj, "tinfo_t" tif, "ea_t" ea, "bytevec_t const *" off0, "int" pio_flags=0) |
| | unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t Collection of register objects.
|
| |
| "error_t" | unpack_idcobj_from_bv ("idc_value_t *" obj, "tinfo_t" tif, "bytevec_t const &" bytes, "int" pio_flags=0) |
| | unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t Read a typed idc object from the byte vector.
|
| |
| "error_t" | pack_idcobj_to_idb ("idc_value_t const *" obj, "tinfo_t" tif, "ea_t" ea, "int" pio_flags=0) |
| | pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t Write a typed idc object to the database.
|
| |
| "error_t" | pack_idcobj_to_bv ("idc_value_t const *" obj, "tinfo_t" tif, "relobj_t" bytes, "void *" objoff, "int" pio_flags=0) |
| | pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t Write a typed idc object to the byte vector.
|
| |
| "bool" | apply_tinfo_to_stkarg ("insn_t const &" insn, "op_t const &" x, "uval_t" v, "tinfo_t" tif, "char const *" name) |
| | apply_tinfo_to_stkarg(insn, x, v, tif, name) -> bool Helper function for the processor modules.
|
| |
| "void" | gen_use_arg_tinfos ("argtinfo_helper_t" _this, "ea_t" caller, "func_type_data_t" fti, "funcargvec_t" rargs) |
| | gen_use_arg_tinfos(_this, caller, fti, rargs) Do not call this function directly, use argtinfo_helper_t.
|
| |
| "bool" | func_has_stkframe_hole ("ea_t" ea, "func_type_data_t" fti) |
| | func_has_stkframe_hole(ea, fti) -> bool Looks for a hole at the beginning of the stack arguments.
|
| |
| "int" | lower_type ("til_t" til, "tinfo_t" tif, "char const *" name=None, "lowertype_helper_t" _helper=None) |
| | lower_type(til, tif, name=None, _helper=None) -> int Lower type.
|
| |
| "int" | replace_ordinal_typerefs ("til_t" til, "tinfo_t" tif) |
| | replace_ordinal_typerefs(til, tif) -> int Replace references to ordinal types by name references.
|
| |
| "void" | begin_type_updating ("update_type_t" utp) |
| | begin_type_updating(utp) Mark the beginning of a large update operation on the types.
|
| |
| "void" | end_type_updating ("update_type_t" utp) |
| | end_type_updating(utp) Mark the end of a large update operation on the types (see begin_type_updating())
|
| |
| "tid_t" | get_named_type_tid ("char const *" name) |
| | get_named_type_tid(name) -> tid_t Get named local type TID
|
| |
| "qstring *" | get_tid_name ("tid_t" tid) |
| | get_tid_name(tid) -> str Get a type name for the specified TID
|
| |
| "uint32" | get_tid_ordinal ("tid_t" tid) |
| | get_tid_ordinal(tid) -> uint32 Get type ordinal number for TID
|
| |
| "ssize_t" | get_udm_by_fullname ("udm_t" udm, "char const *" fullname) |
| | get_udm_by_fullname(udm, fullname) -> ssize_t Get udt member by full name
|
| |
| "bool" | get_idainfo_by_udm (*args) |
| | get_idainfo_by_udm(flags, ti, udm, refinfo_ea=BADADDR) -> bool Calculate IDA info from udt member
|
| |
| "tid_t" | create_enum_type ("char const *" enum_name, "enum_type_data_t" ei, "int" enum_width, "type_sign_t" sign, "bool" convert_to_bitmask, "char const *" enum_cmt=None) |
| | create_enum_type(enum_name, ei, enum_width, sign, convert_to_bitmask, enum_cmt=None) -> tid_t Create type enum
|
| |
| "int" | calc_number_of_children ("argloc_t" loc, "tinfo_t" tif, "bool" dont_deref_ptr=False) |
| | calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int Calculate max number of lines of a formatted c data, when expanded (PTV_EXPAND).
|
| |
| "qstring *" | get_enum_member_expr ("tinfo_t" tif, "int" serial, "uint64" value) |
| | get_enum_member_expr(tif, serial, value) -> str Return a C expression that can be used to represent an enum member.
|
| |
| "bool" | choose_named_type ("til_symbol_t" out_sym, "til_t" root_til, "char const *" title, "int" ntf_flags, "predicate_t" predicate=None) |
| | choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None) -> bool Choose a type from a type library.
|
| |
| "uint32" | choose_local_tinfo ("til_t" ti, "char const *" title, "local_tinfo_predicate_t *" func=None, "uint32" def_ord=0, "void *" ud=None) |
| | choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None) -> uint32 Choose a type from the local type library.
|
| |
| "uint32" | choose_local_tinfo_and_delta ("int32 *" delta, "til_t" ti, "char const *" title, "local_tinfo_predicate_t *" func=None, "uint32" def_ord=0, "void *" ud=None) |
| | choose_local_tinfo_and_delta(delta, ti, title, func=None, def_ord=0, ud=None) -> uint32 Choose a type from the local type library and specify the pointer shift value.
|
| |
| "PyObject *" | idc_parse_decl ("til_t" ti, "char const *" decl, "int" flags) |
| | idc_parse_decl(ti, decl, flags) -> (str, bytes, bytes) or None
|
| |
| "PyObject *" | calc_type_size ("til_t" ti, "PyObject *" tp) |
| | Returns the size of a type.
|
| |
| "bool" | apply_type ("til_t" ti, "type_t const *" type, "p_list const *" fields, "ea_t" ea, "int" flags) |
| | Apply the specified type to the address.
|
| |
| "PyObject *" | get_arg_addrs ("ea_t" caller) |
| | Retrieve addresses of argument initialization instructions.
|
| |
| "PyObject *" | unpack_object_from_idb ("til_t" ti, "type_t const *" type, "p_list const *" fields, "ea_t" ea, "int" pio_flags=0) |
| | unpack_object_from_idb(ti, type, fields, ea, pio_flags=0) -> PyObject
|
| |
| "PyObject *" | unpack_object_from_bv ("til_t" ti, "type_t const *" type, "p_list const *" fields, "bytevec_t const &" bytes, "int" pio_flags=0) |
| | Unpacks a buffer into an object.
|
| |
| "PyObject *" | pack_object_to_idb ("PyObject *" py_obj, "til_t" ti, "type_t const *" type, "p_list const *" fields, "ea_t" ea, "int" pio_flags=0) |
| | Write a typed object to the database.
|
| |
| "PyObject *" | pack_object_to_bv ("PyObject *" py_obj, "til_t" ti, "type_t const *" type, "p_list const *" fields, "ea_t" base_ea, "int" pio_flags=0) |
| | Packs a typed object to a string.
|
| |
| "int" | idc_parse_types ("char const *" input, "int" flags) |
| | idc_parse_types(input, flags) -> int
|
| |
| "PyObject *" | idc_get_type_raw ("ea_t" ea) |
| | idc_get_type_raw(ea) -> PyObject *
|
| |
| "PyObject *" | idc_get_local_type_raw ("int" ordinal) |
| | idc_get_local_type_raw(ordinal) -> (bytes, bytes)
|
| |
| "size_t" | idc_guess_type ("ea_t" ea) |
| | idc_guess_type(ea) -> str
|
| |
| "size_t" | idc_get_type ("ea_t" ea) |
| | idc_get_type(ea) -> str
|
| |
| "int" | idc_set_local_type ("int" ordinal, "char const *" dcl, "int" flags) |
| | idc_set_local_type(ordinal, dcl, flags) -> int
|
| |
| "size_t" | idc_get_local_type ("int" ordinal, "int" flags) |
| | idc_get_local_type(ordinal, flags) -> str
|
| |
| "PyObject *" | idc_print_type ("type_t const *" type, "p_list const *" fields, "char const *" name, "int" flags) |
| | idc_print_type(type, fields, name, flags) -> str
|
| |
| "size_t" | idc_get_local_type_name ("int" ordinal) |
| | idc_get_local_type_name(ordinal) -> str
|
| |
| "PyObject *" | get_named_type ("til_t" til, "char const *" name, "int" ntf_flags) |
| | Get a type data by its name.
|
| |
| "PyObject *" | get_named_type64 ("til_t" til, "char const *" name, "int" ntf_flags) |
| | get_named_type64(til, name, ntf_flags) -> (int, bytes, NoneType, NoneType, NoneType, int, int) See get_named_type() above.
|
| |
| "PyObject *" | print_decls ("text_sink_t" printer, "til_t" til, "PyObject *" py_ordinals, "uint32" flags) |
| | print_decls(printer, til, py_ordinals, flags) -> int Print types (and possibly their dependencies) in a format suitable for using in a header file.
|
| |
| "PyObject *" | remove_tinfo_pointer ("tinfo_t" tif, "char const *" name, "til_t" til) |
| | remove_tinfo_pointer(tif, name, til) -> (bool, NoneType), (bool, str) Remove pointer of a type.
|
| |
| "PyObject *" | get_numbered_type ("til_t" til, "uint32" ordinal) |
| | get_numbered_type(til, ordinal) -> (bytes, NoneType, NoneType, NoneType, int), (bytes, bytes, NoneType, NoneType, int) Retrieve a type by its ordinal number.
|
| |
| "tinfo_code_t" | set_numbered_type ("til_t" ti, "uint32" ordinal, "int" ntf_flags, "char const *" name, "type_t const *" type, "p_list const *" fields=None, "char const *" cmt=None, "p_list const *" fldcmts=None, "sclass_t const *" sclass=None) |
| | set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> tinfo_code_t
|
| |
1.12.0