| IDA SDK

Public Attributes | Public Member Functions | Static Public Member Functions | Public Types | List of all members
processor_t Struct Reference

## Detailed Description

Describes a processor module (IDP).

An IDP file may have only one such structure called LPH. The kernel will copy it to dbctx_t::ph.

## Public Attributes
int32 | version
| Expected kernel version, should be IDP_INTERFACE_VERSION.
int32 | id
| one of Processor IDs
uint32 | flag
| an ORed combination of Processor feature bits
uint32 | flag2
| an ORed combination of Processor additional feature bits
int32 | cnbits
| Number of bits in a byte for code segments (usually 8). More...
int32 | dnbits
| Number of bits in a byte for non-code segments (usually 8). More...
const asm_t *const * | assemblers
| pointer to array of target More...
hook_cb_t * | _notify
| Event notification handler.
const char *const * | reg_names
| array of register names
int32 | regs_num
| number of registers
size_t | tbyte_size
| Size of long double (tbyte) for this processor (meaningful only if asm_t::a_tbyte != nullptr)
char | real_width [4]
| Number of digits in floating numbers after the decimal point. More...
int32 | icode_return
| Icode of return instruction. It is ok to give any of possible return instructions.
void * | unused_slot
| Reserved, currently equals to nullptr.
Names
IDP module may support several compatible processors. The following arrays define processor names:
const char *const * | psnames
| short processor names (nullptr terminated). More...
const char *const * | plnames
| long processor names (nullptr terminated). More...
Segment registers
Segment register information (use virtual CS and DS registers if your processor doesn't have segment registers):
int32 | reg_first_sreg
| number of first segment register
int32 | reg_last_sreg
| number of last segment register
int32 | segreg_size
| size of a segment register in bytes
Virtual segment registers
If your processor doesn't have segment registers, you should define 2 virtual segment registers for CS and DS. Let's call them rVcs and rVds.
int32 | reg_code_sreg
| number of CS register
int32 | reg_data_sreg
| number of DS register
Empirics
const bytes_t * | codestart
| Array of typical code start sequences. More...
const bytes_t * | retcodes
| Array of 'return' instruction opcodes. More...

## Public Member Functions
bool | has_idp_opts (void) const
| #PR_IDP_OPTS
bool | has_segregs (void) const
| PR_SEGS
bool | use32 (void) const
| PR_USE64 or PR_USE32
bool | use64 (void) const
| PR_USE64
bool | ti (void) const
| PR_TYPEINFO
bool | stkup (void) const
| PR_STACK_UP
bool | use_tbyte (void) const
| PR_USE_TBYTE
bool | use_mappings (void) const
| PR2_MAPPINGS
bool | has_code16_bit (void) const
| PR2_CODE16_BIT
bool | supports_macros (void) const
| PR2_MACRO
bool | supports_calcrel (void) const
| PR2_USE_CALCREL
bool | calcrel_in_bits (void) const
| PR2_REL_BITS
int | get_default_segm_bitness (bool is_64bit_app) const
| Get default segment bitness. More...
int | get_proc_index ()
bool | delay_slot_insn (ea_t *ea, bool *bexec, bool *fexec)
| Helper function to get the delay slot instruction.
ssize_t | privrange_changed (const range_t &old_privrange, adiff_t delta, qstring *errbuf=nullptr)
ssize_t | cvt64_supval (nodeidx_t node, uchar tag, nodeidx_t idx, const uchar *data, size_t datlen, qstring *errbuf=nullptr)
ssize_t | cvt64_hashval (nodeidx_t node, uchar tag, const char *name, const uchar *data, size_t datlen, qstring *errbuf=nullptr)
int | get_stkvar_scale (void)
| Get the stack variable scaling factor. More...
void | ensure_processor (void)
size_t | sizeof_ldbl () const
| Get size of long double.
bool | is_funcarg_off (const func_t *pfn, uval_t frameoff) const
| Does the given offset lie within the arguments section?
sval_t | lvar_off (const func_t *pfn, uval_t frameoff) const
| Does the given offset lie within the local variables section?
bool | is_lumina_usable () const
Byte size
Number of 8bit bytes required to hold one byte of the target processor.
int | cbsize (void)
| for code segments
int | dbsize (void)
| for non-code segments

## Static Public Member Functions
static ssize_t | notify (event_t event_code,...)
static ssize_t | init (const char *idp_modname)
static ssize_t | term ()
static ssize_t | newprc (int pnum, bool keep_cfg)
static ssize_t | newasm (int asmnum)
static ssize_t | asm_installed (int asmnum)
static ssize_t | newfile (const char *fname)
static ssize_t | oldfile (const char *fname)
static ssize_t | newbinary (const char *filename, qoff64_t fileoff, ea_t basepara, ea_t binoff, uint64 nbytes)
static ssize_t | endbinary (bool ok)
static ssize_t | creating_segm (segment_t *seg)
static ssize_t | assemble (uchar *_bin, ea_t ea, ea_t cs, ea_t ip, bool _use32, const char *line)
static ssize_t | ana_insn (insn_t *out)
static ssize_t | emu_insn (const insn_t &insn)
static ssize_t | out_header (outctx_t &ctx)
static ssize_t | out_footer (outctx_t &ctx)
static ssize_t | out_segstart (outctx_t &ctx, segment_t *seg)
static ssize_t | out_segend (outctx_t &ctx, segment_t *seg)
static ssize_t | out_assumes (outctx_t &ctx)
static ssize_t | out_insn (outctx_t &ctx)
static ssize_t | out_mnem (outctx_t &ctx)
static ssize_t | out_operand (outctx_t &ctx, const op_t &op)
static ssize_t | out_data (outctx_t &ctx, bool analyze_only)
static ssize_t | out_label (outctx_t &ctx, const char *colored_name)
static ssize_t | out_special_item (outctx_t &ctx, uchar segtype)
static ssize_t | gen_stkvar_def2 (outctx_t &ctx, const struct udm_t *mptr, sval_t v, tid_t tid)
static ssize_t | gen_regvar_def (outctx_t &ctx, regvar_t *v)
static ssize_t | gen_src_file_lnnum (outctx_t &ctx, const char *file, size_t lnnum)
static ssize_t | rename (ea_t ea, const char *new_name, int flags)
static ssize_t | may_show_sreg (ea_t current_ea)
static ssize_t | coagulate (ea_t start_ea)
static void | auto_queue_empty (int type)
static ssize_t | func_bounds (int *possible_return_code, func_t *pfn, ea_t max_func_end_ea)
static ssize_t | may_be_func (const insn_t &insn, int state)
static ssize_t | is_sane_insn (const insn_t &insn, int no_crefs)
static ssize_t | cmp_operands (const op_t &op1, const op_t &op2)
static ssize_t | is_jump_func (func_t *pfn, ea_t *jump_target, ea_t *func_pointer)
static ssize_t | is_basic_block_end (const insn_t &insn, bool call_insn_stops_block)
static ssize_t | getreg (uval_t *rv, int regnum)
static ssize_t | undefine (ea_t ea)
static ssize_t | moving_segm (segment_t *seg, ea_t to, int flags)
static ssize_t | is_sp_based (const insn_t &insn, const op_t &x)
static ssize_t | is_far_jump (int icode)
static ssize_t | is_call_insn (const insn_t &insn)
static ssize_t | is_ret_insn (const insn_t &insn, bool strict)
static ssize_t | is_align_insn (ea_t ea)
static ssize_t | can_have_type (const op_t &op)
static ssize_t | get_stkvar_scale_factor ()
static ssize_t | demangle_name (int32 *res, qstring *out, const char *name, uint32 disable_mask, int demreq)
static ssize_t | create_flat_group (ea_t image_base, int bitness, sel_t dataseg_sel)
static ssize_t | is_alloca_probe (ea_t ea)
static ssize_t | get_reg_name (qstring *buf, int reg, size_t width, int reghi)
static ssize_t | gen_asm_or_lst (bool starting, FILE *fp, bool is_asm, int flags, void *outline)
static ssize_t | gen_map_file (int *nlines, FILE *fp)
static ssize_t | get_autocmt (qstring *buf, const insn_t &insn)
static ssize_t | loader_elf_machine (linput_t *li, int machine_type, const char **p_procname, proc_def_t **p_pd, elf_loader_t *ldr, reader_t *reader)
static ssize_t | is_indirect_jump (const insn_t &insn)
static ssize_t | verify_noreturn (func_t *pfn)
static ssize_t | verify_sp (func_t *pfn)
static ssize_t | create_func_frame (func_t *pfn)
static ssize_t | get_frame_retsize (int *retsize, const func_t *pfn)
static ssize_t | analyze_prolog (ea_t fct_ea)
static ssize_t | calc_spdelta (sval_t *spdelta, const insn_t &ins)
static ssize_t | calcrel (bytevec_t *out_relbits, size_t *out_consumed, ea_t ea)
static ssize_t | get_reg_accesses (reg_accesses_t *accvec, const insn_t &insn, int flags)
static ssize_t | is_control_flow_guard (int *p_reg, const insn_t *insn)
static ssize_t | find_reg_value (uval_t *out, const insn_t &insn, int reg)
static ssize_t | find_op_value (uval_t *out, const insn_t &insn, int op)
static ssize_t | treat_hindering_item (ea_t hindering_item_ea, flags64_t new_item_flags, ea_t new_item_ea, asize_t new_item_length)
static ssize_t | extract_address (ea_t *out_ea, ea_t screen_ea, const char *string, size_t x)
static ssize_t | str2reg (const char *regname)
static ssize_t | is_switch (switch_info_t *si, const insn_t &insn)
static ssize_t | create_switch_xrefs (ea_t jumpea, const switch_info_t &si)
static ssize_t | calc_switch_cases (void *casevec, eavec_t *targets, ea_t insn_ea, const switch_info_t &si)
static ssize_t | get_bg_color (bgcolor_t *color, ea_t ea)
static ssize_t | validate_flirt_func (ea_t start_ea, const char *funcname)
static ssize_t | get_operand_string (qstring *buf, const insn_t &insn, int opnum)
static ssize_t | add_cref (ea_t from, ea_t to, cref_t type)
static ssize_t | add_dref (ea_t from, ea_t to, dref_t type)
static ssize_t | del_cref (ea_t from, ea_t to, bool expand)
static ssize_t | del_dref (ea_t from, ea_t to)
static ssize_t | coagulate_dref (ea_t from, ea_t to, bool may_define, ea_t *code_ea)
static const char * | set_idp_options (const char *keyword, int vtype, const void *value, bool idb_loaded=true)
static ssize_t | set_proc_options (const char *options, int confidence)
static ssize_t | adjust_libfunc_ea (const idasgn_t &sig, const libfunc_t &libfun, ea_t *ea)
static fpvalue_error_t | realcvt (void *m, fpvalue_t *e, uint16 swt)
static ssize_t | adjust_refinfo (refinfo_t *ri, ea_t ea, int n, const fixup_data_t &fd)
static ssize_t | is_cond_insn (const insn_t &insn)
static ssize_t | set_code16_mode (ea_t ea, bool code16=true)
static bool | get_code16_mode (ea_t ea)
static ssize_t | next_exec_insn (ea_t *target, ea_t ea, int tid, regval_getter_t *_getreg, const regval_t &regvalues)
static ssize_t | calc_step_over (ea_t *target, ea_t ip)
static ssize_t | get_macro_insn_head (ea_t *head, ea_t ip)
static ssize_t | get_dbr_opnum (int *opnum, const insn_t &insn)
static ssize_t | insn_reads_tbit (const insn_t &insn, regval_getter_t *_getreg, const regval_t &regvalues)
static ssize_t | get_idd_opinfo (idd_opinfo_t *opinf, ea_t ea, int n, int thread_id, regval_getter_t *_getreg, const regval_t &regvalues)
static ssize_t | calc_next_eas (eavec_t *res, const insn_t &insn, bool over)
static ssize_t | clean_tbit (ea_t ea, regval_getter_t *_getreg, const regval_t &regvalues)
static const char * | get_reg_info (const char *regname, bitrange_t *bitrange)
| Get register information - useful for registers like al, ah, dil, etc. More...
static ssize_t | update_call_stack (call_stack_t *stack, int tid, regval_getter_t *_getreg, const regval_t &regvalues)
static ssize_t | setup_til ()
static ssize_t | max_ptr_size ()
static ssize_t | calc_cdecl_purged_bytes (ea_t ea)
static ssize_t | equal_reglocs (const argloc_t &a1, const argloc_t &a2)
static ssize_t | decorate_name (qstring *outbuf, const char *name, bool mangle, cm_t cc, const tinfo_t &type)
static ssize_t | calc_retloc (argloc_t *retloc, const tinfo_t &rettype, cm_t cc)
static ssize_t | calc_varglocs (func_type_data_t *ftd, regobjs_t *regs, relobj_t *stkargs, int nfixed)
static ssize_t | calc_arglocs (func_type_data_t *fti)
static ssize_t | use_stkarg_type (ea_t ea, const funcarg_t &arg)
static ssize_t | use_regarg_type (int *idx, ea_t ea, void *rargs)
static ssize_t | use_arg_types (ea_t ea, func_type_data_t *fti, void *rargs)
static ssize_t | calc_purged_bytes (int *p_purged_bytes, const func_type_data_t &fti)
static ssize_t | get_stkarg_area_info (stkarg_area_info_t *out, cm_t cc)
static ssize_t | get_cc_regs (callregs_t *regs, cm_t cc)
static ssize_t | get_simd_types (void *out, const simd_info_t *simd_attrs, const argloc_t *argloc, bool create_tifs)
static ssize_t | arg_addrs_ready (ea_t caller, int n, const tinfo_t &tif, ea_t *addrs)
static ssize_t | adjust_argloc (argloc_t *argloc, const tinfo_t *type, int size)
static ssize_t | lower_func_type (intvec_t *argnums, func_type_data_t *fti)
static ssize_t | get_abi_info (qstrvec_t *abi_names, qstrvec_t *abi_opts, comp_t comp)
static ssize_t | arch_changed ()
static ssize_t | create_merge_handlers (merge_data_t *md)
static reg_finder_t * | get_regfinder ()

## Public Types
enum | event_t { ev_init , ev_term , ev_newprc , ev_newasm , ev_newfile , ev_oldfile , ev_newbinary , ev_endbinary , ev_set_idp_options , ev_set_proc_options , ev_ana_insn , ev_emu_insn , ev_out_header , ev_out_footer , ev_out_segstart , ev_out_segend , ev_out_assumes , ev_out_insn , ev_out_mnem , ev_out_operand , ev_out_data , ev_out_label , ev_out_special_item , ev_obsolete3 , ev_gen_regvar_def , ev_gen_src_file_lnnum , ev_creating_segm , ev_moving_segm , ev_coagulate , ev_undefine , ev_treat_hindering_item , ev_rename , ev_is_far_jump , ev_is_sane_insn , ev_is_cond_insn , ev_is_call_insn , ev_is_ret_insn , ev_may_be_func , ev_is_basic_block_end , ev_is_indirect_jump , ev_is_insn_table_jump , ev_is_switch , ev_calc_switch_cases , ev_create_switch_xrefs , ev_is_align_insn , ev_is_alloca_probe , ev_delay_slot_insn , ev_is_sp_based , ev_can_have_type , ev_cmp_operands , ev_adjust_refinfo , ev_get_operand_string , ev_get_reg_name , ev_str2reg , ev_get_autocmt , ev_get_bg_color , ev_is_jump_func , ev_func_bounds , ev_verify_sp , ev_verify_noreturn , ev_create_func_frame , ev_get_frame_retsize , ev_get_stkvar_scale_factor , ev_demangle_name , ev_add_cref , ev_add_dref , ev_del_cref , ev_del_dref , ev_coagulate_dref , ev_may_show_sreg , ev_loader_elf_machine , ev_auto_queue_empty , ev_validate_flirt_func , ev_adjust_libfunc_ea , ev_assemble , ev_extract_address , ev_realcvt , ev_gen_asm_or_lst , ev_gen_map_file , ev_create_flat_group , ev_getreg , ev_analyze_prolog , ev_calc_spdelta , ev_calcrel , ev_find_reg_value , ev_find_op_value , ev_replaying_undo , ev_ending_undo , ev_set_code16_mode , ev_get_code16_mode , ev_get_procmod , ev_asm_installed , ev_get_reg_accesses , ev_is_control_flow_guard , ev_broadcast , ev_create_merge_handlers , ev_privrange_changed , ev_cvt64_supval , ev_cvt64_hashval , ev_get_regfinder , ev_gen_stkvar_def2 , ev_last_cb_before_debugger , ev_next_exec_insn = 1000 , ev_calc_step_over , ev_calc_next_eas , ev_get_macro_insn_head , ev_get_dbr_opnum , ev_insn_reads_tbit , ev_clean_tbit , ev_get_idd_opinfo , ev_get_reg_info , ev_update_call_stack , ev_last_cb_before_type_callbacks , ev_setup_til = 2000 , ev_get_abi_info , ev_max_ptr_size , ev_get_default_enum_size , ev_get_cc_regs , ev_obsolete1 , ev_obsolete2 , ev_get_simd_types , ev_calc_cdecl_purged_bytes , ev_calc_purged_bytes , ev_calc_retloc , ev_calc_arglocs , ev_calc_varglocs , ev_adjust_argloc , ev_lower_func_type , ev_equal_reglocs , ev_use_stkarg_type , ev_use_regarg_type , ev_use_arg_types , ev_arg_addrs_ready , ev_decorate_name , ev_arch_changed , ev_get_stkarg_area_info , ev_last_cb_before_loader , ev_loader =3000 }
| Callback notification codes. More...
typedef const regval_t &idaapi | regval_getter_t(const char *name, const regval_t *regvalues)

## Instruction set
int32 | instruc_start
| icode of the first instruction
int32 | instruc_end
| icode of the last instruction + 1
const instruc_t * | instruc
| Array of instructions.
bool | is_canon_insn (uint16 itype) const
| Does the given value specify a valid instruction for this instruction set?. More...
const char * | get_canon_mnem (uint16 itype) const
| Get the instruction name.
uint32 | get_canon_feature (uint16 itype) const
| Get the instruction features (combination of Instruction feature bits)

## Member Enumeration Documentation

## ◆ event_t

enum processor_t::event_t

Callback notification codes.

These are passed to notify() when certain events occur in the kernel, allowing the processor module to take the appropriate action.

If you are not developing a processor module, you do not need to use the codes directly many of them already have a corresponding function to use instead ( is_call_insn vs is_call_insn(ea_t), for example).

If you are developing a processor module, your notify() function must implement the desired behavior when called with a given code. Not all events need to be handled, some of them are optional.

Enumerator
  ev_init | The IDP module is just loaded. Parameters
  idp_modname | (const char *) processor module name
  Return values
  <0 | on failure
ev_term | The IDP module is being unloaded.
  ev_newprc | Before changing processor type. Parameters
  pnum | (int) processor number in the array of processor names
  keep_cfg | (bool) true: do not modify kernel configuration
  Return values
  1 | ok
  <0 | prohibit
  ev_newasm | Before setting a new assembler. Parameters
  asmnum | (int) See also ev_asm_installed
  ev_newfile | A new file has been loaded. Parameters
  fname | (char *) input file name
  ev_oldfile | An old file has been loaded. Parameters
  fname | (char *) input file name
  ev_newbinary | IDA is about to load a binary file. Parameters
  filename | (char *) binary file name
  fileoff | (qoff64_t) offset in the file
  basepara | (::ea_t) base loading paragraph
  binoff | (::ea_t) loader offset
  nbytes | (::uint64) number of bytes to load
  ev_endbinary | IDA has loaded a binary file. Parameters
  ok | (bool) file loaded successfully?
  ev_set_idp_options | Set IDP-specific configuration option Also see set_options_t in config.hpp. Parameters
  keyword | (const char *)
  value_type | (int)
  value | (const void *)
  errbuf | (const char **) - a error message will be returned here (can be nullptr)
  idb_loaded | (bool) true if the ev_oldfile/ev_newfile events have been generated
  Return values
  1 | ok
  0 | not implemented
  -1 | error (and message in errbuf)
  ev_set_proc_options | Called if the user specified an option string in the command line: -p<processor name>:<options>. Can be used for setting a processor subtype. Also called if option string is passed to set_processor_type() and IDC's SetProcessorType(). Parameters
  options | (const char *)
  confidence | (int) 0: loader's suggestion 1: user's decision
  Return values
  <0 | if bad option string
  ev_ana_insn | Analyze one instruction and fill 'out' structure. This function shouldn't change the database, flags or anything else. All these actions should be performed only by emu_insn() function. \insn_t{ea} contains address of instruction to analyze. Parameters
  out | (insn_t *)
  Returns length of the instruction in bytes, 0 if instruction can't be decoded. Return values
  0 | if instruction can't be decoded.
  ev_emu_insn | Emulate instruction, create cross-references, plan to analyze subsequent instructions, modify flags etc. Upon entrance to this function, all information about the instruction is in 'insn' structure. Parameters
  insn | (const insn_t *)
  Return values
  1 | ok
  -1 | the kernel will delete the instruction
  ev_out_header | Function to produce start of disassembled text. Parameters
  outctx | (outctx_t *)
  Return values
  void |
  ev_out_footer | Function to produce end of disassembled text. Parameters
  outctx | (outctx_t *)
  Return values
  void |
  ev_out_segstart | Function to produce start of segment. Parameters
  outctx | (outctx_t *)
  seg | (segment_t *)
  Return values
  1 | ok
  0 | not implemented
  ev_out_segend | Function to produce end of segment. Parameters
  outctx | (outctx_t *)
  seg | (segment_t *)
  Return values
  1 | ok
  0 | not implemented
  ev_out_assumes | Function to produce assume directives when segment register value changes. Parameters
  outctx | (outctx_t *)
  Return values
  1 | ok
  0 | not implemented
  ev_out_insn | Generate text representation of an instruction in 'ctx.insn' outctx_t provides functions to output the generated text. This function shouldn't change the database, flags or anything else. All these actions should be performed only by emu_insn() function. Parameters
  outctx | (outctx_t *)
  Return values
  void |
  ev_out_mnem | Generate instruction mnemonics. This callback should append the colored mnemonics to ctx.outbuf Optional notification, if absent, out_mnem will be called. Parameters
  outctx | (outctx_t *)
  Return values
  1 | if appended the mnemonics
  0 | not implemented
  ev_out_operand | Generate text representation of an instruction operand outctx_t provides functions to output the generated text. All these actions should be performed only by emu_insn() function. Parameters
  outctx | (outctx_t *)
  op | (const op_t *)
  Return values
  1 | ok
  -1 | operand is hidden
  ev_out_data | Generate text representation of data items This function may change the database and create cross-references if analyze_only is set. Parameters
  outctx | (outctx_t *)
  analyze_only | (bool)
  Return values
  1 | ok
  0 | not implemented
  ev_out_label | The kernel is going to generate an instruction label line or a function header. Parameters
  outctx | (outctx_t *)
  colored_name | (const char *)
  Return values
  <0 | if the kernel should not generate the label
  0 | not implemented or continue
  ev_out_special_item | Generate text representation of an item in a special segment i.e. absolute symbols, externs, communal definitions etc Parameters
  outctx | (outctx_t *)
  segtype | (uchar)
  Return values
  1 | ok
  0 | not implemented
  -1 | overflow
ev_obsolete3 | ev_gen_stkvar_def is obsolete, check ev_gen_stkvar_def2 below
  ev_gen_regvar_def | Generate register variable definition line. Parameters
  outctx | (outctx_t *)
  v | (regvar_t *)
  Return values
  >0 | ok, generated the definition text
  0 | not implemented
  ev_gen_src_file_lnnum | Callback: generate analog of: < #line "file.c" 123 < directive. Parameters
  outctx | (outctx_t *) output context
  file | (const char *) source file (may be nullptr)
  lnnum | (size_t) line number
  Return values
  1 | directive has been generated
  0 | not implemented
  ev_creating_segm | A new segment is about to be created. Parameters
  seg | (segment_t *)
  Return values
  1 | ok
  <0 | segment should not be created
  ev_moving_segm | May the kernel move the segment? Parameters
  seg | (segment_t *) segment to move
  to | (::ea_t) new segment start address
  flags | (int) combination of Move segment flags
  Return values
  0 | yes
  <0 | the kernel should stop
  ev_coagulate | Try to define some unexplored bytes. This notification will be called if the kernel tried all possibilities and could not find anything more useful than to convert to array of bytes. The module can help the kernel and convert the bytes into something more useful. Parameters
  start_ea | (::ea_t)
Returns number of converted bytes
  ev_undefine | An item in the database (insn or data) is being deleted. Parameters
  ea | (ea_t)
  Return values
  1 | do not delete srranges at the item end
  0 | srranges can be deleted
  ev_treat_hindering_item | An item hinders creation of another item. Parameters
  hindering_item_ea | (::ea_t)
  new_item_flags | (flags64_t) (0 for code)
  new_item_ea | (::ea_t)
  new_item_length | (::asize_t)
  Return values
  0 | no reaction
  !=0 | the kernel may delete the hindering item
  ev_rename | The kernel is going to rename a byte. Parameters
  ea | (::ea_t)
  new_name | (const char *)
  flags | (int) Set name flags
  Return values
  <0 | if the kernel should not rename it.
  2 | to inhibit the notification. I.e., the kernel should not rename, but 'set_name()' should return 'true'. also see renamed the return value is ignored when kernel is going to delete name
  ev_is_far_jump | is indirect far jump or call instruction? meaningful only if the processor has 'near' and 'far' reference types Parameters
  icode | (int)
  Return values
  0 | not implemented
  1 | yes
  -1 | no
  ev_is_sane_insn | Is the instruction sane for the current file type?. Parameters
  insn | (const insn_t*) the instruction
  no_crefs | (int) 1: the instruction has no code refs to it. ida just tries to convert unexplored bytes to an instruction (but there is no other reason to convert them into an instruction) 0: the instruction is created because of some coderef, user request or another weighty reason.
  Return values
  >=0 | ok
  <0 | no, the instruction isn't likely to appear in the program
  ev_is_cond_insn | Is conditional instruction? Parameters
  insn | (const insn_t *) instruction address
  Return values
  1 | yes
  -1 | no
  0 | not implemented or not instruction
  ev_is_call_insn | Is the instruction a "call"? Parameters
  insn | (const insn_t *) instruction
  Return values
  0 | unknown
  <0 | no
  1 | yes
  ev_is_ret_insn | Is the instruction a "return"? Parameters
  insn | (const insn_t *) instruction
  strict | (bool) 1: report only ret instructions 0: include instructions like "leave" which begins the function epilog
  Return values
  0 | unknown
  <0 | no
  1 | yes
  ev_may_be_func | Can a function start here? Parameters
  insn | (const insn_t*) the instruction
  state | (int) autoanalysis phase 0: creating functions 1: creating chunks
Returns probability 1..100 Note Actually IDA uses 3 intervals of a probability: 0..50 not a function, 51..99 a function (IDA needs another proof), 100 a function (no other proofs needed)
  ev_is_basic_block_end | Is the current instruction end of a basic block?. This function should be defined for processors with delayed jump slots. Parameters
  insn | (const insn_t*) the instruction
  call_insn_stops_block | (bool)
  Return values
  0 | unknown
  <0 | no
  1 | yes
  ev_is_indirect_jump | Determine if instruction is an indirect jump. If CF_JUMP bit cannot describe all jump types jumps, please define this callback. Parameters
  insn | (const insn_t*) the instruction
  Return values
  0 | use CF_JUMP
  1 | no
  2 | yes
ev_is_insn_table_jump | Reserved.
  ev_is_switch | Find 'switch' idiom or override processor module's decision. It will be called for instructions marked with CF_JUMP. Parameters
  si | (switch_info_t *), out
  insn | (const insn_t *) instruction possibly belonging to a switch
  Return values
  1 | switch is found, 'si' is filled. IDA will create the switch using the filled 'si'
  -1 | no switch found. This value forbids switch creation by the processor module
  0 | not implemented
  ev_calc_switch_cases | Calculate case values and targets for a custom jump table. Parameters
  casevec | (::casevec_t *) vector of case values (may be nullptr)
  targets | (eavec_t *) corresponding target addresses (my be nullptr)
  insn_ea | (::ea_t) address of the 'indirect jump' instruction
  si | (switch_info_t *) switch information
  Return values
  1 | ok
  <=0 | failed
  ev_create_switch_xrefs | Create xrefs for a custom jump table. Parameters
  jumpea | (::ea_t) address of the jump insn
  si | (const switch_info_t *) switch information
Returns must return 1 Must be implemented if module uses custom jump tables, SWI_CUSTOM
  ev_is_align_insn | Is the instruction created only for alignment purposes?. Do not directly call this function, use is_align_insn() Parameters
  ea | (ea_t) - instruction address
  Return values
  number | of bytes in the instruction
  ev_is_alloca_probe | Does the function at 'ea' behave as __alloca_probe? Parameters
  ea | (::ea_t)
  Return values
  1 | yes
  0 | no
  ev_delay_slot_insn | Get delay slot instruction. Parameters
  ea | (::ea_t *) in: instruction address in question, out: (if the answer is positive) if the delay slot contains valid insn: the address of the delay slot insn else: BADADDR (invalid insn, e.g. a branch)
  bexec | (bool *) execute slot if jumping, initially set to 'true'
  fexec | (bool *) execute slot if not jumping, initally set to 'true'
  Return values
  1 | positive answer
  <=0 | ordinary insn
Note Input EA may point to the instruction with a delay slot or to the delay slot instruction itself.
  ev_is_sp_based | Check whether the operand is relative to stack pointer or frame pointer This event is used to determine how to output a stack variable If not implemented, then all operands are sp based by default. Implement this event only if some stack references use frame pointer instead of stack pointer. Parameters
  mode | (int *) out, combination of SP/FP operand flags
  insn | (const insn_t *)
  op | (const op_t *)
  Return values
  0 | not implemented
  1 | ok
  ev_can_have_type | Can the operand have a type as offset, segment, decimal, etc? (for example, a register AX can't have a type, meaning that the user can't change its representation. see bytes.hpp for information about types and flags) Parameters
  op | (const op_t *)
  Return values
  0 | unknown
  <0 | no
  1 | yes
  ev_cmp_operands | Compare instruction operands. Parameters
  op1 | (const op_t*)
  op2 | (const op_t*)
  Return values
  1 | equal
  -1 | not equal
  0 | not implemented
  ev_adjust_refinfo | Called from apply_fixup before converting operand to reference. Can be used for changing the reference info. (e.g. the PPC module adds REFINFO_NOBASE for some references) Parameters
  ri | (refinfo_t *)
  ea | (::ea_t) instruction address
  n | (int) operand number
  fd | (const fixup_data_t *)
  Return values
  <0 | do not create an offset
  0 | not implemented or refinfo adjusted
  ev_get_operand_string | Request text string for operand (cli, java, ...). Parameters
  buf | (qstring *)
  insn | (const insn_t*) the instruction
  opnum | (int) operand number, -1 means any string operand
  Return values
  0 | no string (or empty string)
  >0 | original string length without terminating zero
  ev_get_reg_name | Generate text representation of a register. Most processor modules do not need to implement this callback. It is useful only if processor_t::reg_names[reg] does not provide the correct register name. Parameters
  buf | (qstring *) output buffer
  reg | (int) internal register number as defined in the processor module
  width | (size_t) register width in bytes
  reghi | (int) if not -1 then this function will return the register pair
  Return values
  -1 | if error
  strlen(buf) | if success
  ev_str2reg | Convert a register name to a register number. The register number is the register index in the processor_t::reg_names array Most processor modules do not need to implement this callback It is useful only if processor_t::reg_names[reg] does not provide the correct register names Parameters
  regname | (const char *)
  Return values
  register | number + 1
  0 | not implemented or could not be decoded
  ev_get_autocmt | Callback: get dynamic auto comment. Will be called if the autocomments are enabled and the comment retrieved from ida.int starts with '$!'. 'insn' contains valid info. Parameters
  buf | (qstring *) output buffer
  insn | (const insn_t*) the instruction
  Return values
  1 | new comment has been generated
  0 | callback has not been handled. the buffer must not be changed in this case
  ev_get_bg_color | Get item background color. Plugins can hook this callback to color disassembly lines dynamically Parameters
  color | (bgcolor_t *), out
  ea | (::ea_t)
  Return values
  0 | not implemented
  1 | color set
  ev_is_jump_func | Is the function a trivial "jump" function?. Parameters
  pfn | (func_t *)
  jump_target | (::ea_t *)
  func_pointer | (::ea_t *)
  Return values
  <0 | no
  0 | don't know
  1 | yes, see 'jump_target' and 'func_pointer'
  ev_func_bounds | find_func_bounds() finished its work. The module may fine tune the function bounds Parameters
  possible_return_code | (int *), in/out
  pfn | (func_t *)
  max_func_end_ea | (::ea_t) (from the kernel's point of view)
  Return values
  void |
  ev_verify_sp | All function instructions have been analyzed. Now the processor module can analyze the stack pointer for the whole function Parameters
  pfn | (func_t *)
  Return values
  0 | ok
  <0 | bad stack pointer
  ev_verify_noreturn | The kernel wants to set 'noreturn' flags for a function. Parameters
  pfn | (func_t *)
  Return values
  0 | ok. any other value: do not set 'noreturn' flag
  ev_create_func_frame | Create a function frame for a newly created function Set up frame size, its attributes etc. Parameters
  pfn | (func_t *)
  Return values
  1 | ok
  0 | not implemented
-   ev_get_frame_retsize | Get size of function return address in bytes If this event is not implemented, the kernel will assume. 8 bytes for 64-bit function 4 bytes for 32-bit function 2 bytes otherwise Parameters
    frsize | (int *) frame size (out)
    pfn | (const func_t *), can't be nullptr
    Return values
    1 | ok
    0 | not implemented
  ev_get_stkvar_scale_factor | Should stack variable references be multiplied by a coefficient before being used in the stack frame?. Currently used by TMS320C55 because the references into the stack should be multiplied by 2 Returns scaling factor Return values
  0 | not implemented
Note PR_SCALE_STKVARS should be set to use this callback
  ev_demangle_name | Demangle a C++ (or another language) name into a user-readable string. This event is called by demangle_name() Parameters
  res | (int32 *) value to return from demangle_name()
  out | (qstring *) output buffer. may be nullptr
  name | (const char *) mangled name
  disable_mask | (uint32) flags to inhibit parts of output or compiler info/other (see MNG_)
  demreq | (demreq_type_t) operation to perform
  Return values
  1 | if success
  0 | not implemented
Note if you call demangle_name() from the handler, protect against recursion!
  ev_add_cref | A code reference is being created. Parameters
  from | (::ea_t)
  to | (::ea_t)
  type | (cref_t)
  Return values
  <0 | cancel cref creation
  0 | not implemented or continue
  ev_add_dref | A data reference is being created. Parameters
  from | (::ea_t)
  to | (::ea_t)
  type | (dref_t)
  Return values
  <0 | cancel dref creation
  0 | not implemented or continue
  ev_del_cref | A code reference is being deleted. Parameters
  from | (::ea_t)
  to | (::ea_t)
  expand | (bool)
  Return values
  <0 | cancel cref deletion
  0 | not implemented or continue
  ev_del_dref | A data reference is being deleted. Parameters
  from | (::ea_t)
  to | (::ea_t)
  Return values
  <0 | cancel dref deletion
  0 | not implemented or continue
  ev_coagulate_dref | Data reference is being analyzed. plugin may correct 'code_ea' (e.g. for thumb mode refs, we clear the last bit) Parameters
  from | (::ea_t)
  to | (::ea_t)
  may_define | (bool)
  code_ea | (::ea_t *)
  Return values
  <0 | failed dref analysis, >0 done dref analysis
  0 | not implemented or continue
  ev_may_show_sreg | The kernel wants to display the segment registers in the messages window. Parameters
  current_ea | (::ea_t)
  Return values
  <0 | if the kernel should not show the segment registers. (assuming that the module has done it)
  0 | not implemented
  ev_loader_elf_machine | ELF loader machine type checkpoint. A plugin check of the 'machine_type'. If it is the desired one, the the plugin fills 'p_procname' with the processor name (one of the names present in processor_t::psnames). 'p_pd' is used to handle relocations, otherwise can be left untouched. This event occurs for each newly loaded ELF file Parameters
  li | (linput_t *)
  machine_type | (int)
  p_procname | (const char **)
  p_pd | (proc_def_t **) (see ldr\elf.h)
  loader | (elf_loader_t *) (see ldr\elf.h)
  reader | (reader_t *) (see ldr\elf.h)
  Return values
  e_machine | value (if it is different from the original e_machine value, procname and 'p_pd' will be ignored and the new value will be used) before replacing pd it is a good idea to delete the previous instance using 'delete pd;' The 'loader' and 'reader' arguments are available starting from IDA v7.7.
  ev_auto_queue_empty | One analysis queue is empty. Parameters
  type | (atype_t)
  Return values
  void | see also idb_event::auto_empty_finally
  ev_validate_flirt_func | Flirt has recognized a library function. This callback can be used by a plugin or proc module to intercept it and validate such a function. Parameters
  start_ea | (::ea_t)
  funcname | (const char *)
  Return values
  -1 | do not create a function,
  0 | function is validated
  ev_adjust_libfunc_ea | Called when a signature module has been matched against bytes in the database. This is used to compute the offset at which a particular module's libfunc should be applied. Parameters
  sig | (const idasgn_t *)
  libfun | (const libfunc_t *)
  ea | (::ea_t *)
  Note 'ea' initially contains the ea_t of the start of the pattern match Return values
  1 | the ea_t pointed to by the third argument was modified.
  <=0 | not modified. use default algorithm.
  ev_assemble | Assemble an instruction. (display a warning if an error is found). Parameters
  bin | (uchar *) pointer to output opcode buffer
  ea | (::ea_t) linear address of instruction
  cs | (::ea_t) cs of instruction
  ip | (::ea_t) ip of instruction
  use32 | (bool) is 32bit segment?
  line | (const char *) line to assemble
Returns size of the instruction in bytes
  ev_extract_address | Extract address from a string. Parameters
  out_ea | (ea_t *), out
  screen_ea | (ea_t)
  string | (const char *)
  position | (size_t)
  Return values
  1 | ok
  0 | kernel should use the standard algorithm
  -1 | error
  ev_realcvt | Floating point -> IEEE conversion. Parameters
  m | (void *) ptr to processor-specific floating point value
  e | (fpvalue_t *) IDA representation of a floating point value
  swt | (uint16) operation (see realcvt() in ieee.h)
  Return values
  0 | not implemented
ref REAL_ERROR_ otherwise
  ev_gen_asm_or_lst | Callback: generating asm or lst file. The kernel calls this callback twice, at the beginning and at the end of listing generation. The processor module can intercept this event and adjust its output Parameters
  starting | (bool) beginning listing generation
  fp | (FILE *) output file
  is_asm | (bool) true:assembler, false:listing
  flags | (int) flags passed to gen_file()
  outline | (html_line_cb_t **) ptr to ptr to outline callback. if this callback is defined for this code, it will be used by the kernel to output the generated lines
  Return values
  void |
  ev_gen_map_file | Generate map file. If not implemented the kernel itself will create the map file. Parameters
  nlines | (int *) number of lines in map file (-1 means write error)
  fp | (FILE *) output file
  Return values
  0 | not implemented
  1 | ok
  -1 | write error
  ev_create_flat_group | Create special segment representing the flat group. Parameters
  image_base | (::ea_t)
  bitness | (int)
  dataseg_sel | (::sel_t) return value is ignored
  ev_getreg | IBM PC only internal request, should never be used for other purpose Get register value by internal index. Parameters
  regval | (uval_t *), out
  regnum | (int)
  Return values
  1 | ok
  0 | not implemented
  -1 | failed (undefined value or bad regnum)
  ev_analyze_prolog | Analyzes function prolog, epilog, and updates purge, and function attributes. Parameters
  ea | (::ea_t) start of function
  Return values
  1 | ok
  0 | not implemented
  ev_calc_spdelta | Calculate amount of change to sp for the given insn. This event is required to decompile code snippets. Parameters
  spdelta | (sval_t *)
  insn | (const insn_t *)
  Return values
  1 | ok
  0 | not implemented
ev_calcrel | Reserved.
  ev_find_reg_value | Find register value via a register tracker. The returned value in 'out' is valid before executing the instruction. Parameters
  out | (uval_t *) pointer to the found value
  pinsn | (const insn_t *) instruction
  reg | (int) register index
  Return values
  1 | if implemented, and value was found
  0 | not implemented, -1 decoding failed, or no value found
  ev_find_op_value | Find operand value via a register tracker. The returned value in 'out' is valid before executing the instruction. Parameters
  out | (uval_t *) pointer to the found value
  pinsn | (const insn_t *) instruction
  opn | (int) operand index
  Return values
  1 | if implemented, and value was found
  0 | not implemented, -1 decoding failed, or no value found
  ev_replaying_undo | Replaying an undo/redo buffer. Parameters
  action_name | (const char *) action that we perform undo/redo for. may be nullptr for intermediary buffers.
  vec | (const undo_records_t *)
  is_undo | (bool) true if performing undo, false if performing redo This event may be generated multiple times per undo/redo
  ev_ending_undo | Ended undoing/redoing an action. Parameters
  action_name | (const char *) action that we finished undoing/redoing. is not nullptr.
  is_undo | (bool) true if performing undo, false if performing redo
  ev_set_code16_mode | Some processors have ISA 16-bit mode e.g. ARM Thumb mode, PPC VLE, MIPS16 Set ISA 16-bit mode Parameters
  ea | (ea_t) address to set new ISA mode
  code16 | (bool) true for 16-bit mode, false for 32-bit mode
  ev_get_code16_mode | Get ISA 16-bit mode. Parameters
  ea | (ea_t) address to get the ISA mode
  Return values
  1 | 16-bit mode
  0 | not implemented or 32-bit mode
ev_get_procmod | Get pointer to the processor module object. All processor modules must implement this. The pointer is returned as size_t.
  ev_asm_installed | After setting a new assembler. Parameters
  asmnum | (int) See also ev_newasm
  ev_get_reg_accesses | Get info about the registers that are used/changed by an instruction. Parameters
  accvec | (reg_accesses_t*) out: info about accessed registers
  insn | (const insn_t *) instruction in question
  flags | (int) reserved, must be 0
  Return values
  -1 | if accvec is nullptr
  1 | found the requested access (and filled accvec)
  0 | not implemented
  ev_is_control_flow_guard | Detect if an instruction is a "thunk call" to a flow guard function (equivalent to call reg/return/nop) Parameters
  p_reg | (int *) indirect register number, may be -1
  insn | (const insn_t *) call/jump instruction
  Return values
  -1 | no thunk detected
  1 | indirect call
  2 | security check routine call (NOP)
  3 | return thunk
  0 | not implemented
  ev_broadcast | Broadcast call. Parameters
  magic | (::int64) a magic number Other parameters and the return value depend on the magic
  ev_create_merge_handlers | Create merge handlers, if needed. Parameters
  md | (merge_data_t *) This event is generated immediately after opening idbs.
Returns must be 0
  ev_privrange_changed | Privrange interval has been moved to a new location. Most common actions to be done by module in this case: fix indices of netnodes used by module Parameters
  old_privrange | (const range_t *) - old privrange interval
  delta | (::adiff_t)
  errbuf | (qstring *) - a error message will be returned here (can be nullptr)
Returns 0 Ok -1 error (and message in errbuf)
  ev_cvt64_supval | perform 32-64 conversion for a netnode array element Parameters
  node | (::nodeidx_t)
  tag | (uchar)
  idx | (::nodeidx_t)
  data | (const uchar *)
  datlen | (::size_t)
  errbuf | (qstring *) - a error message will be returned here (can be nullptr)
Returns 0 nothing was done 1 converted successfully -1 error (and message in errbuf)
  ev_cvt64_hashval | perform 32-64 conversion for a hash value Parameters
  node | (::nodeidx_t)
  tag | (uchar)
  name | (const ::char *)
  data | (const uchar *)
  datlen | (::size_t)
  errbuf | (qstring *) - a error message will be returned here (can be nullptr)
Returns 0 nothing was done 1 converted successfully -1 error (and message in errbuf)
  ev_get_regfinder | Get pointer to the regfinder object. This event is called by ::find_reg_value() when it detects that the processor module does not support the ev_find_reg_value event. Returns (::reg_finder_t *) Return values
  0 | reg_finder_t is not supported
  ev_gen_stkvar_def2 | Generate stack variable definition line. Default line is varname = type ptr value, where 'type' is one of byte,word,dword,qword,tbyte Parameters
  outctx | (outctx_t *)
  stkvar | (const udm_t *)
  v | (sval_t)
  tid | (tid_t) stkvar TID
  Return values
  1 | ok
  0 | not implemented
ev_last_cb_before_debugger | START OF DEBUGGER CALLBACKS.
  ev_next_exec_insn | Get next address to be executed This function must return the next address to be executed. If the instruction following the current one is executed, then it must return BADADDR Usually the instructions to consider are: jumps, branches, calls, returns. This function is essential if the 'single step' is not supported in hardware. Parameters
  target | (::ea_t *), out: pointer to the answer
  ea | (::ea_t) instruction address
  tid | (int) current therad id
  getreg | (::processor_t::regval_getter_t *) function to get register values
  regvalues | (const regval_t *) register values array
  Return values
  0 | unimplemented
  1 | implemented
  ev_calc_step_over | Calculate the address of the instruction which will be executed after "step over". The kernel will put a breakpoint there. If the step over is equal to step into or we cannot calculate the address, return BADADDR. Parameters
  target | (::ea_t *) pointer to the answer
  ip | (::ea_t) instruction address
  Return values
  0 | unimplemented
  1 | implemented
  ev_calc_next_eas | Calculate list of addresses the instruction in 'insn' may pass control to. This callback is required for source level debugging. Parameters
  res | (eavec_t *), out: array for the results.
  insn | (const insn_t*) the instruction
  over | (bool) calculate for step over (ignore call targets)
  Return values
  <0 | incalculable (indirect jumps, for example)
  >=0 | number of addresses of called functions in the array. They must be put at the beginning of the array (0 if over=true)
  ev_get_macro_insn_head | Calculate the start of a macro instruction. This notification is called if IP points to the middle of an instruction Parameters
  head | (::ea_t *), out: answer, BADADDR means normal instruction
  ip | (::ea_t) instruction address
  Return values
  0 | unimplemented
  1 | implemented
  ev_get_dbr_opnum | Get the number of the operand to be displayed in the debugger reference view (text mode). Parameters
  opnum | (int *) operand number (out, -1 means no such operand)
  insn | (const insn_t*) the instruction
  Return values
  0 | unimplemented
  1 | implemented
  ev_insn_reads_tbit | Check if insn will read the TF bit. Parameters
  insn | (const insn_t*) the instruction
  getreg | (::processor_t::regval_getter_t *) function to get register values
  regvalues | (const regval_t *) register values array
  Return values
  2 | yes, will generate 'step' exception
  1 | yes, will store the TF bit in memory
  0 | no
  ev_clean_tbit | Clear the TF bit after an insn like pushf stored it in memory. Parameters
  ea | (::ea_t) instruction address
  getreg | (::processor_t::regval_getter_t *) function to get register values
  regvalues | (const regval_t *) register values array
  Return values
  1 | ok
  0 | failed
  ev_get_idd_opinfo | Get operand information. This callback is used to calculate the operand value for double clicking on it, hints, etc. Parameters
  opinf | (idd_opinfo_t *) the output buffer
  ea | (::ea_t) instruction address
  n | (int) operand number
  thread_id | (int) current thread id
  getreg | (::processor_t::regval_getter_t *) function to get register values
  regvalues | (const regval_t *) register values array
  Return values
  1 | ok
  0 | failed
  ev_get_reg_info | Get register information by its name. example: "ah" returns: main_regname="eax" bitrange_t = { offset==8, nbits==8 } This callback may be unimplemented if the register names are all present in processor_t::reg_names and they all have the same size Parameters
  main_regname | (const char **), out
  bitrange | (bitrange_t *), out: position and size of the value within 'main_regname' (empty bitrange == whole register)
  regname | (const char *)
  Return values
  1 | ok
  -1 | failed (not found)
  0 | unimplemented
  ev_update_call_stack | Calculate the call stack trace for the given thread. This callback is invoked when the process is suspended and should fill the 'trace' object with the information about the current call stack. Note that this callback is NOT invoked if the current debugger backend implements stack tracing via debugger_t::event_t::ev_update_call_stack. The debugger-specific algorithm takes priority. Implementing this callback in the processor module is useful when multiple debugging platforms follow similar patterns, and thus the same processor-specific algorithm can be used for different platforms. Parameters
  stack | (call_stack_t *) result
  tid | (int) thread id
  getreg | (::processor_t::regval_getter_t *) function to get register values
  regvalues | (const regval_t *) register values array
  Return values
  1 | ok
  -1 | failed
  0 | unimplemented
  ev_setup_til | Setup default type libraries. (called after loading a new file into the database). The processor module may load tils, setup memory model and perform other actions required to set up the type system. This is an optional callback. Parameters
  none |
  Return values
  void |
  ev_get_abi_info | Get all possible ABI names and optional extensions for given compiler abiname/option is a string entirely consisting of letters, digits and underscore. Parameters
  abi_names | (qstrvec_t *) - all possible ABis each in form abiname-opt1-opt2-...
  abi_opts | (qstrvec_t *) - array of all possible options in form "opt:description" or opt:hint-line#description
  comp | (comp_t) - compiler ID
  Return values
  0 | not implemented
  1 | ok
  ev_max_ptr_size | Get maximal size of a pointer in bytes. Parameters
  none |
Returns max possible size of a pointer
ev_get_default_enum_size | Get default enum size. Not generated anymore. inf_get_cc_size_e() is used instead
  ev_get_cc_regs | Get register allocation convention for given calling convention. Parameters
  regs | (callregs_t *), out
  cc | (cm_t)
  Return values
  1 |
  0 | not implemented
ev_obsolete1 | ev_get_stkarg_offset is obsolete. See ev_get_stkarg_area_info
ev_obsolete2 | ev_shadow_args_size is obsolete. See ev_get_stkarg_area_info
  ev_get_simd_types | Get SIMD-related types according to given attributes ant/or argument location. Parameters
  out | (::simd_info_vec_t *)
  simd_attrs | (const simd_info_t *), may be nullptr
  argloc | (const argloc_t *), may be nullptr
  create_tifs | (bool) return valid tinfo_t objects, create if neccessary
  Return values
  number | of found types
  -1 | error If name==nullptr, initialize all SIMD types
  ev_calc_cdecl_purged_bytes | Calculate number of purged bytes after call. Parameters
  ea | (::ea_t) address of the call instruction
Returns number of purged bytes (usually add sp, N)
  ev_calc_purged_bytes | Calculate number of purged bytes by the given function type. Parameters
  [out] | p_purged_bytes | (int *) ptr to output
  | fti | (const func_type_data_t *) func type details
  Return values
  1 |
  0 | not implemented
  ev_calc_retloc | Calculate return value location. Parameters
  [out] | retloc | (argloc_t *)
  | rettype | (const tinfo_t *)
  | cc | (cm_t)
  Return values
  0 | not implemented
  1 | ok,
  -1 | error
  ev_calc_arglocs | Calculate function argument locations. This callback should fill retloc, all arglocs, and stkargs. This callback is never called for CM_CC_SPECIAL functions. Parameters
  fti | (func_type_data_t *) points to the func type info
  Return values
  0 | not implemented
  1 | ok
  -1 | error
  ev_calc_varglocs | Calculate locations of the arguments that correspond to '...'. Parameters
  | ftd | (func_type_data_t *), inout: info about all arguments (including varargs)
  [out] | aux_regs | (regobjs_t *) buffer for hidden register arguments, may be nullptr
  [out] | aux_stkargs | (relobj_t *) buffer for hidden stack arguments, may be nullptr
  | nfixed | (int) number of fixed arguments
  Return values
  0 | not implemented
  1 | ok
  -1 | error On some platforms variadic calls require passing additional information: for example, number of floating variadic arguments must be passed in rax on gcc-x64. The locations and values that constitute this additional information are returned in the buffers pointed by aux_regs and aux_stkargs
  ev_adjust_argloc | Adjust argloc according to its type/size and platform endianess. Parameters
  argloc | (argloc_t *), inout
  type | (const tinfo_t *), may be nullptr nullptr means primitive type of given size
  size | (int) 'size' makes no sense if type != nullptr (type->get_size() should be used instead)
  Return values
  0 | not implemented
  1 | ok
  -1 | error
  ev_lower_func_type | Get function arguments which should be converted to pointers when lowering function prototype. The processor module can also modify 'fti' in order to make non-standard conversion of some arguments. Parameters
  argnums | (intvec_t *), out - numbers of arguments to be converted to pointers in acsending order
  fti | (func_type_data_t *), inout func type details
  Return values
  0 | not implemented
  1 | argnums was filled
  2 | argnums was filled and made substantial changes to fti argnums[0] can contain a special negative value indicating that the return value should be passed as a hidden 'retstr' argument: -1 this argument is passed as the first one and the function returns a pointer to the argument, -2 this argument is passed as the last one and the function returns a pointer to the argument, -3 this argument is passed as the first one and the function returns 'void'.
  ev_equal_reglocs | Are 2 register arglocs the same?. We need this callback for the pc module. Parameters
  a1 | (argloc_t *)
  a2 | (argloc_t *)
  Return values
  1 | yes
  -1 | no
  0 | not implemented
  ev_use_stkarg_type | Use information about a stack argument. Parameters
  ea | (::ea_t) address of the push instruction which pushes the function argument into the stack
  arg | (const funcarg_t *) argument info
  Return values
  1 | ok
  <=0 | failed, the kernel will create a comment with the argument name or type for the instruction
  ev_use_regarg_type | Use information about register argument. Parameters
  [out] | idx | (int *) pointer to the returned value, may contain: idx of the used argument, if the argument is defined in the current instruction, a comment will be applied by the kernel idx | REG_SPOIL - argument is spoiled by the instruction -1 if the instruction doesn't change any registers -2 if the instruction spoils all registers
  | ea | (::ea_t) address of the instruction
  | rargs | (const funcargvec_t *) vector of register arguments (including regs extracted from scattered arguments)
  Return values
  1 |
  0 | not implemented
  ev_use_arg_types | Use information about callee arguments. Parameters
  ea | (::ea_t) address of the call instruction
  fti | (func_type_data_t *) info about function type
  rargs | (funcargvec_t *) array of register arguments
  Return values
  1 | (and removes handled arguments from fti and rargs)
  0 | not implemented
  ev_arg_addrs_ready | Argument address info is ready. Parameters
  caller | (::ea_t)
  n | (int) number of formal arguments
  tif | (tinfo_t *) call prototype
  addrs | (::ea_t *) argument intilization addresses
  Return values
  <0 | do not save into idb; other values mean "ok to save"
  ev_decorate_name | Decorate/undecorate a C symbol name. Parameters
  outbuf | (qstring *) output buffer
  name | (const char *) name of symbol
  mangle | (bool) true-mangle, false-unmangle
  cc | (cm_t) calling convention
  type | (const tinfo_t *) name type (nullptr-unknown)
  Return values
  1 | if success
  0 | not implemented or failed
  ev_arch_changed | The loader is done parsing arch-related information, which the processor module might want to use to finish its initialization. Return values
  1 | if success
  0 | not implemented or failed
  ev_get_stkarg_area_info | Get some metrics of the stack argument area. Parameters
  [out] | out | (stkarg_area_info_t *) ptr to stkarg_area_info_t
  | cc | (cm_t) calling convention
  Return values
  1 | if success
  0 | not implemented
ev_loader | This code and higher ones are reserved for the loaders. The arguments and the return values are defined by the loaders

## Member Function Documentation

## ◆ get_default_segm_bitness()

int processor_t::get_default_segm_bitness | ( | bool | is_64bit_app | ) | const
| inline

Get default segment bitness.

Return values

  2 | PR_DEFSEG64
  1 | PR_DEFSEG32
  0 | none specified

## ◆ get_proc_index()

int processor_t::get_proc_index | ( | void |  | ) |
| inline

Return values

  currently | selected processor subtype (index into psnames/plnames)

## ◆ get_reg_info()

const char * processor_t::get_reg_info | ( | const char * | regname,
|  | bitrange_t * | bitrange
| ) |  |
| inline static

Get register information - useful for registers like al, ah, dil, etc.

Example: this function for "al" returns "eax" in 32bit mode

Returns
  main register name (nullptr no such register)

## ◆ get_stkvar_scale()

int processor_t::get_stkvar_scale | ( | void |  | ) |
| inline

Get the stack variable scaling factor.

Useful for processors who refer to the stack with implicit scaling factor. TMS320C55 for example: SP(#1) really refers to (SP+2)

## ◆ is_canon_insn()

bool processor_t::is_canon_insn | ( | uint16 | itype | ) | const
| inline

Does the given value specify a valid instruction for this instruction set?.

See instruc_start and instruc_end

## Member Data Documentation

## ◆ cnbits

int32 processor_t::cnbits

Number of bits in a byte for code segments (usually 8).

IDA supports values up to supported address bits size

## ◆ dnbits

int32 processor_t::dnbits

Number of bits in a byte for non-code segments (usually 8).

IDA supports values up to supported address bit size

## ◆ psnames

const char* const* processor_t::psnames

short processor names (nullptr terminated).

Each name should be shorter than 9 characters

## ◆ plnames

const char* const* processor_t::plnames

long processor names (nullptr terminated).

No restriction on name lengths.

## ◆ assemblers

const asm_t* const* processor_t::assemblers

pointer to array of target

assembler definitions. You may change this array when current processor is changed. (nullptr terminated)

## ◆ codestart

const bytes_t* processor_t::codestart

Array of typical code start sequences.

This array is used when a new file is loaded to find the beginnings of code sequences. This array is terminated with a zero length item.

## ◆ retcodes

const bytes_t* processor_t::retcodes

Array of 'return' instruction opcodes.

This array is used to determine form of autogenerated locret_... labels. The last item of it should be { 0, nullptr } This array may be nullptr Better way of handling return instructions is to define the is_ret_insn callback in the notify() function

## ◆ real_width

char processor_t::real_width[4]

Number of digits in floating numbers after the decimal point.

If an element of this array equals 0, then the corresponding floating point data is not used for the processor. This array is used to align numbers in the output.

- real_width[0] - number of digits for short floats (only PDP-11 has them)
- real_width[1] - number of digits for "float"
- real_width[2] - number of digits for "double"
- real_width[3] - number of digits for "long double"

Example: IBM PC module has { 0,7,15,19 }

The documentation for this struct was generated from the following files:

- idp.hpp
- frame.hpp
- typeinf.hpp